Quorum Reads and Writes Explained: R + W > N, Sloppy Quorums, Hinted Handoff and Read Repair in Dynamo-Style Databases (2026)
Most engineers learn one line about leaderless replication: if R + W > N, every read sees the latest write. That line is true, and it is also the reason teams get surprised in production. Quorum consistency is a statement about two sets of replicas overlapping at one instant. It says nothing about what happens when the replica set itself changes, when a write half-succeeds, or when two writers carry clocks that disagree. Cassandra, ScyllaDB and Riak all expose the R, W and N knobs, and all three have documented behaviour where a “quorum” read returns something other than the last acknowledged write. In 2026, with Cassandra 5.0 in production and Accord transactions arriving in the Cassandra 6 line, knowing exactly where plain quorums stop guaranteeing anything is what lets you choose consistency levels on purpose rather than by folklore.
What this covers: the R + W > N rule and its three hidden assumptions, sloppy quorums and hinted handoff, read repair before and after Cassandra 4.0, last-write-wins and clocks, Probabilistically Bounded Staleness, availability and tail-latency math for N = 3 and N = 5, a runnable Python simulator, multi-datacenter consistency levels, failure modes and a decision table.
Context and Background
The overlapping-quorum idea is older than most databases that use it. David K. Gifford’s “Weighted Voting for Replicated Data”, presented at the 7th ACM Symposium on Operating Systems Principles in 1979, assigned votes to copies of a file and required that a read quorum and a write quorum together exceed the total number of votes. Werner Vogels, Amazon’s CTO, later called it the first paper to describe the “r+w” overlapping quorum approach. Gifford’s copies also carried version numbers, so a reader could tell which of the copies it contacted was current. That detail matters: overlap alone is useless unless the reader can recognise the newest value.
The modern form arrived with Amazon’s Dynamo paper (DeCandia et al., SOSP 2007). Dynamo stored each key on N nodes chosen by walking a consistent-hashing ring. Its authors wrote that “setting R and W such that R + W > N yields a quorum-like system” and that the latency of a get or put “is dictated by the slowest of the R (or W) replicas”, which is why R and W are usually set below N. They reported that “the common (N,R,W) configuration used by several instances of Dynamo is (3,2,2).” Crucially, Dynamo was designed to stay writable during failures, so it did not enforce strict quorum membership. It used a “sloppy quorum” and hinted handoff instead, which is where most of the subtlety in this article comes from.
Dynamo’s design spread through open-source systems. Apache Cassandra adopted the ring, the tunable consistency levels, hinted handoff and read repair, combined with a Bigtable-style storage engine. Riak implemented Dynamo closely, including vector clocks and explicit sloppy quorums. ScyllaDB reimplemented Cassandra’s protocol and consistency levels in C++. Ring placement and token ownership are covered in our explainer on database sharding with consistent hashing and rendezvous hashing, so this post assumes you know how a key maps to its N replicas.
One naming trap deserves an early warning. Amazon DynamoDB is not a leaderless Dynamo-style store. Marc Brooker’s 2025 comparison of Dynamo, DynamoDB and Aurora DSQL explains that each DynamoDB partition is a replica group with a leader that uses Paxos, acknowledges a write once a quorum of peers persists it, and serves strongly consistent reads from the leader. The quorum is still there, but it lives inside a consensus protocol rather than being assembled per request by whichever node happens to coordinate. Keep that distinction in mind whenever “Dynamo” appears in a vendor deck.
How Quorum Consistency Works: The Overlap Argument and Its Three Hidden Assumptions
Quorum consistency means a write is acknowledged by W of a key’s N replicas and a read collects answers from R of them. If R + W > N, any read set and any write set share at least one replica, so the reader receives the latest acknowledged version and picks it by timestamp or version. The guarantee holds only while those assumptions hold.

Figure 1: With N = 3, W = 2 and R = 2, any read quorum must include at least one replica from the write quorum.
Figure 1 shows the argument concretely. The coordinator sends version v2 to all three replicas. Replicas A and B acknowledge, so the write returns success with W = 2 while replica C is still applying it. A read at R = 2 that happens to contact B and C gets v2 from B and v1 from C, compares timestamps, and returns v2. There is no pair of replicas it could have contacted that excludes both A and B. That is the whole proof: two subsets of sizes R and W drawn from N elements must intersect when R + W > N, by the pigeonhole principle.
The proof is about sets, so the sets must be fixed
The pigeonhole argument silently assumes both quorums are drawn from the same N replicas. If the write landed on A and a substitute node D because C was unreachable, and the later read contacts B and C, the sets {A, D} and {B, C} share nothing. N was 3 in the configuration file, but the write and read effectively ran against a population of four. This is exactly what a sloppy quorum does, and it is the first hidden assumption: membership is stable between the write and the read.
The Dynamo paper is explicit that this was a deliberate trade. In its words, a traditional quorum approach “would be unavailable during server failures and network partitions”, so Dynamo performs operations “on the first N healthy nodes from the preference list, which may not always be the first N nodes encountered while walking the consistent hashing ring.” Availability went up. The overlap guarantee became conditional.
The proof assumes a write either happened or did not
The second hidden assumption is atomicity of the write at the replica-set level. A coordinator that needs W = 2 acknowledgements but receives only one reports failure to the client. The replica that did apply the write still holds it. Nothing rolls it back, because Dynamo-style systems have no prepare phase and no abort. Our two-phase commit explainer describes the protocol you would need to make that write all-or-nothing, and leaderless stores intentionally skip it.
The consequence is that a “failed” write can become visible later. A quorum read that touches the one replica holding it will return it, since its timestamp is newest. A second quorum read that misses that replica will not. Readers can therefore see a value appear and then vanish, which is the non-monotonic behaviour Cassandra’s 4.0 read-repair work explicitly targets. Kyle Kingsbury’s Jepsen analysis of Riak summarised the general point: “failed writes may still be partially successful.”
The proof assumes the reader can tell which value is newer
The third assumption is that version comparison is meaningful. Gifford used monotonically increasing version numbers on each copy. Dynamo used vector clocks and returned all causally concurrent versions to the client for reconciliation. Cassandra and ScyllaDB use a per-cell timestamp and resolve conflicts by last write wins; the Cassandra architecture documentation says updates “resolve according to the conflict resolution rule of last write wins”, with the coordinator’s clock used when the client supplies no timestamp.
Last write wins turns clock quality into a correctness parameter. If writer X’s clock runs 40 ms ahead of writer Y’s, a write from Y issued 30 ms after X’s will lose, even though both were acknowledged by a full quorum and a subsequent quorum read did overlap with both. The overlap worked perfectly and quorum consistency was technically satisfied. The comparison discarded the later write. Our post on hybrid logical clocks and vector clocks covers the clock mechanisms that reduce this risk; quorum arithmetic cannot.
Put together, R + W > N is necessary but not sufficient for reading the latest write. It also needs stable membership, atomic writes, and a safe merge rule. Each mechanism below exists because one of those three assumptions fails in real clusters, and each patches quorum consistency in a different place.
Sloppy Quorums, Hinted Handoff and Read Repair: How Systems Patch Quorum Consistency
With the assumptions behind quorum consistency named, the repair machinery stops looking like a grab-bag of features. Hinted handoff and sloppy quorums deal with membership changes. Read repair and anti-entropy deal with divergence that partial writes and missed writes leave behind. Lightweight transactions and newer consensus protocols deal with the cases where a merge rule is not good enough.
Sloppy quorum and hinted handoff in Dynamo and Riak

Figure 2: A sloppy quorum meets W = 2 by writing to fallback node D, which later hands the hinted replica back to A.
Figure 2 follows the Dynamo paper’s own example. With N = 3, a key’s home replicas are A, B and C. A is down, so the coordinator sends A’s copy to D, the next healthy node on the preference list. The paper describes it this way: “The replica sent to D will have a hint in its metadata that suggests which node was the intended recipient.” D stores hinted replicas “in a separate local database that is scanned periodically” and, once A recovers, delivers the replica and may delete its local copy “without decreasing the total number of replicas in the system.”
The sloppy part, and the cost to quorum consistency, is that D’s acknowledgement counts toward W. The write succeeds even though only one home replica has it. That is the availability win: the paper notes that an application can set W = 1 so that a write “is only rejected if all nodes in the system are unavailable.” It is also the consistency loss. Until handoff completes, a read at R = 2 against home replicas A and C can miss the write entirely, despite R + W > N.
Riak made the trade explicit and configurable. Its replication documentation describes failing over to non-primary vnodes to satisfy R and W as “sloppy quorum”, and adds two extra parameters, PR and PW, defined as “the number of primary vnodes that must respond.” Setting them above zero “produces a mode of operation called strict quorum.” Riak’s defaults are N = 3 with R and W at quorum and PR = PW = 0, meaning sloppy quorums are on unless you ask otherwise.
Hinted handoff in Cassandra is not a sloppy quorum
Cassandra borrowed the term hinted handoff but changed its meaning in a way that trips up people coming from the Dynamo paper. In Cassandra, the coordinator always sends writes to all replicas; the architecture docs say “write operations are always sent to all replicas, regardless of consistency level.” If a replica is down, the coordinator stores a hint on its own disk. DataStax’s documentation makes the consequence clear: “If there are sufficient replicas to meet the consistency level, the request succeeds” and “hints are written for any down replicas.” If there are not, the request fails with UnavailableException and no hint is written.
In other words, a Cassandra hint does not count toward QUORUM. The only exception is consistency level ANY, which the Apache docs describe as “a single replica may respond, or the coordinator may store a hint,” and which is accepted only for writes. A write at ANY with all replicas down is durable on the coordinator but not readable until a replica recovers. So Cassandra’s QUORUM is a strict quorum over home replicas, which makes its quorum consistency stronger than Dynamo’s during node failures. Its main membership risk comes from topology changes and repair gaps rather than from fallback nodes.
Hints are bounded. Cassandra’s hints documentation sets max_hint_window to three hours by default and throttles delivery to 1,024 KiB per second per delivery thread. If a replica stays down longer than the window, the coordinator stops collecting hints for it and, in the docs’ words, “the destination replica will be permanently out of sync until” read repair or anti-entropy repair fixes the data. The same page warns that “hints are best effort” and “do not guarantee eventual consistency.” That sentence is the reason scheduled repair is not optional.
Read repair: fixing divergence on the read path

Figure 3: Cassandra’s read path at QUORUM, with a digest mismatch triggering blocking read repair before the client gets an answer.
Figure 3 shows the Cassandra 4.0 read path for a QUORUM read with replication factor 3. The coordinator sends a full data request to the replica it predicts is fastest and digest requests, which return only a hash, to enough others to meet the consistency level. If the digests match, it returns the data. If not, it requests full data from the mismatching replica, merges cells by timestamp, and sends repair mutations to the stale replicas. The Cassandra read repair documentation states that “a response is not returned to the client until the read repair has completed.”
Read repair is how quorum consistency heals itself on the read path, but it only runs when a read touches more than one replica. At ONE and LOCAL_ONE no digest requests are sent and no repair happens. At TWO, THREE, QUORUM and LOCAL_QUORUM, repair occurs only when the direct and digest responses disagree. Cold data that nobody reads is never repaired this way, which is why read repair complements anti-entropy rather than replacing it. Anti-entropy compares replicas with hash trees; our Merkle tree explainer walks through how Cassandra’s repair builds and compares them.
What Cassandra 4.0 changed
Cassandra 4.0 made two significant changes. First, it removed background read repair. The old table options read_repair_chance and dclocal_read_repair_chance probabilistically sent extra reads to all replicas and repaired them asynchronously; CASSANDRA-13910 removed both. Second, CASSANDRA-14635 added a read_repair table option with two values: BLOCKING, the default, and NONE.
The two values encode a genuine trade-off between two guarantees, and the documentation names both. BLOCKING gives monotonic quorum reads, which “prevents reads from appearing to go back in time in some circumstances”, but not partition-level write atomicity. NONE makes the coordinator reconcile responses without writing repairs, which preserves partition-level write atomicity but gives up monotonic quorum reads. The atomicity issue arises because a blocking read repair may write back only part of a batch-written partition, so a later reader could see some cells of a multi-cell write and not others.
Speculative execution also changed. In 4.0 the coordinator can send additional full-data reads to uncontacted replicas when a response is slow, and can send repair mutations speculatively to extra nodes, blocking only on the responses needed to meet the consistency level. Both the speculative_retry and additional_write_policy table options default to 99PERCENTILE in the current CQL reference.
Anti-entropy and gossip close the loop
Hints and read repair are opportunistic. The backstop is anti-entropy repair, which the Dynamo paper implemented with “a separate Merkle tree for each key range” and which Cassandra exposes as full and incremental repair. Repair needs to know which nodes are alive and which own which ranges, and that membership view historically came from gossip; our post on gossip protocols, SWIM and failure detection explains why a node can be “down” for one peer and “up” for another. Reporting on Cassandra 6 describes Transactional Cluster Metadata replacing gossip as the main carrier of token ownership and schema, and repair scheduling moving inside the database. Treat those as alpha-stage features until a GA release ships.
Worked Numbers: What Quorum Consistency Costs in Staleness, Availability and Tail Latency
Every quorum consistency setting trades three quantities: how often a read is stale, how often an operation is unavailable, and how long the slowest required replica takes. Each can be estimated from simple models, and each has a real-world measurement to anchor it.
Probabilistically Bounded Staleness
When R + W ≤ N, the configuration is called a partial quorum, and the question becomes how stale reads are in practice. Bailis, Venkataraman, Franklin, Hellerstein and Stoica answered this in “Probabilistically Bounded Staleness for Practical Partial Quorums” (VLDB 2012). They define two metrics: t-visibility, the probability of reading a write t seconds after it returns, and k-staleness, the probability of reading one of the last k versions.
The static starting point is combinatorial. If a write reached exactly W random replicas and a read contacts R random replicas, the probability that the read misses every written replica is C(N−W, R) / C(N, R). For N = 3, R = W = 1, that is 2/3. For N = 3, R = 1, W = 2 it is 1/3. For R = W = 2 it is 0, which is the overlap theorem again. The paper’s insight is that this static number is pessimistic, because writes keep propagating to all N replicas after the coordinator returns. Their WARS model treats the write, acknowledgement, read and response delays as separate latency distributions and estimates t-visibility by Monte Carlo simulation.
Two of their results are worth quoting exactly. Using production latency distributions, they found that switching from spinning disks to SSDs changed the wait for a 99.9% probability of consistent reads from 45.5 ms to 1.85 ms. In another environment, partial quorums gave “an 81.1% combined read and write latency improvement at the 99.9th percentile (230 to 43.3ms) for a 202ms window of inconsistency.” The paper also records the defaults of the era: Cassandra at N = 3, R = W = 1, Riak at N = 3, R = W = 2, and LinkedIn’s Voldemort often at N = 3, R = W = 1 for low-latency applications. Those defaults have changed since, so check your driver before assuming.
A runnable quorum simulator
The following simulator is a deliberately small version of the WARS idea. It sends a write to N replicas with random one-way delays, returns success after W acknowledgements, issues a read immediately or after a gap, and counts how often the first R responses are all stale. A second function demonstrates the non-monotonic read that a partial write causes, with and without blocking read repair.
"""Toy Dynamo-style quorum simulator: N replicas, LWW by version, random delivery delays."""
import random
def run(n=3, r=2, w=2, trials=20000, p_drop=0.0, delay_ms=(1, 20), read_gap_ms=0.0, read_repair=False, seed=7):
rng = random.Random(seed)
stale = 0
for _ in range(trials):
# Each replica holds version 0. A write of version 1 is sent to all N replicas.
arrive = []
for _ in range(n):
if rng.random() < p_drop:
arrive.append(float("inf")) # message lost; replica stays at v0
else:
arrive.append(rng.uniform(*delay_ms))
acked = sorted(arrive)[w - 1] # write returns after W acks
if acked == float("inf"):
continue # write failed; not counted
t_read = acked + read_gap_ms
# Read goes to all N, coordinator waits for the first R responses.
resp = []
for i in range(n):
rtt = rng.uniform(*delay_ms)
# replica answers with v1 if write arrived before the read request did
version = 1 if arrive[i] <= t_read + rtt / 2 else 0
resp.append((rtt, version))
first_r = sorted(resp)[:r]
newest = max(v for _, v in first_r)
if newest == 0:
stale += 1
return stale / trials
def monotonic_demo(n=3, r=2, trials=20000, blocking_repair=False, seed=11):
"""A write reaches only replica 0, then fails (not enough acks). Two quorum reads follow."""
rng = random.Random(seed)
back_in_time = 0
for _ in range(trials):
store = [1] + [0] * (n - 1) # partial write: only replica 0 has v1
q1 = rng.sample(range(n), r)
seen1 = max(store[i] for i in q1)
if blocking_repair and seen1 == 1:
for i in q1:
store[i] = 1 # repair the replicas in the read quorum
q2 = rng.sample(range(n), r)
seen2 = max(store[i] for i in q2)
if seen1 == 1 and seen2 == 0:
back_in_time += 1
return back_in_time / trials
if __name__ == "__main__":
for (n, r, w) in [(3, 1, 1), (3, 1, 2), (3, 2, 2), (5, 1, 1), (5, 2, 2), (5, 3, 3)]:
print(f"N={n} R={r} W={w} R+W>N={r + w > n} "
f"stale={run(n, r, w):.4f} stale_after_5ms={run(n, r, w, read_gap_ms=5):.4f}")
print(f"non-monotonic reads, no repair: {monotonic_demo():.4f}")
print(f"non-monotonic reads, blocking repair: {monotonic_demo(blocking_repair=True):.4f}")
Running it with Python 3 produces the output below. These numbers are illustrative: they come from uniform 1 to 20 ms delays chosen for this article, not from any production system.
N=3 R=1 W=1 R+W>N=False stale=0.5218 stale_after_5ms=0.2854
N=3 R=1 W=2 R+W>N=False stale=0.2160 stale_after_5ms=0.0761
N=3 R=2 W=2 R+W>N=True stale=0.0000 stale_after_5ms=0.0000
N=5 R=1 W=1 R+W>N=False stale=0.6910 stale_after_5ms=0.4325
N=5 R=2 W=2 R+W>N=False stale=0.1767 stale_after_5ms=0.0466
N=5 R=3 W=3 R+W>N=True stale=0.0000 stale_after_5ms=0.0000
non-monotonic reads, no repair: 0.2213
non-monotonic reads, blocking repair: 0.0000
Three lessons about quorum consistency survive the toy model. Strict quorums never return stale data here, because membership is fixed and writes are atomic once acknowledged. Partial quorums are stale often immediately after a write, but staleness falls quickly as the gap grows, which is the PBS effect. And the monotonic demo matches the exact answer: with N = 3, R = 2 and the failed write on one replica, the first read sees it with probability 2/3 and the second misses it with probability 1/3, giving 2/9 ≈ 0.222. Blocking read repair writes the value to the other member of the first read quorum, after which two of three replicas hold it and every later quorum overlaps.
Availability math for N = 3 and N = 5
Assume, for illustration only, that each replica is independently available with probability p. An operation needing k responses succeeds when at least k of N replicas are up, which is a binomial tail. Real failures are correlated through racks, zones and deployments, so treat these as upper bounds.
| Configuration | Responses needed | Availability at p = 0.99 | Expected unavailability per year | Availability at p = 0.999 |
|---|---|---|---|---|
| N = 3, ONE | 1 | 0.999999 | about 0.5 minutes | ≈ 1.0 |
| N = 3, QUORUM | 2 | 0.999702 | about 157 minutes | 0.999997 |
| N = 3, ALL | 3 | 0.970299 | about 10.8 days | 0.997003 |
| N = 5, QUORUM | 3 | 0.999990 | about 5 minutes | ≈ 1.0 |
| N = 5, four of five | 4 | 0.999020 | about 8.6 hours | 0.999990 |
| N = 5, ALL | 5 | 0.950990 | about 17.9 days | 0.995010 |
Illustrative: independent failures, computed from the binomial distribution. Not a vendor figure.
The table explains two industry habits around quorum consistency. QUORUM on N = 3 tolerates one replica down, and ALL tolerates none, so ALL is rarely worth it. Moving from N = 3 to N = 5 at QUORUM cuts modelled unavailability by roughly thirty times at p = 0.99, because two replicas can now fail. The cost is 67% more storage and write traffic for every key.
Tail latency: quorums absorb one slow replica
Dynamo’s authors stressed that latency is set by the slowest of the R or W replicas the coordinator waits for. That turns quorum size into an order statistic. Suppose, again illustratively, each replica independently exceeds 10 ms on 1% of requests. A ONE read is slow only if all three contacted replicas are slow, about one in a million when the coordinator sends to all three and takes the first. A QUORUM read on N = 3 is slow only if at least two are slow: 3 × 0.01² × 0.99 + 0.01³ ≈ 0.03%. An ALL read is slow if any one is slow: 1 − 0.99³ ≈ 2.97%.
So QUORUM hides one straggler and ALL inherits every straggler. The same arithmetic explains why Cassandra’s speculative retry helps: if the predicted-fastest replica is slow, another replica is asked after the 99th-percentile threshold, which converts a tail event into a second chance. The Dynamo paper reported a 99.9th-percentile target of 300 ms for its services, a reminder that this whole design is tuned around tails, not averages.
Multi-Datacenter Quorums and Cassandra Consistency Levels
Quorum consistency gets more interesting when replicas sit in several datacenters, because the expensive replicas are the remote ones. Cassandra and ScyllaDB use NetworkTopologyStrategy, which assigns a replication factor per datacenter, and the Apache docs state that “all production deployments should use the NetworkTopologyStrategy.”
The levels and what they count
Each Cassandra consistency level defines how many replica responses the coordinator waits for. ONE, TWO and THREE count any replicas. QUORUM needs “a majority (n/2 + 1) of the replicas”, computed across all datacenters; the DataStax documentation gives the formula as (sum of replication factors / 2) + 1. LOCAL_QUORUM needs a majority in the coordinator’s datacenter. EACH_QUORUM needs a majority in every datacenter. LOCAL_ONE needs one local replica and guarantees reads are not sent to remote datacenters. ALL needs every replica. ANY is write-only and may be satisfied by a hint.
| Topology | Level | Replicas waited for | Remote round trip on critical path? | Survives loss of one DC? |
|---|---|---|---|---|
| 2 DCs, RF 3 each | QUORUM | 4 of 6 | Yes, at least one | Reads and writes fail until DC returns |
| 2 DCs, RF 3 each | LOCAL_QUORUM | 2 of 3 local | No | Yes, from the surviving DC |
| 2 DCs, RF 3 each | EACH_QUORUM | 2 in each DC | Yes | No, fails while any DC is down |
| 3 DCs, RF 3 each | QUORUM | 5 of 9 | Yes | Yes, 6 replicas remain |
| 3 DCs, RF 3 each | LOCAL_QUORUM | 2 of 3 local | No | Yes |
Derived from the documented quorum formulas. The 2-DC QUORUM row follows from needing 4 of 6 replicas with only 3 alive.
The two-datacenter QUORUM row is the classic surprise. Four of six sounds safe until one region goes offline, leaving three replicas and no quorum. That is why two-DC deployments almost always use LOCAL_QUORUM, and why teams that need QUORUM-like semantics across regions deploy three datacenters.
Support for EACH_QUORUM on reads varies by product and version. The ScyllaDB consistency documentation marks EACH_QUORUM as “write only”, while DataStax documentation for DSE 6.9 describes EACH_QUORUM reads; CASSANDRA-9602 is the Apache ticket that requested read support. Check your exact version before designing around it.
LOCAL_QUORUM is a per-datacenter quorum, not a global one
LOCAL_QUORUM writes plus LOCAL_QUORUM reads give read-your-writes within one datacenter. Across datacenters they give nothing beyond eventual consistency: a write acknowledged in DC1 is replicated asynchronously to DC2, and a LOCAL_QUORUM read in DC2 may run before it arrives. If clients are pinned to a home datacenter by routing, that is usually fine. If a client can fail over between datacenters mid-session, it can observe its own writes disappear until replication catches up.
EACH_QUORUM writes paired with LOCAL_QUORUM reads give a stronger property: every write is in a majority of every datacenter before it is acknowledged, so a local quorum read anywhere overlaps it. The price is that the write path includes the slowest inter-region round trip and fails whenever any datacenter cannot form a quorum. That is a reasonable choice for low-volume control data, such as tenant configuration, and a poor one for high-volume telemetry.
Lightweight transactions and where plain quorums stop
Quorum consistency has a hard ceiling. When the requirement is compare-and-set, such as “create this username only if absent”, no choice of R and W is enough. Two concurrent writers can each read “absent” at QUORUM and each write at QUORUM; both succeed and last write wins picks one silently. Cassandra’s answer is lightweight transactions, conditional statements with IF clauses that run a Paxos round, with SERIAL and LOCAL_SERIAL consistency for the Paxos phase. DataStax documents SERIAL as achieving linearizable consistency for lightweight transactions only. ScyllaDB documents SERIAL and LOCAL_SERIAL as linearizable read levels.
Lightweight transactions step outside quorum consistency into consensus, and they cost several round trips and contend badly on hot keys, so they suit uniqueness checks rather than every write. Kingsbury’s 2013 Jepsen analysis of Cassandra found bugs in the early Cassandra 2.0 implementation, which were reported and addressed afterwards, so judge current behaviour on current versions and current tests. The Accord protocol for general multi-partition transactions, described in reporting from mid-2026 as alpha-stage in Cassandra 6.0, is the project’s longer-term route past these limits. Our comparison of Raft and Paxos failure modes covers why consensus can offer what quorum overlap cannot: a single agreed order of operations.

Figure 4: A decision flow for picking Cassandra consistency levels by read-your-writes need, datacenter count, regional durability and compare-and-set requirements.
Figure 4 condenses the section into a decision path for quorum consistency per table. Start with whether readers must see their own writes; if not, ONE or LOCAL_ONE with a reliable repair schedule is usually right. If they must, choose QUORUM in one datacenter, LOCAL_QUORUM across datacenters with sticky routing, or EACH_QUORUM writes when a write must survive the loss of a whole region. Any conditional logic routes to lightweight transactions regardless of the base level.
Trade-offs, Gotchas, and What Goes Wrong
Last write wins loses acknowledged writes. This is the most consequential failure, and quorum consistency does nothing about it. In Jepsen’s Riak test with allow_mult=false, 1,434 of 2,000 acknowledged writes disappeared in a healthy cluster because concurrent read-modify-write cycles overwrote each other. Under a partition with sloppy quorums, 91% of acknowledged writes were lost. Setting PR = PW = R = W = quorum still lost about 92%, because partially failed minority writes carried newer timestamps. Jepsen’s Cassandra test of repeated single-cell mutation at QUORUM lost 285 of 1,009 acknowledged writes. Those tests are from 2013 and the versions are old, but the mechanism is inherent to last write wins.
Read-modify-write is a race. Reading at QUORUM and then writing at QUORUM is not atomic. Two clients interleave and one update vanishes. Use lightweight transactions, idempotent appends, collection types that merge by element, or CRDTs. Jepsen’s Riak CRDT test kept all 2,000 writes, and our post on CRDTs for digital twin synchronisation shows the pattern for edge state.
Same-timestamp ties. Two writes with identical timestamps are broken deterministically by comparing values, not by arrival order. Jepsen’s Cassandra test saw tie-related losses at roughly one row in 200, which it attributed to coarse timestamp granularity in that version. Client-generated microsecond timestamps reduce collisions but reintroduce clock-skew risk.
Tombstones and zombies. A delete is a timestamped tombstone. If a replica stays down longer than the tombstone grace period and is never repaired, it can bring deleted data back after the tombstones are purged elsewhere. The same failure appears when a node is down beyond the three-hour default max_hint_window and repair is skipped.
Quorum reads under load amplify repair. Every digest mismatch adds a blocking repair write to a read. After an outage, read latency can spike until anti-entropy repair catches up. Running repair promptly after recovery keeps read repair as a trickle rather than a flood.
Quorum consistency is not linearizability. A read that overlaps an in-flight write may return the new value while a later read returns the old one, unless blocking read repair or a consensus protocol orders them. Kingsbury described Cassandra’s LWW cell behaviour as “not linearizable by any definition.”
ALL is a trap. It looks like the safest level and is the least available, as the table above shows. It also inherits every replica’s tail latency.
Practical Recommendations
Treat quorum consistency as a tool for read-your-writes on a single key, not as a substitute for transactions. Decide per table, because a user-profile table and a sensor-reading table do not need the same guarantees. Write the reasoning down next to the schema so the next engineer does not “fix” a deliberate ONE into a QUORUM, or the reverse.
For single-datacenter clusters with replication factor 3, QUORUM writes and QUORUM reads are the sensible default for mutable records. For immutable, append-only time series, writing at LOCAL_QUORUM and reading at LOCAL_ONE is often enough, provided repair runs within the tombstone grace period. For two-datacenter deployments, use LOCAL_QUORUM with sticky client routing, and add a third datacenter if you need QUORUM semantics that survive a regional outage.
Model conflicts before choosing levels, because quorum consistency only controls which replicas answer, not how their answers merge. If two writers can update the same cell, last write wins will discard one of them sometimes, whatever R and W are. Prefer data models where each write creates a new row or a new collection element, and reserve lightweight transactions for genuine uniqueness or compare-and-set needs.
Keep clocks honest. Run NTP or PTP on every node and client that stamps writes, alert on offset, and decide explicitly whether the client or the coordinator generates timestamps.
- Set replication factor 3 per datacenter and use
NetworkTopologyStrategy. - Pick consistency levels per table and document why.
- Leave
read_repairatBLOCKINGunless you need partition-level write atomicity. - Schedule anti-entropy repair inside the tombstone grace period.
- Alert when a node is down longer than
max_hint_window. - Avoid read-modify-write; use lightweight transactions or merge-friendly types.
- Never use ALL for availability-sensitive paths.
- Load-test at the 99.9th percentile, not the mean.
Frequently Asked Questions
What does R + W > N mean in a quorum system?
N is the number of replicas that store a key, W is how many must acknowledge a write, and R is how many must answer a read. When R + W > N, every possible read set shares at least one replica with every possible write set, so a read always contacts some replica holding the latest acknowledged write. The reader then picks the newest version by timestamp or version number. The guarantee assumes a fixed replica set, writes that either fully succeed or never become visible, and a reliable way to compare versions.
Is quorum consistency the same as strong consistency or linearizability?
No. Quorum consistency guarantees overlap between read and write sets, which gives read-your-writes for successfully acknowledged writes on a stable replica set. Linearizability additionally requires that all operations appear in one real-time order. Plain quorums break that order when a write partially fails, when a read overlaps an in-flight write, or when last write wins discards a concurrent update. Cassandra’s blocking read repair restores monotonic quorum reads, and lightweight transactions at SERIAL provide linearizable compare-and-set, but ordinary QUORUM reads and writes are not linearizable by themselves.
What is the difference between a sloppy quorum and hinted handoff?
A sloppy quorum is a counting rule: when home replicas are unreachable, acknowledgements from fallback nodes count toward W or R, so the operation succeeds. Hinted handoff is the delivery mechanism: the fallback node stores the write with a hint naming the intended replica and forwards it when that replica recovers. Dynamo and Riak combine the two. Cassandra uses hinted handoff without a sloppy quorum, because a coordinator’s stored hint does not count toward any consistency level except ANY.
How does read repair work in Cassandra 4.0 and later?
The coordinator sends a full data read to one replica and digest reads to others until it can satisfy the consistency level. If the digests disagree, it fetches full data, merges cells by timestamp and writes repair mutations to stale replicas before replying. Cassandra 4.0 removed the probabilistic background options read_repair_chance and dclocal_read_repair_chance, and added a read_repair table option set to BLOCKING by default or NONE. Reads at ONE or LOCAL_ONE never trigger repair, because only one replica is consulted.
Which Cassandra consistency level should I use for multiple datacenters?
For most two-datacenter deployments, LOCAL_QUORUM for both reads and writes gives read-your-writes within each datacenter, keeps remote round trips off the critical path, and survives the loss of a whole datacenter. Plain QUORUM across two datacenters of replication factor 3 needs four of six replicas and fails when either datacenter goes down. Use EACH_QUORUM writes only for data that must exist in a majority of every region before acknowledgement, and accept the added latency and reduced write availability that come with it.
Is DynamoDB a Dynamo-style leaderless database?
No. Despite the name, DynamoDB does not use the 2007 Dynamo paper’s leaderless sloppy quorums. Each partition is a replica group with a leader that replicates a write-ahead log using Paxos and acknowledges after a quorum persists the write. Strongly consistent reads come from the leader; eventually consistent reads, which cost half as much, can come from any replica. Global secondary indexes and streams only support eventually consistent reads. Global tables add a multi-Region strong consistency mode that replicates synchronously to another Region before a write returns.
Further Reading
- Merkle trees explained: inclusion proofs, anti-entropy, Git, Cassandra and Certificate Transparency — how anti-entropy repair finds the divergence that hints and read repair miss.
- Gossip protocols, SWIM membership and failure detection in Cassandra, Consul and Serf — where a coordinator’s idea of which replicas are alive comes from.
- XDP and eBPF Layer 4 load balancing with Katran, Cilium and Maglev consistent hashing — consistent hashing applied to connection routing rather than replica placement.
- Hybrid logical clocks and vector clocks for event ordering — the clock mechanisms that decide whether last write wins is safe.
- DeCandia et al., “Dynamo: Amazon’s Highly Available Key-value Store”, SOSP 2007.
- Bailis et al., “Probabilistically Bounded Staleness for Practical Partial Quorums”, VLDB 2012.
By Riju — about
