Consistency Models Nobody Talks About

2026-09-14distributed systems

Every architecture review eventually arrives at the same question: is this linearizable? It is the wrong question, or at least an incomplete one. Most systems do not need linearizability, and the ones that claim to have it are usually describing a property they have not tested.

What your replica is actually doing

Consider a replicated key-value store with three nodes, asynchronous replication, and read-your-writes enabled on the client. The client library tracks a version vector, and on reconnect it waits until some replica reports a version at least as new as the last write it observed. This is a real guarantee, and it is not linearizability. It is monotonic reads plus read-your-writes, and it is what almost every production system actually implements.

The distinction matters because the failure modes are different. Under linearizability, a read always returns the most recent completed write. Under read-your-writes, a read returns a state at least as new as what that client has seen. Two clients can permanently disagree about the value of a counter, and nothing in the system will notice.

The test that catches it

If you want to know what your storage layer provides, do not read the documentation. Run two clients, have each write a distinct increment to the same counter, then read from both. If the values differ and stay differing, you have read-your-writes without convergence. That is a perfectly fine design, but it means any application-level invariant you build on top of it has to tolerate divergence.

Distributed systems do not fail by violating their specifications. They fail by satisfying weaker specifications than their authors believed.

Practical rules

Write down the guarantee you depend on, in terms of what a single client observes, not in terms of what the cluster does. Then write a test that would fail if the guarantee were violated. If you cannot write that test, you do not know what your system provides, and neither does anyone downstream of you.

The second rule is less obvious: when you compose two systems with different guarantees, the result has the weaker of the two, and often something strictly weaker than either. A cache in front of a linearizable store does not give you linearizable reads. It gives you cached reads with whatever staleness the cache enforces, plus a cache that may be inconsistent with itself during a failover.

← All posts