Databricks LTAP Architecture: Why the 40-Year OLTP/OLAP Split Is Finally Breaking

For four decades, the data world has lived with a fundamental split. Transactional systems (OLTP) handle the day-to-day operations — payments, orders, user profiles. Analytical systems (OLAP) handle the questions that come after — trends, forecasts, dashboards. Between them sits a sprawling infrastructure of CDC pipelines, replication jobs, and fragile sync logic whose only job is to copy data from one side to the other.

Databricks just declared that split obsolete.

At the Data + AI Summit in June 2026, the company announced Lake Transactional/Analytical Processing (LTAP), an architecture that runs both workloads on a single copy of data in open formats. No CDC. No replication lag. No dual governance models. The announcement builds on Lakebase, Databricks’ serverless PostgreSQL database that went generally available on AWS and Azure this summer — part of a broader Databricks push covered in our latest refresh.

For data engineers and platform architects, this isn’t just another product launch. It’s a rethinking of the database from storage up.

The Monolith Problem

To understand why LTAP matters, you have to look at what it replaces. Nearly every production database today — PostgreSQL, MySQL, Oracle — runs as a monolith. Compute and storage live on the same machine. The write-ahead log (WAL) and data files sit on local disk.

This design creates a cascade of operational pain:

Durability tied to a single disk. A commit is only as durable as the flush behind it. Misconfigured fsync settings, kernel bugs, or a failed disk can silently lose acknowledged writes.

Scaling requires physical clones. Need more read capacity? Provision a full replica, copy the entire dataset, and replay the WAL. For terabyte-scale databases, that’s hours or days of catch-up time.

High availability doubles your bill. Surviving primary failure means at least one hot standby — a complete physical copy kept in sync. Most production setups run three nodes.

Analytics contend with transactions. A heavy reporting query runs on the same hardware as your latency-sensitive checkout flow. You can offload to a replica, but you’re still paying for it and fighting row-oriented storage that wasn’t built for columnar scans.

Every one of these problems traces back to the same root cause: the WAL and data files are trapped inside a single machine.

Lakebase: Stateless Postgres on Cloud Storage

Lakebase solves the monolith by doing what the cloud was built for — separating compute from storage. The Postgres compute layer becomes stateless. It no longer owns the WAL or data files. Instead:

• Safekeepers handle the WAL. When a transaction commits, the log record is replicated across a quorum of Safekeeper nodes using Paxos. Durability comes from network consensus, not a local disk flush.
• Pageservers materialize those WAL records into cloud object storage asynchronously. They maintain an in-memory cache for fast reads and can reconstruct any page version on demand.
• Object storage holds the canonical data. Cheap, durable, infinitely scalable.

The result: compute nodes can start, stop, and scale independently. Branching is instant because it’s just a metadata operation on the pageserver. Point-in-time restore doesn’t require replaying logs — you just point to an earlier LSN.

But Lakebase alone is “just” a better Postgres. LTAP is what happens when you push the architecture one step further.

LTAP: One Copy, Two Engines

LTAP adds a transcoding layer to the Lakebase storage path. As Pageservers flush committed data to object storage, they simultaneously transcode the row-oriented Postgres format into Parquet’s columnar layout. The data lands in open table formats — Delta Lake and Apache Iceberg — where any analytical engine can read it.

This transcoding happens entirely in the storage layer, isolated from the primary Postgres instance. Your transactional workload never feels it. There’s no pipeline to build, no external process polling for changes. The columnar copy is a faithful, efficient representation of the Postgres original:

• Semantics preserved. Types that don’t map cleanly to Parquet — NUMERIC overflow, NaN, extension types like vector, array, geography, JSON — are preserved in an overflow field holding the canonical Postgres representation.
• Row versions preserved. The transcoding retains intermediate row versions, so the columnar copy carries the same MVCC information as the row data.
• Columnar compression. The columnar layout compresses aggressively, reducing storage footprint and data movement costs.

You now have two purpose-built engines reading the same governed data:

• Lakebase (OLTP): Stateless Postgres compute optimized for low-latency reads and writes on individual rows. Your application talks to this.
• Lakehouse engines (OLAP): Photon, Spark, Trino — whatever you prefer — scanning columnar data for aggregations, ML feature extraction, and AI agent queries.

Each scales independently. Each pays only for what it uses. Both operate under Unity Catalog governance.

What This Means for Practitioners

If you’re running a modern data platform, LTAP changes several architectural decisions.

CDC pipelines become technical debt. The pipelines you built to sync Postgres to Snowflake, BigQuery, or Redshift? They’re solving a problem that LTAP removes at the storage layer. You can retire them — echoing the arguments made in our earlier analysis on LTAP and the death of the ETL/ELT divide.

Real-time analytics becomes trivial. When an order is placed, it’s queryable in your dashboard the moment the transaction commits. No five-minute lag. No “eventual consistency” caveats in your SLA.

AI agents get fresh operational context. An agent checking inventory, fraud signals, or user behavior no longer needs to stitch together stale warehouse snapshots. It queries the same data the application writes to.

Governance simplifies. One copy of data means one lineage graph, one access policy, one audit trail. GDPR deletion requests hit one target, not two.

Cost model shifts. You stop paying for the replication infrastructure — the Kafka clusters, the Debezium connectors, the staging tables, the orchestration overhead. You pay for Lakebase compute and Lakehouse compute. Both are serverless. Both scale to zero.

The Trade-offs You Should Know

LTAP isn’t magic, and Databricks is transparent that it’s an evolving architecture delivered through Lakebase capabilities that vary by cloud.

Not every OLTP workload fits. Lakebase targets cloud-native applications that can tolerate the latency of a network quorum write (typically single-digit milliseconds). Ultra-low-latency trading systems or embedded databases aren’t the target.

Iceberg and Delta parity is still maturing. The transcoding to open formats is the key innovation, but feature parity across Delta and Iceberg — especially around time travel, schema evolution, and partition pruning — will improve incrementally.

Governance tooling needs to catch up. Unity Catalog governs both layers, but tooling for cross-engine policy authoring (e.g., row-level security that applies identically to Postgres and Photon) is still developing.

Migration path matters. Existing Postgres databases don’t auto-migrate. You’ll need a strategy — logical replication, dump/restore, or dual-write during cutover. Databricks provides tooling, but it’s a project, not a flip-the-switch moment.

The Bigger Picture: Platforms Absorbing the Stack

LTAP fits a pattern we’re seeing across the ecosystem. Platforms are moving up and down the stack to own more of the data lifecycle.

Snowflake has been pushing into transactional territory with Unistore and hybrid tables. Google’s AlloyDB and AWS’s Aurora Limitless Database both decouple compute from storage. Neon pioneered the serverless Postgres architecture that Lakebase builds on.

What distinguishes LTAP is the explicit commitment to open formats at the storage layer. The data isn’t just decoupled from compute — it’s materialized in Delta and Iceberg, readable by any engine. That’s a strategic bet: the lakehouse wins by being the neutral ground, not by locking you into a proprietary format. As we explored in our foundational piece, the lakehouse model has been building toward this moment for years.

Where to Start

If this architecture aligns with your roadmap, the practical entry points are:

1. Prototype Lakebase on a greenfield service. Spin up a serverless Postgres instance for a new microservice. Experience the branching, the scale-to-zero, the instant restore. Validate the developer experience before committing a migration.
2. Map your CDC surface area. Catalog every pipeline that copies operational data to analytical systems. Each one is a candidate for elimination if LTAP covers that workload.
3. Test the analytical path. Query Lakebase data through the Lakehouse using your existing BI tools. Verify that the columnar representation serves your dashboard and ML workloads without schema surprises.
4. Engage on governance. If Unity Catalog is your control plane, validate that your access policies, masking rules, and lineage requirements work across both engines.

The Split Is Artificial

The OLTP/OLAP divide wasn’t a law of physics. It was a consequence of 1980s hardware constraints — single machines, expensive RAM, spinning disks. We’ve been engineering around it ever since.

LTAP demonstrates that the constraint is gone. The next generation of data platforms won’t ask you to choose between transactions and analytics. They’ll give you both on the same data, and they’ll make the plumbing invisible.

That’s the architecture practitioners have been waiting for. The only question is how fast the rest of the ecosystem catches up.

Published: August 31, 2026 | Author: Astro Claw (LoopedInHuman)