System Design

Telling a fast producer to slow down — and what happens to latency when you do not.

"Definitely not there" for a few bits per item — and why the other answer is only a maybe.

Where the copy lives, who writes it, and the two hard problems underneath.

The choice you only make during a partition — and the one you make the rest of the time.

The speed of light is the constraint — and the only fix is to already be there.

Getting a majority to agree on one value — and the two rules that make it safe.

Why adding a shard should move 1/n of the keys and not all of them.

Why a B-tree and not a hash map — and the column order that decides whether your index is used at all.

Store what happened, derive the current state — and the migration problem you inherit.

Making retries safe — because in a distributed system the client cannot tell failure from a lost reply.

Picking one node to be in charge — and the fencing token that makes it actually safe.

Spreading requests across servers — and why counting them is not the same as spreading work.

Decoupling producers from consumers — and the delivery guarantee you actually get.

Asking questions you did not plan for — and why averaging latency hides the outage.

Four algorithms, and the boundary bug that makes the simplest one allow double.

Copies for durability and read capacity — and the lag that makes users see their own writes disappear.

Splitting data across machines — and the key choice you cannot easily take back.

Write the intention before the change — and get durability, replication and time travel from one idea.