Trigpoint
In 2012 the original author wrote that the popular “two of three” formulation was always misleading.

CAP theorem

CAP Theorem · Brewer (2000) / Gilbert & Lynch (2002)
Checked against the sources ✓ Lab case ✓ Systems design · distributed trade-offs Read first: Microservices Tell the editor privately ▸
In three sentences When a network partition happens, you can have consistency or availability, and not both. A partition is not an option you can decline. It is a condition of the environment. So the real question is not which two of the three. It is which side you want at the moment the partition occurs.

↳ Seen a counter-example?

Holds when
When the same data can be changed in several places and the connection between them may break.
Evidence
Conceptual framework; Checked against the sources
Breaks down when
Assuming you must give up consistency or availability for good, carrying single-machine guarantees onto a network, or dropping the proof's model misapplies it.
CAP theorem Brewer (2000) · Gilbert & Lynch (2002) The trade-off lives in the partition window only Partition window Time (deliberately no scale, no units) Before the partition consistency and availability together if it knows none is happening Choose consistency availability falls Choose availability consistency falls only one of the two After the partition choosing availability means reconciling deferring it loses both The trade-off can be made per surface not one cut for the whole system: consistency for what goes out, availability for drafts Figure: trigpoint.pub
Figure 1 · Time runs along the horizontal axis, and the middle stretch is the window in which a network partition occurs. Outside the window, provided the system knows it is not partitioned, consistency and availability can both be had. Inside it, only one of the two, and which one you choose decides whether conflicts have to be reconciled once the window closes. How long a partition window lasts varies by environment, and this page has no measured figure to mark. View full size ▸

1. What happened

Take the three properties first. Consistency: every read sees the result of the most recent write. Availability: every non-failing node returns a valid response to every request. Partition tolerance: the system keeps working even when messages between nodes are arbitrarily lost or delayed.

The 2000 keynote proposed that you can have at most two of the three[1]Brewer, E. A. (2000-07-19). Towards Robust Distributed Systems. Keynote, ACM PODC, Portland, OR. Abstract in Proceedings of PODC '00, p. 7. DOI 10.1145/343477.343502. Bibliographic details confirmed by two sources. Claims matched against the full text. Slides from the keynote at the symposium on Principles of Distributed Computing (PODC). One slide is titled The CAP Theorem and its statement opens with Theorem:, but no proof is given; the name conjecture comes from the title of Gilbert and Lynch's 2002 paper. By the author's 2012 retrospective, the theorem first appeared in autumn 1998, was published in 1999, and was presented in this 2000 keynote; the same piece records that the first version of the consistency-versus-availability argument appeared as ACID versus BASE in a 1997 systems paper of which he was a co-author.. And the popular version of that sentence is its own biggest problem, because it makes partition tolerance sound like an option. On a real distributed network, dropped packets and unreachable nodes are certain to happen. A partition is a condition of the environment, not a checkbox.

So the correct shape is this. While a partition is not happening, and the system knows it is not, consistency and availability can both be had, with no trade-off. Once a partition does happen, you can only have one: either you refuse or block the requests that would break consistency (availability drops), or you let both sides of the partition keep serving (consistency drops, and conflicts have to be reconciled afterwards).

The word knows is doing work. On a network where message delay has no upper bound and nodes have no clocks, a late message cannot be told apart from a lost one, so a system that insists on always answering cannot guarantee consistency even in a run where nothing was actually lost[4]Gilbert, S. & Lynch, N. (2002). Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services. ACM SIGACT News, 33(2), 51–59. Bibliographic details checked against the official record. Claims matched against the full text. Corollary 1.1 of the same paper: in the asynchronous model, with no clocks, an always-available algorithm cannot guarantee atomic consistency even in executions where no message is lost, because a lost message cannot be told apart from an arbitrarily delayed one. In the partially synchronous model, with a clock at each node, the paper proves the impossibility still holds (Theorem 2), but the analogue of Corollary 1.1 does not: there are algorithms that return consistent data when every message is delivered and return stale data only when messages are lost.. With clocks the picture changes: the same paper shows that there are then algorithms that return consistent data when every message arrives and return stale data only when messages are lost. The practical counterpart is to put a time limit on communication and treat a timeout without agreement as a partition.

Attribution where due: The trade-off was put forward by Brewer in his keynote Towards Robust Distributed Systems at PODC in July 2000[1]Brewer, E. A. (2000-07-19). Towards Robust Distributed Systems. Keynote, ACM PODC, Portland, OR. Abstract in Proceedings of PODC '00, p. 7. DOI 10.1145/343477.343502. Bibliographic details confirmed by two sources. Claims matched against the full text. Slides from the keynote at the symposium on Principles of Distributed Computing (PODC). One slide is titled The CAP Theorem and its statement opens with Theorem:, but no proof is given; the name conjecture comes from the title of Gilbert and Lynch's 2002 paper. By the author's 2012 retrospective, the theorem first appeared in autumn 1998, was published in 1999, and was presented in this 2000 keynote; the same piece records that the first version of the consistency-versus-availability argument appeared as ACID versus BASE in a 1997 systems paper of which he was a co-author., and the formal proof is in the 2002 paper by Gilbert and Lynch in ACM SIGACT News[2]Gilbert, S. & Lynch, N. (2002). Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services. ACM SIGACT News, 33(2), 51–59. DOI 10.1145/564585.564601. Bibliographic details checked against the official record. Claims matched against the full text. Proves, in the asynchronous network model, that when messages may be lost a read/write data object cannot guarantee both availability and atomic consistency; it also proves that in a partially synchronous model, where each node has a clock, the result still holds whenever messages may be lost arbitrarily. This paper, not the keynote, is the source of the status of theorem..

2. Why this matters to you

This page applies wherever the same thing is being changed in two places at once. You do not need a server for it.

The common shapes: your notes or files on two devices, or you and a collaborator each editing a copy, or several lines of work running at once against the same body of material. The network drops, or you forget to sync, or both sides edit simultaneously. That is a partition. And in that moment you have already chosen a side, usually without choosing consciously.

What choosing consistency looks like: nothing may continue until the sync completes (locking, queueing, preferring to stop). The benefit is that there is never a second version. The cost is that you are blocked.

What choosing availability looks like: both sides keep editing and conflicts get handled afterwards. The benefit is that work does not stop. The cost is that reconciliation has to actually happen, and most people skip that step, which leaves two versions that are both incomplete.

Three judgements transfer directly.

First, outside a partition there is nothing to trade off in advance. That is the most usable sentence here: partitions are rare, and while there is none there is little reason to give up consistency or availability[3]Brewer, E. (2012). CAP Twelve Years Later: How the ‘Rules’ Have Changed. Computer, 45(2), 23–29. DOI 10.1109/MC.2012.37. Bibliographic details checked against the official record. Claims matched against the full text. The author's own words: “The ‘2 of 3’ formulation was always misleading because it tended to oversimplify the tensions among properties.” And: “Because partitions are rare, there is little reason to forfeit C or A when the system is not partitioned.” What misleads is the two of three formulation, not the theorem itself.. Do not pre-emptively sacrifice something because you once read the theorem. But not partitioned has to be something the system knows, not something it assumes: put a time limit on syncing and treat a timeout as a partition, rather than taking for granted that the network never drops.

Second, the trade-off can be made per surface rather than once for a whole system. Choose consistency for what goes out publicly (prefer to queue), availability for internal drafts (let them run separately), and availability with a visible generation stamp for derived boards (admitting they lag).

Third, and this is the one almost nobody does: if you choose availability, schedule the reconciliation as work. Choosing availability does not mean conflicts need not be handled. It means handling them later. Defer it and never do it, and you have lost consistency and availability both.

Verification layer · Members
The guided layer of this node is open to all readers.
Verification details and failure boundaries are for members.
US$8.25 a month on average · or subscribe monthly ▸

Lab cases 2 first-hand cases from our studio

Open previewField record · 2026-06

We chose availability and pushed consistency to the moment of the merge

Situation: several lines of work change the same knowledge base at once. On 12 June 2026 the knowledge base started keeping version history, and every line of work shared one working area and one list of changes waiting to be saved. The general rules carried a discipline from that day: a save takes only files within one’s own scope, and work is saved at the end of each session, because changes another line has left unsaved in the working area would otherwise be swept up by the next loose save.

This is an analogy of the CAP trade-off: strictly, CAP applies only between several replicas that can each answer on their own; the shape here is the same, but it is not the same thing.

Decision point: within two days of the discipline being set, it failed twice. On 13 June one line took a whole-tree snapshot for its own operation and swept in another line’s half-finished work. On 14 June one line put only its own files on the list waiting to be saved, but the save took the whole list, and 8 files that another line had put there to save itself went with it.

There were at least four workable options. One, a lock, so that only one line writes at a time. Two, tighten the discipline: a save takes only the paths named on the command. Three, give each line its own isolated copy to work in, merged back into the main line at the end. Four, keep sharing and work out afterwards from the saved content who changed what.

What we did and what happened: on 14 June we did the second and the third together. Saving named paths only became the floor, and isolated copies became an option. The floor works only if both sides keep it, and it cannot stop two lines changing the same file at the same time; between sessions that were not in isolated copies, the same kind of incident happened at least six times in all by 17 August. From 19 August every session that writes goes into an isolated copy by default, and saving named paths only remains as the fallback for sessions outside one.

The negative result is on the convergence side. In two counts on the same day, 7 September, isolated copies fell from 36 to 23 while commits left on branches and not merged back rose from 75 to 77. We therefore set rules for classifying and disposing of branches that have not been merged back: a branch that carries content must be dealt with within 14 days, and none is ever deleted automatically.

Take-away: if several lines of work share one working area, give each its own isolated copy, and schedule merging back into the main line as work with a deadline. Isolation without convergence only pushes the conflicts into the future.

Trigpoint PassField record · 2026-06

Which surfaces choose availability, and which must choose consistency

In August 2026 we gave each line of work its own isolated copy, so the content side chose availability. In early October the public website had several problems in one day: one language version went live about four weeks early, and one deployment pushed out a stale build. At that point there were at least four workable ways to decide whether the website should follow the content side, and they differ in who may deploy and from where.

Trigpoint Pass content · includes applicable criteria

Read the member edition ▸

Full access to the lab cases. Trigpoint Pass ▸

Common misreadings

Page verification: Checked against the sources ✓ · Page version v2 · Content last revised 2026-11-14 · Corrections ↓

  • A common retelling, pick two of the three properties: the author's own 2012 piece says plainly that the two of three formulation was always misleading, because it oversimplified the tensions among the three; partitions are rare, and while a system is not partitioned there is little reason to forfeit consistency or availability. The trade-off happens only during a partition, and locally. #
  • A common retelling, giving up partition tolerance is also an option: on a real distributed network a partition is a condition of the environment, not a box to tick. Having consistency and availability together holds only on the assumption that partitions do not happen, typically a single machine or a single site. #
  • A common retelling, this is a theorem proved in 2000: one slide of the 2000 keynote has theorem in its title, but no proof is given; the proof is the 2002 paper by two other authors titled after Brewer's conjecture, and the proof is bound to a particular network model and definitions. Three things to keep apart. By the author's own 2012 retrospective, the idea first appeared in autumn 1998 and was published in 1999; the argument between consistency and availability had appeared earlier, as ACID versus BASE, in a 1997 paper he co-authored. #
Verification record

Records how far each claim was checked, not a guarantee that it is true.

Corrections
  • 2026-10-09 · An earlier version of this page had three statements that did not match the original material, and all three have been corrected against the originals. First, it said Brewer, in the 2000 keynote, did not frame the trade-off as a theorem and drew it from operational observation; one of the slides is in fact titled The CAP Theorem, it simply gives no proof, and the name conjecture comes from the title of Gilbert and Lynch's 2002 paper. Second, the two sentences it quoted as Brewer's own words in his 2012 retrospective, including that the theorem is misleading, came from a third-party reading summary; what the author wrote is that the two of three formulation was misleading, not the theorem itself. Third, it stated without condition that consistency and availability can both be had while not partitioned; that holds only when the system knows it is not partitioned.
References

How to read the source notes “Bibliographic details checked” means author, year, title and venue were confirmed. It does not mean the source's claims were checked. “Matched against the full text” means the claim was compared with the text of the source itself. Definitions as of 2026-09-20.

  1. [1] Brewer, E. A. (2000). Towards Robust Distributed Systems. Keynote, ACM PODC, Portland, OR, 19 July 2000. Abstract in Proceedings of PODC '00, p. 7. ↩
  2. [2] Gilbert, S. & Lynch, N. (2002). Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services. ACM SIGACT News, 33(2), 51–59. ↩
  3. [3] Brewer, E. (2012). CAP Twelve Years Later: How the 'Rules' Have Changed. Computer, 45(2), 23–29. ↩
  4. [4] Gilbert, S. & Lynch, N. (2002). Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services. ACM SIGACT News, 33(2), 51–59. ↩

↳ Is a citation wrong?

Tell me when a new shelf opens

Tell me when a new shelf opens

Shelf notices are sent only when a new shelf opens or when the reading rules change.

Trial

Tell the editor privately: a correction, a counter-example or where it applies

Submissions are read only by the editor, and nothing is published before they are handled. Once a note is handled, a summary and response written by the editor are published. No sign-up is needed, and the nickname may be left blank.

What are you submitting?
Set a public name to be credited by name ▸
Submit anonymously, without signing in

Signing in lets you follow the status on your page. What you have written is kept.

You are signed in: this note is linked to your account, visible only to you and the editor, so you can follow its status on your page. The text is never published. Full privacy policy ▸

Submit anonymously instead, not linked to your account ▸

No email is collected. Your original text and nickname are read only by the editor and are never published; the site publishes only a summary the editor writes. The human check is provided by Cloudflare Turnstile. To limit abuse, the system keeps a hash of your IP address, not the address itself. Your original text is stored with our cloud provider and can be deleted on request. Full privacy policy ▸