Skip to content

Databricks Lakebase: Postgres Beside the Lakehouse

Painterly photo of a technician in a red plaid shirt working on a laptop on the floor beside a dark server rack full of cables in a data centre

Lakebase is Databricks' managed Postgres service. It runs next to the lakehouse on the same storage foundation. It shuts its compute down when nobody queries it, and it can branch a full copy of a production database in seconds. Databricks presents it as the transactional half of one platform, with Delta tables and Unity Catalog on the analytical side.

The service is more specific than the marketing suggests. It is ordinary Postgres with a managed control plane around it. The interesting part is where that control plane stops.

The gap Lakebase targets

A Databricks SQL warehouse is built for large scans. A customer portal asks a different question: thousands of small lookups per second, each answered in milliseconds. Every write needs full ACID guarantees.

Those workloads have lived in a separate database for decades. A pipeline usually sat in between to keep both sides in sync.

Lakebase is the attempt to remove that second platform. Databricks announced it in June 2025, weeks after saying it would acquire Neon, the serverless Postgres company. Reports put that deal at about one billion dollars (CNBC). Lakebase packages that architecture, and the same Postgres service is also sold on Neon's own platform.

A standard Postgres, with the usual extensions

There is no new SQL dialect and no fork to learn. Lakebase runs Postgres 16, 17 or 18, with 17 as the default. The extension list includes pgvector 0.8 for embeddings, PostGIS 3.6 for spatial data, pgRouting, hll, pg_trgm, pg_stat_statements and pgcrypto.

Existing drivers, ORMs and migration tools work as they are. A psql prompt against a Lakebase branch looks like a psql prompt anywhere else.

Storage and compute are decoupled

A project holds branches, databases, roles and computes. Each branch gets one read-write compute. Read replicas serve reads from that same storage, and a high availability endpoint goes further: it runs the primary plus one to three secondaries in different availability zones and promotes one automatically when the primary fails, with the connection string unchanged and an SLA behind it. Sizing is expressed in Compute Units. One CU brings about 2 GB of RAM plus the matching CPU and local SSD. The size also caps the connections: 218 at 1 CU, and a hard ceiling of 3,993 from 24 CU upwards.

Autoscaling sizes one compute anywhere between 0.5 and 64 CU, watching CPU load, memory use and the working set size. The window you configure is far narrower: the difference between the minimum and the maximum cannot exceed 16 CU. A compute that has to absorb a 60 CU peak therefore cannot idle at 0.5 CU. Sizes from 65 to 112 CU exist as fixed computes. You reach those through the Postgres API, Terraform or the SDK rather than the UI.

Scale to zero is the other half of the cost model. An idle compute suspends after a timeout. You set it between 60 seconds and 7 days. The default is 24 hours. The next query wakes it in a few hundred milliseconds, and connection strings stay valid while it sleeps. Only active compute time is billed. The feature has two conditions: it works only on a compute whose maximum is 32 CU or smaller, and it is not available on a high availability endpoint at all.

That mechanism has a price of its own. Suspending a compute closes its connections. Anything living in the session disappears with them: temporary tables, prepared statements, advisory locks, LISTEN and NOTIFY, the connection pool and any transaction in flight. The statistics split: counters in pg_stat_user_tables survive a suspend, the data collected by pg_stat_statements does not. Workloads that need the session state must keep scale to zero switched off. The compute then runs around the clock, and a client needs retry logic for the first query after a wake-up.

Branches and point-in-time recovery

Every project starts with a root branch called production. Further branches hang off it in a tree. A child inherits the schema and the data of its parent through copy-on-write pointers. Creating one takes seconds and copies no storage. Only blocks that change are written.

Children stay isolated. Schema changes, role grants and data edits on one branch do not touch its parent or its siblings. That makes per-developer branches and agent sandboxes practical. A branch can also start from any point in the parent's restore window. Point-in-time recovery and historical testing use the same mechanism. The storage saving lasts only while a branch is short-lived: a branch without an expiration is billed for its full data size.

Unity Catalog: a read-only catalog, not magic

Registering a Lakebase database in Unity Catalog creates a catalog of type Lakebase Postgres. It mirrors the schemas, tables and views of the database. Permissions, lineage and audit logs then run through the same control layer as Delta tables. One SQL interface can query the data next to analytical tables.

Two details matter in practice. The catalog is read-only. You manage the database in Lakebase, and Unity Catalog syncs the metadata, so a new table shows up after a refresh.

The second detail is compute. Querying the catalog needs serverless compute: a serverless SQL warehouse, or serverless compute for notebooks and jobs. A Pro or classic warehouse fails with UC_LAKEBASE_CATALOG_ACCESS_DENIED. That error is confusing if you did not expect the restriction.

Four patterns the service is built for

Serving lakehouse data. Synced tables copy a Unity Catalog table into Postgres through a managed Lakeflow pipeline. You pick a Gold table, meaning one from the curated layer of the lakehouse, or a feature table, and choose continuous, triggered or snapshot sync. What lands in Postgres is meant to be read: apps query the copy by key, and writing to it is technically possible but expressly discouraged, because a write drifts from the source of truth that the next sync assumes. Continuous mode keeps the copy within seconds of the source.

A beta option, LTAP Direct Writes, sends the bulk load straight to the storage layer of the branch instead of through the live compute. Those loads skip the compute endpoint, so they finish faster and add no query load while they run.

Operational data back into the lakehouse. Lakebase Change Data Feed reads the Postgres write-ahead log. Every insert, update and delete becomes a row in a Unity Catalog managed Delta table, batched roughly every 15 seconds. Rows carry _pg_change_type, an LSN, a transaction ID and a timestamp, in the same shape as Delta Change Data Feed. That removes the Debezium or Kafka connector from the audit-trail story. Tables need REPLICA IDENTITY FULL, so the log holds both the old and the new row. The feature is in Public Preview.

An application backend. Any Postgres client connects, including Databricks Apps. Autoscaling absorbs traffic spikes without dropping connections, as long as the compute stays awake. Branching replaces the seeding scripts that development environments usually need.

Agents and machine learning. Agents built with LangGraph or the OpenAI Agents SDK can keep conversation state in Postgres, next to the tables they read. Models served through Model Serving fetch real-time features from an online feature store backed by Lakebase. No separate Redis or DynamoDB cluster is needed.

Where the architecture stops

The managed model removes things people rely on. There is no superuser and no access to the host operating system, so features that demand either are out. Postgres logs are not accessible. Parameters can be set at session, database or role level, but not at instance level. Unlogged and temporary tables live on the local disk of the compute. They do not survive a restart or a scale-to-zero cycle.

Storage is not a disk on the compute. Lakebase keeps the data in a distributed layer that writes through to Databricks-managed object storage, so no single machine holds the authoritative copy and a compute failure, restart or failover loses no committed transaction. Databricks puts the ceiling at 8 TB per instance, which is ample for serving and agent workloads and far too small to archive raw history. That stays in Delta Lake and object storage.

Change Data Feed is a preview, and a workspace admin has to enable it. Teams that plan an audit trail around it should check the status in their own workspace first.

The lock-in is partial. The engine is standard Postgres, and logical replication is the documented way to move an existing database in. What you cannot take elsewhere is the layer around it: branching, the sync pipelines, autoscaling, scale to zero and the Unity Catalog integration. Leaving means rebuilding all of it.

A core ledger is a different matter. With unusual extensions, a superuser requirement or transactions that span systems outside Databricks, a dedicated cloud Postgres gives more control. Lakebase competes for work that sits close to analytics. It is not the database of record.

When it fits

The service fits when the analytical data already lives on Databricks. An application, an agent or a model then needs that data with millisecond latency. It also fits when operational writes should land as Delta tables without an external CDC stack. A workspace that already has identity and billing in place gets a database with little setup.

It makes less sense as a general-purpose operational database for a team that does not use the lakehouse. Most of the value sits in the integration.

Sources