Technology1 min read

Built on object storage, served from cache

By · Published by Everything Blog

In short

Lakebase Postgres fulfills page requests from the fastest available layer to keep operations responsive despite using object storage as its primary baseline. Local compute caches absorb the vast majority of traffic at microsecond speeds, while network-connected pageservers resolve most compute misses using local NVMe drives. Direct object storage fetches account for roughly 39 requests per second, or about 1 in every 28 million accesses. These infrequent fetches are predominantly reserved for edge scenarios such as database restores or waking instances that have been idle for weeks.

Key points

  • Multi-tiered local caching allows database architectures to leverage bottomless object st…: Multi-tiered local caching allows database architectures to leverage bottomless object storage without exposing queries to high latency.
  • Production metrics show that only one out of every 28 million page reads actually reaches…: Production metrics show that only one out of every 28 million page reads actually reaches the base storage layer.
  • Remote object storage access is primarily confined to cold operations like branch restora…: Remote object storage access is primarily confined to cold operations like branch restorations and waking long-idle databases.

Sources checked by our analysis pipeline: 1

Object storage gives Lakebase Postgres its foundation: durable, bottomless storage, instant branches and restores, and one copy of data for transactions and analytics (LTAP).

But building on object storage doesn't mean reading from it. In our production fleet, 99.99999% of page reads are served from fast local caches, and 99.46% never even leave the compute node.

The rare reads that do reach object storage are one-offs. They come from old branches, restores, or databases waking up after weeks idle, and once that data is cached, the next reads are local again.

The common argument against running Postgres on object storage goes like this:

Postgres processes many small, latency-sensitive reads

Object storage is built for larger requests at higher latency, and a single read from it can take hundreds of milliseconds

Therefore, a Postgres backed by object storage must be a slow Postgres

The premise is right, but the conclusion isn't: it assumes that a database built on object storage has to read from object storage to answer queries, and Lakebase Postgres almost never does.

Let's start with some numbers

To…

Technology