# Databricks Lakebase: why Databricks bought a Postgres to serve apps

> Databricks bought Neon in May 2025 and now headlines Lakebase in funding releases. The lakehouse needed a real database, and that says where apps are going.

By TechFabric, 12 September 2026, updated 14 October 2026. Databricks Field Guide, TechFabric. Canonical: https://databricks.techfabric.com/notes/databricks-bought-a-postgres/

On 14 May 2025 Databricks announced it would acquire Neon, a serverless Postgres company. Fifteen months later Lakebase, the product Neon became, is named in the headline of the company's [August 2026 funding release](https://www.databricks.com/company/newsroom/press-releases/databricks-grows-80-yoy-surpasses-7b-revenue-run-rate-scales) as one of three products the new capital goes into. That is a fast promotion for a database, and it tells you what the lakehouse was missing.

## Where the lakehouse stopped

A lakehouse is very good at the analytical half of a company's data. Tables in object storage, one catalog, cheap to keep everything, and a query engine that scales to whatever you point it at. What it was never built for is an application: a screen that reads one customer's record and writes it back in the time it takes a person to blink. Every team that tried to build an app straight on the lakehouse learned this on the second day, and every one of them then ran a Postgres beside it with a copy job between the two. Two systems, one sync, and a permissions model that had to be maintained twice.

## What Lakebase is

Buying Neon was Databricks admitting that. Lakebase is a real Postgres, registered in [Unity Catalog](https://databricks.techfabric.com/guide/unity-catalog/), with lakehouse tables synced into it and the operational data living beside the analytics under one set of grants. The stack most teams run as three systems and two copy jobs collapses into one, and an agent answering questions over the same data inherits the user's permissions instead of a prompt telling it what not to say.

> **Our position**: If you're building an application on Databricks in 2026 and reaching for a separate database out of habit, stop and read the [Lakebase chapter](https://databricks.techfabric.com/guide/lakebase/) first. The habit was correct in 2024. The cases where we'd still keep a separate database are real, and they're narrower than they were: very high write rates, an application that has to run when the workspace doesn't, and anything where the Postgres extension you depend on isn't there yet.

## Built in a room

We built an application on Lakebase live at the first [Gilbert Databricks User Group](/events/) session on 18 September 2026, in front of a room, with the seams left visible. The recording goes on the events page afterwards. The honest edges, meaning what's generally available and what's still in preview, are in the chapter and were in the room, because a recommendation that can't say where it stops isn't one.

## Where the money goes next

Three products got named in that release, Lakebase, Genie and Unity Gateway, and all three sit closer to the end user than anything the company sold in 2023. The platform is moving from where data is kept to where it's used, and the applications and agents on top of it are where the [Databricks Apps](https://databricks.techfabric.com/guide/databricks-apps/) and [Agents](https://databricks.techfabric.com/guide/agents/) chapters now spend most of their words.

## Update, 8 October 2026

Databricks published a walkthrough on 8 October 2026 for [building apps with Replit and Lakebase](https://www.databricks.com/blog/how-build-governed-enterprise-apps-databricks-replit-and-lakebase), and the mechanism in it is the argument this note makes, running in a product. A business user describes an app in plain language, Replit Agent builds the front end, and when the app deploys to Databricks Apps the agent auto-provisions a managed Lakebase Postgres for the app's own operational data. The app reads live analytical data from Databricks and writes its own records back to Lakebase.

Replit [announced the integration as generally available with native Lakebase support on 10 September 2026](https://replit.com/blog/databricks2026). That general availability statement is Replit's, and Databricks' [own documentation for connecting Replit](https://docs.databricks.com/aws/en/integrations/replit) gives no release status either way.

Worth reading the documentation before the blog, because the setup is less magical than the prose. The connection runs through a service principal with an OAuth secret and an existing SQL warehouse the principal can manage. So the identity doing the querying from Replit is a service principal, and the person who typed the prompt never appears in the audit trail at all. That distinction matters the first time someone asks who ran a query.

Our position doesn't move, it gets sharper.

Databricks is now letting a third-party coding agent create Postgres databases inside customer tenants, which is the clearest signal yet that Lakebase is meant to be the default operational store for anything built on the platform. If you run a Databricks account, decide now which groups may deploy apps this way and what a Replit-provisioned Lakebase project is allowed to hold, because the provisioning step is the one your platform team no longer sees.

## Update, 15 October 2026

The Lakebase argument in this note was about collapsing two systems into one. Search was the piece most likely to put a third one back, and Databricks has now closed it. [Lakebase Search](https://docs.databricks.com/aws/en/oltp/projects/lakebase-search) is generally available, and in a post on 15 October 2026 the team published [sizing numbers from Slide Hub](https://www.databricks.com/blog/sizing-lakebase-search-lessons-real-app-and-4-million-passages), an internal Databricks app searching about 700 presentations. Two `CREATE EXTENSION` statements turn it on. `lakebase_vector` gives approximate nearest-neighbour search through the `lakebase_ann` index type, drop-in compatible with pgvector, and `lakebase_text` gives BM25 through `lakebase_bm25`. The documentation, last updated on 23 September 2026, says the vector indexes are storage-backed and survive scale-to-zero without warmup.

Two figures decide a sizing conversation. Databricks reports that matching the Local File Cache roughly to the size of the vector index keeps 95~98% of pages in memory and brings warm vector latency into single-digit milliseconds, and that cutting the candidate pool from 1,000 to 200 keeps 90.5% of top-10 results at a third of the page reads. On cost, a 14-minute load test serving 109k requests used $0.02 of Lakebase Postgres compute, and the post recommends an always-on 0.5 CU floor at $31~40 a month to avoid cold starts. That floor is the number we'd put in a design document, and the first Gilbert user group session gives the reason: a cold endpoint answered in 2,979 ms against 1,650 ms warm.

Our position doesn't move, it loses a caveat. The separate-database cases this note names still stand, but "the search engine lives elsewhere" is no longer one of them.

```mermaid How search moved into the application database
flowchart LR
  A["App queries"] --> B["Lakebase Postgres"]
  B --> C["Separate search system"]
  C --> D["Copy job and second transaction path"]
  A --> E["Lakebase Postgres with lakebase_vector and lakebase_text"]
  E --> F["Hybrid results in one SQL query"]
```
