Data Engineering · 5 min read
Lakebase routes 99.99999% of Postgres reads around object storage
Lakebase says tiered caches keep more than 99.99999% of Postgres page reads off object storage, with about 1.1 billion local accesses per second and cold misses as the exception.
Key takeaways
- More than 99.99999% of page accesses bypassed object storage in Lakebase’s production sample.
- The compute local cache handled 99.46%, or about 1.1 billion page accesses per second.
- Pageserver NVMe handled about 6 million reads per second; object storage handled about 39 requests per second, or roughly 1 in 28 million accesses.
- In us-east-1, p90 was below one delta per GetPage and p99 was around six.
- Lakebase cites 99.999999999% durability for S3-style object storage.

By Grace Kim
More than 99.99999% of Lakebase Postgres page reads bypass object storage in production, according to Lakebase’s own fleet analysis. Object storage handled roughly 39 requests per second, not the active read path.
Lakebase separates where data lives from where routine pages come from. “The premise is right, but the conclusion isn’t,” the company says. Postgres issues many small, latency-sensitive reads, while object storage is built for larger requests at higher latency; one read can take hundreds of milliseconds. Local tiers need not make storage answer hot queries. Architecture, not magic.
What do the production numbers show?
In its sampled fleet, every page read was served by the first tier holding it:
- Compute local cache: ~1.1 billion page accesses per second, 99.46% of the total. These never leave the compute node and deliver memory or microsecond-level latency, comparable to a traditional Postgres with a warm cache.
- Pageserver local NVMe: ~6 million reads per second, 0.54% of the total, serving cache misses without object storage.
- Object storage: ~39 requests per second, roughly 1 in 28 million page accesses.
More than 99.99999% of accesses come from local caches on compute and pageservers. Object-storage requests typically involve old branches, restores, or databases waking after weeks idle. Once fetched, data enters local caches, so later reads stay local.
What does object storage still contribute?
Lakebase still treats S3-style object storage as the durable foundation, not the query path. Its claimed benefits are operational as much as technical:
- Durability: Object storage such as S3 is designed for 99.999999999% durability, so durable state does not depend on one machine.
- Bottomless storage: Capacity grows with the data, with no disks to size and no risk of running out of space.
- Immutable, addressable history: Immutable layer files make branches and instant restores metadata operations, without copying data.
- Stateless compute: Durable state stays outside compute, which can scale to zero and restart without moving data.
- One copy for transactions and analytics: Operational data in the lake can feed analytical engines through LTAP.
How does the read path work?\n
Compute runs standard Postgres with hot pages in a local cache and no durable state; it can start, stop, scale, or fail without risking data. The storage layer owns correctness, durability and history through three components:
- Safekeepers replicate the write-ahead log. A transaction commits after a quorum acknowledges its WAL record; a Paxos-based protocol handles leader election and failover.
- Pageservers turn WAL into pages, maintain an LSM tree on local NVMe, and asynchronously persist materialized history to object storage.
- Object storage holds immutable, long-term history and backs pageservers; “Postgres never reads from it directly,” Lakebase says.
On a compute-cache miss, Lakebase sends GetPage@LSN to a pageserver, requesting the named page as it existed at that log sequence number. The pageserver usually has the required layers on local NVMe; only a deeper miss reaches object storage. Compute caches pages returned by pageservers, while pageservers cache layers fetched from object storage, so the deeper cost is paid once.
Why do pageserver misses matter?\n
The pageserver stores two layer types. An image layer holds a snapshot of every page in a key range at one LSN; a delta layer holds WAL records for that key range across a range of LSNs.
To resolve GetPage@LSN, it starts at the requested page and LSN, walks down through layers collecting deltas for that page, stops at the first image, replays the deltas and returns the result.
The number of deltas measures read work. Zero means the page comes straight from an image; many mean a long WAL chain must be replayed.
Across the us-east-1 fleet, p90 stayed below one delta per GetPage, so most requests were served straight from an image without replay. p99 fell to around six after Lakebase began creating base-page images more eagerly, placing them closer to requested LSNs and shortening WAL chains.
When does object storage enter the path?\n
Two cases account for practically every object-storage request. Branches or restores can point to history missing from pageserver NVMe. A branch is a pointer to an LSN; point-in-time and snapshot restores create a new branch at that LSN rather than rewrite the current one. A far-past restore can trigger first-read fetches from object storage.
A database scaled to zero for weeks also wakes without cached data, sending first reads to object storage. Only those first reads pay the deeper-tier cost; afterward, active queries follow the local path, keeping object storage out of their critical path.
What should data teams measure?\n
Treat Lakebase’s figures as a design pattern, not a universal guarantee: the company supplies its own production sample, and cold first touches can expose the design’s limits.
- Treat object storage as the durable tier; design explicit local caches instead of assuming read-through object storage meets latency goals.
- Instrument cache hits, object misses and delta replay by
GetPage@LSN, not just average query latency. - Test branch restores, point-in-time and snapshot recovery, and weeks-long scale-to-zero wake-ups.
- Measure first-touch and steady-state latency separately, including p90 and p99.
Lakebase does not make object storage fast. It keeps storage mostly off hot reads, at the cost of cache coordination and a cold first touch. In its sample, 99.46% never leaves compute and about 39 requests per second reach storage. Efficient, if the cache behaves.
Databricks Blog (Source)
More from Grace Kim
Show full bio
Market editor covering companies, deals and strategy in Analytics Digest is a professional daily at Analytics Digest.
18 articles