DIGNALEGI

The reading room · Digna Legi

Beyond synthetic testing: Capturing and replaying real database workloads at Airbnb

A personal relevance score

80–100: high value. 70–79: worth the time. Below 70: below the usual publication threshold.

Evidence-reviewed score based on available publisher text. Operational results are self-reported, and several implementation sections require familiarity with database transactions and replay systems.

Scores reflect one reader’s profile, not an objective quality rating. Best is a separate personal selection.

How scoring works →

This brief · about 3 min with detail

Original article ↗

Why read this

Real database traffic exposes upgrade risks that synthetic workloads miss, but useful replay requires preserving transactions, timing, and dependencies between queries.

AI brief · Checked against source text

The main idea

Airbnb tests database upgrades and capacity by capturing production queries at a shared database proxy and replaying them against test targets. The crucial engineering problem is preserving the relationships that make those queries meaningful: transaction order, concurrent traffic, and generated identifiers used by later reads. Separate replay modes measure load tolerance or compare results between database versions, answering different questions about performance and compatibility.

Some background helpful. Basic familiarity with SQL queries, database transactions, proxies, and database upgrades.

Go a little deeper

Concurrency is part of the workload

A collection of correct queries can still make an inaccurate load test if separate files run at unrelated times. Airbnb groups logs into five-minute windows and gives workers a shared future start time. Workers then preserve spacing between queries, adjusted by the requested speed. This coordination recreates overlapping demand, helping test how the database behaves when operations compete rather than merely whether each operation succeeds.

Compatibility requires controlled differences

Different database engines can generate different identifiers for inserted rows. Later reads may then miss those rows, creating apparent incompatibilities caused by replay setup. Airbnb rewrites inserts to use the identifiers recorded in production. This preserves downstream dependencies and makes comparisons more useful, while deliberately sacrificing coverage of the target’s own identifier-generation behavior.

An upgrade can expose an old ambiguity

Comparing two versions restored from the same database snapshot revealed queries whose requested row order was incomplete. Without explicit ordering—or with tied values and no unique tiebreaker—a query that limits its results can select different rows after an upgrade. The repair was to make the application’s expected order explicit, revealing how an engine change can expose assumptions already embedded in application code.

A case from the article

Separating cache effects from engine changes

MySQL 8.0 removed the query cache, complicating direct performance comparisons with 5.7. Airbnb first replayed traffic against 5.7 with and without caching, then compared uncached 5.7 against 8.0. That sequence exposed duplicate application queries previously absorbed by the cache. It illustrates how replay becomes a diagnostic experiment when successive runs isolate different possible explanations for a regression.

How the case is made

An engineering account supports its design choices with MySQL upgrade investigations and measured capacity tests.

Where the idea has limits

Replaying captured traffic models the workload observed during its capture window. The system also deliberately fixes generated identifiers, so those tests do not exercise the target database’s native identifier generation.

A question to take away · from Digna Legi

Which assumptions in your system remain invisible because the current infrastructure quietly compensates for them?

What the original adds

The source details the three-stage processing architecture, replay job controls, production-data access restrictions, and a capacity test where commit latency rose from about 6 to 34 milliseconds under 80% more write traffic.

About this brief

AI-written, then separately checked for source support, useful detail and clarity. The author’s claims and our editorial question are kept separate. The original remains the author’s work. How we select and summarise →

Digna legi. Worth reading.