CAP theorem — consistency, availability, partition tolerance: Visual walkthrough

Everything here is a story about two machines that hold a copy of the same fact. That is the heart of a distributed system. Let us build it from nothing.

Step 1 — Two boxes, one fact

WHAT. Draw two computers. Call them $N_{1}$ and $N_{2}$ . The letter $N$ just stands for node — one machine in the system. The little number under it is only a name tag, so we can tell them apart. Each box stores one fact, a value we call $x$ . Right now both boxes agree: $x = v_{0}$ .

Read the symbols out loud like this:

$x$ — the thing we are remembering (a bank balance, a score, a cart).
$v_{0}$ — the value it currently holds. The letter $v$ means "value"; the little $0$ means "the starting one, version zero."

WHY two boxes and not one? Because one box is fragile — if it dies, your data is gone, and it can serve only so many customers. So real systems keep copies (called replicas) on several machines. The moment you have copies, you have a new problem: keeping them in agreement. That problem is the whole story.

PICTURE. Two identical boxes, a wire between them, both showing $v_{0}$ in green. Peace.

Figure — CAP theorem — consistency, availability, partition tolerance

Step 2 — The wire can break (the partition)

WHAT. Cut the wire. Now $N_{1}$ and $N_{2}$ are both alive and both working, but they cannot send messages to each other. Any message either one tries to send is dropped or delayed forever. This broken state is called a partition.

WHY draw this as unavoidable? Because it is. Cables get cut by digging machines, a switch reboots, a machine freezes for two seconds during a garbage-collection pause and misses everything. Nobody chooses a partition — the physical world imposes it. This is exactly why the parent note insists P is not optional: you can only choose how to behave when it happens.

PICTURE. The same two boxes, but the wire is now a broken red zig-zag. Both boxes are still lit up — alive, just deaf to each other.

Step 3 — A write lands on one side

WHAT. A client walks up to $N_{1}$ and says: "set $x = v_{1}$ ." Here $v_{1}$ is a new value, version one — the fresh, latest truth. $N_{1}$ obeys and updates its own copy. Now $N_{1}$ holds $v_{1}$ ; $N_{2}$ still holds the stale $v_{0}$ .

Term by term, the event is: $node that got the write N_{1} : x \leftarrow new latest value v_{1}$ The arrow $\leftarrow$ means "is assigned" — the box's memory is overwritten with $v_{1}$ .

WHY does $N_{2}$ not learn about it? $N_{1}$ tries to forward the update ("hey $N_{2}$ , it's $v_{1}$ now!"), but Step 2 killed the wire. The message vanishes. This is the crucial fact: $N_{2}$ has zero information that any write ever happened.

PICTURE. $N_{1}$ flips to a coral $v_{1}$ ; a message arrow leaves $N_{1}$ heading right but crashes into the broken wire and disappears. $N_{2}$ still shows green $v_{0}$ , blissfully unaware.

Step 4 — A read arrives on the other side

WHAT. Now a second client walks up to $N_{2}$ and asks: "what is $x$ ?" $N_{2}$ must respond. It has exactly two kinds of response available, and no third option:

(a) Answer with a value — it can only offer $v_{0}$ , the only value it knows.
(b) Refuse — reply "error / I can't tell you right now."

WHY only these two? A machine can either hand back data or hand back an error/timeout. There is no magical door that lets it hand back $v_{1}$ : it has never heard of $v_{1}$ (Step 3). So the content of any successful answer is forced to be $v_{0}$ .

PICTURE. A client arrow points into $N_{2}$ with a question mark. Two dashed reply arrows fan out of $N_{2}$ : one labelled " $v_{0}$ " (answer), one labelled "error" (refuse). $v_{1}$ is drawn faded and crossed out — the option $N_{2}$ physically cannot produce.

Step 5 — Line up the two demands and watch them collide

WHAT. Put the two definitions from Step 4 side by side against $N_{2}$ 's two possible moves:

$N_{2}$ does...	Returns	Satisfies C? ( $= v_{1}$ )	Satisfies A? (non-error)
(a) Answer	$v_{0}$	❌ (it's stale, not $v_{1}$ )	✅
(b) Refuse	error	✅ (never returns a wrong value)	❌

WHY this is a contradiction, not just a bad day. To satisfy C, the answer must equal $v_{1}$ . To satisfy A, the answer must be a value (not an error). The only value $N_{2}$ can produce is $v_{0} \neq = v_{1}$ . So: $needed for C (answer = v_{1}) \land needed for A (answer is a value) is impossible when N_{2} only knows v_{0} .$ The symbol $\land$ means "and" — both at once. The line says: no single response checks both boxes.

PICTURE. A two-row scoreboard. Row (a): green tick under A, red cross under C. Row (b): green tick under C, red cross under A. A big red "no row has two ticks" banner underneath.

Step 6 — Edge case: what if nobody wrote?

WHAT. Rewind. Suppose the wire is cut (partition present) but no client ever writes. Both boxes still hold $v_{0}$ . A read hits $N_{2}$ . It answers $v_{0}$ .

WHY does the theorem "relax" here? Because now $v_{0}$ is the most recent write — there is no newer $v_{1}$ to be out of step with. C wants "latest write," and $v_{0}$ genuinely is the latest. So the answer is both available and consistent. No contradiction.

PICTURE. Broken wire, both boxes green $v_{0}$ , no write arrow anywhere, $N_{2}$ happily returns $v_{0}$ with a double tick (C ✅ A ✅).

Step 7 — Edge case: no partition at all

WHAT. Now heal the wire. A write $x = v_{1}$ hits $N_{1}$ ; $N_{1}$ immediately forwards it to $N_{2}$ ; a later read on $N_{2}$ returns $v_{1}$ .

WHY both C and A now? With the wire alive, the information gap from Step 3 never opens. $N_{2}$ does know $v_{1}$ . So it can answer (A) with the latest value (C) at the same time. CAP forces no sacrifice when there is no partition.

But — and this is the PACELC theorem twist — forwarding to $N_{2}$ and waiting for it to confirm takes time. If you wait, reads everywhere see $v_{1}$ (consistent) but writes are slow (high Latency). If you don't wait, writes are fast but a read on $N_{2}$ might briefly still see $v_{0}$ (stale). A quieter version of the same tug-of-war runs even on a perfect network.

PICTURE. Healed green wire; write $v_{1}$ on $N_{1}$ with a successful message arrow reaching $N_{2}$ ; both boxes turn coral $v_{1}$ ; a small clock icon on the arrow labelled "costs latency (PACELC)."

The one-picture summary

Everything above collapses into one flow: two boxes → cut wire → write on one side → read on the other → the isolated node hits a fork with no "both" branch. The two branches are CP and AP.

Recall Feynman: retell the whole walkthrough

You and a friend each keep a copy of one scoreboard, connected by a phone line (Step 1). The phone line snaps — you can both still talk to visitors, but not to each other (Step 2). You score a point and change your board to $v_{1}$ ; you try to phone your friend but the line is dead, so your friend never hears it (Step 3). A visitor asks your friend for the score (Step 4). Your friend has only two moves: shout out the old number (fast, but wrong now) or say "I can't tell you until the phone works" (right, but useless). There is no way to be both fast and right, because your friend simply doesn't know about your new point (Step 5). If you'd never scored, the old number would still be correct — no problem (Step 6). And if the phone were working, your friend would just hear " $v_{1}$ " and answer correctly — though the phone call itself takes a moment (Step 7). That forced choice, and only when the line is down and the numbers have diverged, is the entire CAP theorem.

Active recall

Why can't the isolated node return the latest write?

The partition dropped the update message, so the node has no information that the new value even exists.

What two ingredients together trigger the CAP contradiction?

A partition plus a write on one side and a read on the other side of it.

Why does no row in the Step 5 table satisfy both C and A?

C needs the answer to equal

v_{1}

; A needs any non-error value; the node only holds

v_{0} \neq = v_{1}

, so no single response does both.

When no client writes during a partition, why is a read still consistent?

The old value

v_{0}

is genuinely the most recent write, so returning it satisfies both C and A.

On a healthy network, what tension remains and which theorem names it?

Latency vs Consistency (wait for replicas or not) — named by PACELC.

Connections

Parent topic
Distributed Systems
ACID vs BASE
Eventual Consistency
Replication and Quorums
PACELC theorem
Consensus — Paxos & Raft
NoSQL Databases

Visual walkthrough — CAP theorem — consistency, availability, partition tolerance

Step 1 — Two boxes, one fact

Step 2 — The wire can break (the partition)

Step 3 — A write lands on one side

Step 4 — A read arrives on the other side

Step 5 — Line up the two demands and watch them collide

Step 6 — Edge case: what if nobody wrote?

Step 7 — Edge case: no partition at all

The one-picture summary

Active recall

Connections

Concept Map