skip to content

questions

2

PACELC extends the CAP theorem with a clause for when the network is NOT partitioned. What does the 'ELC' part of PACELC add, and why does stronger consistency cost latency even when nothing has failed?

level: middleimportance: must knowfreq 55%

answer

  1. PAC = CAP's partition case
  2. ELC: the E is for else; name the two things traded then
  3. what a consistent read or write must do before it answers
  4. DynamoDB strong vs eventual read = ELC in the API
  5. PACELC covers the non-partitioned time CAP is silent about

basics

~20 s

PACELC says: if there's a network split (P), pick availability or consistency (A or C) — that's CAP. But Else (E), even when the network is fine, you still must pick between faster answers (Latency) or more correct answers (Consistency), because waiting to check with other machines always costs time.

solid answer

~40 s

PACELC, coined by Daniel Abadi, says CAP only describes behavior during a partition — the 'PAC' part: if Partitioned, choose Availability or Consistency. But partitions are rare; most of the time the network is healthy, and even then a distributed system still faces a trade-off — the 'ELC' part: Else, choose lower Latency or stronger Consistency. This is because achieving strong consistency, even without a partition, requires coordinating with remote replicas, which adds network round-trip latency. A system can be CP under CAP yet still choose low latency over strict consistency in normal operation, or vice versa — PACELC forces architects to make that everyday trade-off explicit rather than treating consistency as a partition-only concern.

go deeper

for a junior

Doesn't need to know PACELC by name, but should recognize that answering from a local copy without checking with other machines is faster and may miss the latest write.

for a middle

Should state both halves of the formula — PAC as CAP's partition case, ELC as the everyday latency-vs-consistency case — and explain why coordination costs latency.

for a senior

Should be able to place a real system on both axes independently and explain why the combination isn't contradictory, say how the latency cost grows with the distance between replicas, and recognize a system that is slow in normal operation because it demands strong consistency for data that doesn't need it.

for a principal

Should explain why PACELC exists as a critique or extension of CAP's scope, and reason about how to route different operations of the same system to different points on the latency-vs-consistency spectrum based on their actual correctness requirements.

## The gap CAP leaves open CAP theorem only tells you what happens in the exceptional case: when the network is partitioned. It says nothing about system behavior during the vast majority of the time a distributed system is actually running, which is the normal case where all nodes can reach each other. Daniel Abadi pointed out in 2010 that this gap matters, because even with a healthy network, a distributed system still has to make a consistency-versus-performance trade-off on every operation, and that trade-off looks nothing like the partition-time choice CAP describes. He proposed **PACELC** to name both trade-offs in one formula: 1. If there is a **Partition (P)**, choose between Availability and Consistency (A or C) — exactly CAP. 2. **Else (E)**, when the system is running normally with no partition, choose between Latency and Consistency (L or C). ## Why the else clause exists The mechanism behind the 'else' clause is straightforward once you look at what strong consistency actually requires operationally. To guarantee a read always returns the most recent write, a system generally must involve more than one node in every operation: - a **write** has to be acknowledged by a quorum of replicas, or all of them, before it's considered committed; - a **read** may need to check with a quorum or the current leader to be sure it isn't returning stale data. Every extra round trip costs real time — network latency within a data center might be sub-millisecond, but between regions it can be tens to hundreds of milliseconds. So a system that insists on strong consistency pays a latency tax on every request, partition or not. A system willing to relax consistency can skip those round trips — serve a read from the nearest local replica, acknowledge a write as soon as one node has it — and respond far faster, at the cost that a read might not reflect the very latest write yet. ## What the formula adds to CAP This gap existed in CAP because CAP was framed as a theorem about an exceptional failure condition, but engineers designing globally distributed systems needed to justify decisions that had nothing to do with rare partitions — decisions like 'should this read go to the local replica or the leader replica three regions away' made on every request under totally normal conditions. PACELC gives that decision a name and slots it next to the CAP decision so the two don't get conflated. A system can, for instance, be **CP** under CAP — sacrificing availability during a partition to stay consistent — while also being **EL** under PACELC — favoring low latency over the strongest consistency in normal operation — a combination CAP alone can't express, because CAP is silent about the non-partitioned case entirely. ## The cost on each side The trade-off has a concrete cost on each side. | The everyday choice | What it costs, and the data it suits | |---|---| | **Favoring Consistency** in the 'else' branch | Means every operation pays the coordination latency described above — acceptable for data where correctness matters more than milliseconds, like a bank balance or an inventory count that must never oversell. | | **Favoring Latency** | Means operations return fast using local or cached state, at the cost that different clients can briefly see different answers to the same query even with a perfectly healthy network — acceptable for data like a like-count or a recommendation where a few seconds of staleness is invisible but a slow page load isn't. | ## The failure mode it produces The failure mode this trade-off produces in production is subtler than a partition-triggered outage: teams that don't think in PACELC terms often discover, well after launch, that their system is slower than expected under normal conditions because every read is doing a full quorum round-trip across regions for data that never needed strong consistency in the first place — the 'else' cost was being paid on every request, silently, with no partition in sight to explain it. The fix is usually to identify which operations actually require the latest-write guarantee and downgrade the rest to a faster, locally-served read path. ## The trade-off made explicit in an API A concrete real-world example: DynamoDB offers a per-read choice between 'eventually consistent reads' and 'strongly consistent reads.' - The **eventually consistent** option is the default and costs half as much read capacity; it can be answered from an availability zone near the caller, which lowers latency, and its answer might not reflect a write that has just completed. - The **strongly consistent** option returns an answer that reflects every earlier write that succeeded, at twice the read capacity. That single API parameter is PACELC's ELC trade-off made explicit and left to the application developer to choose per call, rather than baked into the system as a single global policy — exactly the kind of everyday decision CAP alone gives no vocabulary for.

  • Can a system's PAC choice and its ELC choice be different from each other — e.g., CP but EL?
    Yes, and this is exactly the combination PACELC was invented to describe. A system can sacrifice availability for consistency during a rare partition while, during the far more common non-partitioned case, favoring fast local responses over strict consistency for operations that don't need the latest-write guarantee. CAP alone can't express this because it has nothing to say about non-partitioned behavior.
  • When does that latency cost become large enough to shape the design?
    When the replicas that have to be consulted are far apart. Inside one data center a round trip is short, so coordinating costs little. Between regions it runs to tens or hundreds of milliseconds, paid on every request that needs the latest write. That is why the else choice matters most in geographically distributed systems, which tend to keep strong consistency for the data that needs it and serve the rest from a nearby replica.
  • Is 'eventual consistency' the same trade-off as choosing Latency over Consistency in PACELC's else clause?
    They're closely related but not identical: PACELC's latency-vs-consistency choice is about what an individual system does in normal operation, while 'eventual consistency' is one specific, named point on the broader consistency-model spectrum describing how and when replicas converge. A system that picks Latency in PACELC will typically end up offering some flavor of weaker-than-strong consistency, but the exact strength of that guarantee is a separate question.

CAP is like asking 'what do you do if the phone line goes dead mid-call' — drop the call, or keep talking on both ends without knowing what the other said. PACELC adds: 'even when the line works fine, do you pause every sentence to read it back and confirm the other person heard it correctly (slower, always accurate), or just talk at normal speed and risk an occasional mishearing (faster, usually fine)?'

  • Thinks CAP already covers the no-partition case
  • Can't explain why strong consistency costs latency without a partition
  • Assumes a system's CAP choice (CP/AP) automatically determines its PACELC else-choice
  • Confuses PACELC's latency-vs-consistency trade-off with the full eventual-consistency spectrum
  • Can't name any real trade-off, such as an API flag, that reflects the ELC choice

context

open as a page

A wide-column store lets you configure the consistency level per read or write request — for example, requiring acknowledgment from just one replica versus requiring acknowledgment from a majority of replicas. How does this per-request knob let a team make different CAP and PACELC trade-offs for different operations within the SAME cluster, and what's the risk of misusing it?

level: seniorimportance: should knowfreq 50%

basics

~20 s

Instead of the whole database picking 'always fast' or 'always safe' once, each individual read or write can choose: talk to just one copy (fast, might be stale) or talk to most copies (slower, more sure to be correct). Different parts of the app can pick differently. The risk is picking 'fast' for something that actually needed to be 'safe' and getting wrong data where it matters.

open as a page