Cutaway — interactive explainers of systems internals

Interactive explainers of backend and systems internals — WALs, Raft, connection pooling, workflow engines — with the casing removed. Built for engineers who have been paged at 3 AM.

• cutaway/12 · 2026-06-30 · 9 min

  Bloom filters, or: the cheapest way to skip a disk read

  A bloom filter answers 'is this key here?' in a few bytes per key — definitely-no, or maybe. Insert keys into one filter, starve it of memory, and watch its maybes pile up until it can't skip anything; then see why that single bit array decides how many sorted runs an LSM read has to touch.

• cutaway/10 · 2026-06-18 · 8 min

  B-tree page splits, or: why your UUID index is twice the size

  A B-tree stays balanced by splitting full pages and growing from the leaves up. Where the splits land — and how full the pages end up — is decided entirely by the order you insert keys. Feed it sequential keys and it packs tight; feed it random UUIDs and watch it settle at two-thirds empty.

• cutaway/08 · 2026-06-18 · 11 min

  Isolation levels, or: which anomalies you agreed to ship

  Read Committed, Repeatable Read, Serializable — three settings of one dial, each defined by the anomalies it still lets through. Interleave two transactions, watch a committed wrong answer appear, then raise the level until the database aborts one of them instead.

• cutaway/11 · 2026-06-18 · 9 min

  Quorums, or: why R + W > N is the whole ballgame

  A leaderless replicated store has no single copy of the truth — just N replicas and two numbers, how many you write to and how many you read from. One inequality decides whether a read can come back stale. Set it wrong, partition the right nodes, and watch a value you just wrote vanish.

• cutaway/09 · 2026-06-18 · 9 min

  Transaction ID wraparound, or: the clock you didn't know was ticking

  Postgres numbers every transaction with a 32-bit counter and reads visibility off a circle. Freezing keeps the oldest end of that circle from being lapped — and one held snapshot stalls freezing the same way it stalls vacuum, until the database refuses to accept writes at all.

• cutaway/07 · 2026-06-12 · 9 min

  Compaction strategies, or: choose your amplification

  An LSM tree defers work; the compaction strategy decides who pays it back. Run one engine on a fixed disk budget, flip it between leveled and tiered mid-flight, and find the ingest rate where writes stall outright — then watch the other strategy survive the same load by hoarding disk instead.

• cutaway/06 · 2026-06-12 · 12 min

  MVCC, or: why your table is 3× bigger than your data

  Postgres never updates a row in place — every UPDATE buries the old version in the heap and trusts vacuum to sweep up later. Hold one transaction open and watch vacuum keep running while reclaiming nothing, until the table is mostly corpses and the disk alert fires.

• cutaway/05 · 2026-06-11 · 13 min

  LSM trees: write fast now, pay later

  Your B-tree ingest tops out at 5k rows/s and the SSD is bored — random writes are the bottleneck, not bandwidth. An LSM tree fixes the write path by making reads do the work later. Pile up uncompacted files and watch read amplification climb into the danger zone.

• cutaway/03 · 2026-06-11 · 12 min

  What PgBouncer actually does to your connections

  A Postgres backend is a whole process, so a few hundred of them is a real ceiling. A pooler multiplexes thousands of clients onto a handful of server connections — and the mode you pick decides which of your queries silently break.

• cutaway/02 · 2026-06-11 · 11 min

  Raft leader election, but you control the network

  A primary on the wrong side of a partition is still taking writes. The fix is not a faster failover detector — it is a rule about who is allowed to win. Cut the links yourself and watch Raft refuse to elect two leaders.

• cutaway/04 · 2026-06-11 · 13 min

  How durable workflow engines replay history

  A worker is OOM-killed 40 minutes into an order workflow. It restarts and the order finishes as if nothing happened — nobody wrote recovery code. The trick is replaying recorded history through deterministic code. Crash the worker yourself and watch the local variables refill.

• cutaway/01 · 2026-06-11 · 11 min

  How a write-ahead log survives a crash

  COMMIT returned OK, then the box lost power. Whether that row is still there comes down to one fsync. Kill the database mid-write and watch recovery replay the log.