CAP theorem — consistency, availability, partition tolerance: Worked examples

This page is the drill hall for the CAP topic. The parent note told you the idea: during a network split you must pick between staying Correct and staying Answering. Here we hit every kind of situation that idea can throw at you — one worked example per cell — so no exam question can surprise you.

Before any symbol appears, some plain-word reminders (we will not use anything until it is anchored below):

Definition The three CAP letters — spelled out and mapped to plain words

C = Consistency — every read returns the most recent successful write (or an error). All nodes agree on one up-to-date value. Plain-word slogan: "Correct." Picture: both notebooks show the same latest number.
A = Availability — every request to a non-failing node gets a non-error response (no promise it is the latest). Plain-word slogan: "Answering." Picture: the node always says something back.
P = Partition tolerance — the system keeps working even when the network drops or delays messages between nodes. Plain-word slogan: "Partition." Picture: the phone line is cut but the rooms keep running. So on this whole page, read the letters as C = Correct, A = Answering, P = Partition. The theorem: when P happens you must give up C or A.

Definition The other words we build on

Node — one computer holding a copy (a "replica") of the data. Picture a person in a room with a notebook.
Partition — the phone line between rooms is cut; messages between nodes are dropped or delayed. Picture a red X across the wire.
Replica — a duplicate copy of the same value living on a different node. Two notebooks that are supposed to say the same thing.
Leader / follower — one node is chosen as the leader (it accepts writes first); the other copies are followers that receive the write afterwards. Picture one head-notebook-keeper who tells everyone else what to write.
PACELC — read it as: if Partition then choose Availability or Consistency; Else (normal times) choose Latency or Consistency. So L = Latency (how long a request waits) and C = Consistency (everyone sees the latest value). The parent's PACELC note has the full story; on this page you only need: even with a healthy network you still trade speed against freshness.

We write a stored value as $x$ , and a specific version of it as $v_{0}$ (old) or $v_{1}$ (new). The little number is just a timestamp label — "which write happened first". Nothing more.

The scenario matrix

Every CAP question is really one of these case classes. The examples below fill in each row.

#	Case class	What is being tested	Example that hits it
1	No partition (healthy network)	Both C and A available; PACELC L-vs-C	Ex 1
2	Partition + choose CP	Refuse to answer, keep correct	Ex 2
3	Partition + choose AP	Answer anyway, may be stale	Ex 3
4	Quorum boundary (majority side vs minority side)	Which side stays alive	Ex 4
5	Degenerate: single node ( $N = 1$ )	Is CAP even meaningful?	Ex 5
6	Degenerate: total split (every node isolated)	Limiting extreme	Ex 6
7	Real-world word problem (money vs sales)	Choosing C or A from business cost	Ex 7
8	Exam-style twist ("CAP's C = ACID's C?")	Concept trap	Ex 8
9	Limiting behaviour (partition duration → 0 and → ∞)	Eventual consistency limit	Ex 9

The two axes of this matrix are: (a) is there a partition? (no / yes) and (b) if yes, which property do you sacrifice? (C or A). The degenerate rows (5, 6) test the edges of those axes — one node, or infinitely many isolated nodes.

Figure s01 below draws exactly these two axes: the vertical dashed line splits "no partition" (left, teal bubble = PACELC) from "partition present" (right), and the two right-hand bubbles show the CP/AP fork. Use it as the map for the whole page — each example lands in one bubble.

Figure — CAP theorem — consistency, availability, partition tolerance

Example 1 — No partition, PACELC lives (Cell 1)

Forecast: Guess now — does sync or async give the reader the latest value, and roughly how long does each write take?

Sync latency. The leader sends to 4 followers in parallel and waits for the slowest ack (acknowledgement). One round trip = send ( $10$ ) + ack back ( $10$ ) $= 20 ms$ . Why this step? "Wait for all" means the reply cannot happen until the last ack arrives; sent in parallel that is one round-trip time, not four.
Async latency. Leader writes locally and replies immediately: $\approx 0 ms$ of network wait. Why this step? Async means "don't wait for followers", so the network delay is removed from the client's path.
Which gives a fresh follower read? Only sync. In async, a follower may still hold $v_{0}$ when a client reads it, because the copy is still in flight. Why this step? Freshness on any node requires that node to have received the write before the read — that is exactly what waiting for its ack guarantees.

Verify: Sync $= 20 ms$ , async $\approx 0 ms$ ; sync $-$ async $= 20 ms$ extra latency, the "cost of C". Units are milliseconds throughout. ✓

Example 2 — Partition, choose CP (Cell 2)

Forecast: Will $N_{2}$ answer $v_{0}$ , answer $v_{1}$ , or refuse?

$N_{2}$ checks quorum. With 3 nodes, a strict majority is $⌊ 3/2 ⌋ + 1 = 1 + 1 = 2$ (using the floor definition above). Alone, $N_{2}$ counts only itself: $1 < 2$ . Why this step? CP systems require a majority to serve, so first they ask "am I in the majority?".
$N_{2}$ refuses. Since $1 < 2$ , $N_{2}$ returns an error / timeout, not data. Why this step? $N_{2}$ never heard $v_{1}$ ; the only way to guarantee it never hands out a stale value is to hand out nothing. Losing A protects C.
Client sees no stale data. Correct: the client got an error, never the wrong $v_{0}$ . Why this step? The definition of Consistency = "most recent write or an error". An error is allowed; a stale value is not.

Verify: majority $= ⌊ 3/2 ⌋ + 1 = 2$ ; minority side has $1$ node $< 2 \Rightarrow$ must reject. No stale value returned $\Rightarrow$ C preserved. ✓

Example 3 — Partition, choose AP (Cell 3)

Forecast: Answer with data, or refuse like Ex 2?

$N_{2}$ answers with what it has. It returns $v_{0}$ immediately. Why this step? AP's promise is "a non-failing node always gives a non-error response". $N_{2}$ is up, so it must answer — even though $v_{0}$ is stale.
Mark the value stale. The read returned old data; A is kept, C is lost for this moment. Why this step? $N_{2}$ literally has no way to know $v_{1}$ exists — the partition guarantees it. So the only response it can give is the old one.
Heal + reconcile. When the link returns, $N_{2}$ receives $v_{1}$ and overwrites $v_{0}$ (last-write-wins by timestamp, or a merge). This is Eventual Consistency. Why this step? AP doesn't abandon correctness forever — it defers it. Given no new writes, all replicas converge to $v_{1}$ .

Verify: During partition $N_{2}$ returns $v_{0}$ (stale) $\Rightarrow$ A kept, C lost. After heal, final value $= v_{1}$ on all nodes (single latest write) $\Rightarrow$ convergence. ✓

Example 4 — Quorum boundary: which side lives? (Cell 4)

Forecast: Guess which side stays available in each split.

Compute the quorum. For $N = 5$ , majority $= ⌊ N /2 ⌋ + 1 = ⌊ 5/2 ⌋ + 1 = 2 + 1 = 3$ (floor of $2.5$ is $2$ ). Why this step? A "quorum" is the smallest group forming a strict majority; two disjoint groups can never both reach it, which is exactly why it prevents split-brain.
3-vs-2 split. The 3-side has $3 \geq 3$ → serves. The 2-side has $2 < 3$ → rejects. Why this step? Only the side with a majority can safely accept writes without risking two conflicting "latest" values.
4-vs-1 split. The 4-side has $4 \geq 3$ → serves. The 1-side rejects. Why this step? Same rule; the bigger the majority side, the more failures it can still absorb.
Why two majorities can never coexist. If both sides served, we'd have two "latest" writes — a split-brain. Since $3 + 3 = 6 > 5$ , two disjoint quorums cannot both fit inside 5 nodes. Why this step? This inequality is the whole reason quorums guarantee C: any two quorums must overlap in at least one node, so they can't disagree silently.

Figure s02 below draws the 3-vs-2 split: the teal circles (left, size 3) reach the quorum and serve; the plum circles (right, size 2) fall short and reject. The orange dashed line is the partition. Read it as the picture of steps 2 and 4.

Verify: $N = 5 \Rightarrow$ quorum $= 3$ . In $3 : 2$ , sizes $3 \geq 3$ (serve), $2 < 3$ (reject). In $4 : 1$ , $4 \geq 3$ (serve), $1 < 3$ (reject). Two quorums need $2 \times 3 = 6 > 5$ nodes → impossible → no split-brain. See Replication and Quorums. ✓

Example 5 — Degenerate: a single node (Cell 5)

Forecast: Is a single-node DB CP, AP, or "CAP doesn't apply"?

Count the links that could break. A partition is a break on a link between two nodes. The number of possible node-pairs (links) is $(2 N) = \frac{N ( N - 1 )}{2}$ (the "n choose 2" defined above). For $N = 1$ : $(2 1) = \frac{1 \cdot 0}{2} = 0$ . Why this step? Zero links means there is literally nothing to partition — the CAP trade-off is never triggered.
What if the client can't reach the node? That's a client outage, not a CAP partition. If reachable, the single copy is always the latest (nothing to disagree with) and it answers. Why this step? With one copy, C is automatic (no disagreement possible) and A holds whenever the node is up.
Classification. A single node is trivially CA — but only because $P$ never arises. It is not "beating the theorem"; it simply isn't distributed. Why this step? CAP applies to Distributed Systems with $\geq 2$ replicas. $N = 1$ is the degenerate edge.

Verify: Number of inter-node links $= (2 1) = 0 \Rightarrow$ no partition possible $\Rightarrow$ C and A both trivially hold. ✓

Example 6 — Degenerate: everyone isolated (Cell 6)

Forecast: Guess how many nodes stay writable.

Quorum for $N = 4$ . Majority $= ⌊ 4/2 ⌋ + 1 = 2 + 1 = 3$ . Why this step? Same majority rule; note even ties ( $4$ nodes, half is $2$ ) need strictly more than half.
Each island's size. Every island has exactly $1$ node. $1 < 3$ for all of them. Why this step? No island can reach the quorum of 3, so none may accept writes.
Whole-system write availability. $0$ of $4$ nodes can serve writes → CP system is fully unavailable for writes in a total split. Why this step? This is the limiting extreme: as the partition shatters everything, CP write-availability drops to zero. (An AP system, by contrast, would let all 4 keep answering and reconcile later.)

Verify: $N = 4 \Rightarrow$ quorum $= 3$ ; each island size $1 < 3 \Rightarrow$ writable nodes $= 0$ . Fraction available (CP) $= 0/4 = 0$ . ✓

Example 7 — Real-world word problem: money vs sales (Cell 7)

Forecast: Which service should be CP and which AP? Guess before computing.

Bank, if it went AP (answer with a possibly-stale balance). Worst case: each of the 1000 reads enables one overdraw, so cost $\le 1000 \times \$ 500 = $500{,}000$. Why this step? Multiply "number of requests" by "dollar cost per wrong answer" to price the stale option. This is the money you lose by keeping A and sacrificing C.
Cart, if it went CP (refuse the add during the split). Each rejected add loses one sale, so cost $= 1000 \times \$ 3 = $3{,}000$ in lost revenue. Why this step? For the cart the cost sits on the refuse side, not the stale side — pricing this shows what keeping C (and sacrificing A) costs here.
Compare and decide. Bank: choosing AP risks up to $500 000, while choosing CP (refuse the withdrawal) risks $0 of lost money — only inconvenience. Cart: choosing CP costs $3 000 in lost sales, while choosing AP (accept the add, merge later) risks only a briefly-wrong cart. So bank → CP, cart → AP. Why this step? You never pick C or A in the abstract — you pick whichever mistake is cheaper. The dollar figures make the trade-off concrete, exactly the strict-vs-relaxed spirit of ACID vs BASE.

Verify: AP-bank worst cost $=1000\times500=\$ 500{,}000 $; C P - c a r tl os t s a l es$ =1000\times3=$3{,}000 $; s in ce$ 500000 > 3000$, the bank avoids the larger loss by choosing CP and the cart avoids its loss by choosing AP. Units are dollars throughout. ✓

Example 8 — Exam twist: is CAP's C the same as ACID's C? (Cell 8)

Forecast: Guess true or false before reading.

Define CAP-C. It means linearizability: all replicas agree on one latest value across nodes. Why this step? CAP-C is about cross-node agreement in a distributed system — the "Correct" slogan from the opening definitions.
Define ACID-C. It means a transaction never breaks the database's invariants (e.g. "account balance ≥ 0", foreign keys valid) — a single-node correctness rule. Why this step? ACID-C is about rules within a transaction, independent of replication or partitions.
They are different axes. A CP system can be perfectly linearizable yet run a transaction that violates a business rule; an ACID system on one node has no CAP-C question at all. Why this step? Conflating them is the trap: same letter, unrelated meanings.
Answer: FALSE. Why this step? CP guarantees agreement about which value; ACID-C guarantees the value obeys the rules. Neither implies the other.

Verify: CAP-C ≡ linearizability (cross-replica); ACID-C ≡ invariant preservation (intra-transaction). Distinct definitions ⇒ CP ⇏ ACID-C ⇒ statement is False. See ACID vs BASE. ✓

Example 9 — Limiting behaviour: partition duration → 0 and → ∞ (Cell 9)

Forecast: What happens to staleness at the two extremes?

Stale-read count model. Number of stale reads $S = r \cdot T$ (rate × time). Why this step? Over a window $T$ at rate $r$ , the total is the product — a simple linear accumulation.
Limit $T \to 0$ . $S = r \cdot T \to 0$ . A partition that heals instantly produces essentially zero staleness → looks like full consistency. Why this step? This is why brief blips barely matter for AP systems — the shorter the split, the closer AP behaves to CP.
Limit $T \to \infty$ . $S = r \cdot T \to \infty$ . Staleness grows without bound; but once the link heals (any finite time), Eventual Consistency still makes all replicas converge to the latest value. Why this step? AP never promises no staleness — only that after healing, with no new writes, replicas converge. Convergence is about the end state, not the count of stale reads along the way.
Contrast with CP. A CP system's stale reads $= 0$ for all $T$ (it refuses instead), at the cost of write-availability $\to 0$ during the split. Why this step? This crystallizes the whole page: AP trades a growing $S$ for uptime; CP trades uptime for $S = 0$ .

Verify: $S = r T$ ; $lim_{T \to 0} r T = 0$ , $lim_{T \to \infty} r T = \infty$ ; post-heal replicas converge (single final value). CP: $S = 0$ always. ✓

Recall Self-test across the whole matrix

What do C, A, P stand for in one plain word each? ::: Correct (Consistency), Answering (Availability), Partition (Partition-tolerance). Spell out CP and AP. ::: CP = Consistency + Partition-tolerance (stays correct, may refuse); AP = Availability + Partition-tolerance (stays answering, may be stale). Which cell is a single-node DB? ::: Cell 5 — degenerate, trivially CA because P never arises. In a 5-node cluster, what quorum is needed and why can't two sides both serve? ::: Quorum = 3; two quorums need 6 > 5 nodes, so they must overlap — no split-brain. As partition duration T → ∞ in an AP system, do replicas still converge? ::: Yes, after the link heals (any finite time) eventual consistency converges them; only the stale-read count grew. Is a CP database automatically ACID-consistent? ::: No — CAP-C is linearizability, ACID-C is invariant preservation; different axes. In a total 4-way split under majority quorum, how many nodes can accept writes? ::: Zero — each island of 1 is below the quorum of 3.

Connections

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

Worked examples — CAP theorem — consistency, availability, partition tolerance