What is the CAP theorem?

Question

Accepted Answer

The **CAP theorem** states that a distributed system can guarantee at most **two of three** properties — **Consistency**, **Availability**, and **Partition tolerance** — at the same time. Since network partitions are unavoidable, the real choice is between consistency and availability during a partition.

## The three properties

```text
CONSISTENCY (C) → every read sees the latest write (all nodes agree on the data)
AVAILABILITY (A) → every request gets a response (the system stays responsive)
PARTITION TOLERANCE (P) → the system keeps working despite network partitions
  (communication breaks between nodes)
→ CAP: you can only fully guarantee TWO of these three simultaneously.
```

## The real trade-off: C vs A (P is mandatory)

```text
In distributed systems, network PARTITIONS WILL happen → P is NOT optional (you must
tolerate partitions) → so the real choice during a partition is C vs A:
  CP (consistency over availability) → during a partition, refuse requests that can't be
    consistent (sacrifice availability to keep data correct) — e.g. financial systems
  AP (availability over consistency) → during a partition, stay available but may return
    stale/inconsistent data (eventual consistency) — e.g. social feeds, many NoSQL stores
→ choose based on whether CONSISTENCY or AVAILABILITY matters more for the use case.
```

## Nuance and practice

```text
→ CAP is about behavior DURING a partition (normally you can have both C and A)
→ It's not strictly binary → many systems offer TUNABLE consistency (per-operation choices)
→ Related: EVENTUAL CONSISTENCY (AP systems converge to consistency over time)
→ Understand the trade-off to choose databases/designs appropriately
```

## Why it matters

Understanding the CAP theorem is valuable because it's a **fundamental concept for distributed systems** that frames a key trade-off, so it's important system-design knowledge.

The CAP theorem — that a distributed system can guarantee at most two of Consistency, Availability, and Partition tolerance simultaneously — captures a fundamental constraint in distributed systems.

Understanding the **three properties** (consistency: reads see the latest write; availability: every request gets a response; partition tolerance: working despite network partitions) is the foundation.

Most importantly, understanding **the real trade-off** is the key practical insight: since **network partitions are unavoidable** in distributed systems (P is mandatory), the actual choice during a partition is between **consistency and availability** — **CP systems** sacrifice availability to keep data correct during partitions (suiting financial systems where correctness is paramount), while **AP systems** stay available but may return stale data (eventual consistency, suiting social feeds and many NoSQL stores where availability matters more).

Understanding this C-vs-A trade-off and choosing based on whether consistency or availability matters more for the use case is essential for designing distributed systems and choosing databases appropriately.

Understanding the **nuance** — that CAP is about behavior during a partition (you can normally have both C and A), that it's not strictly binary (many systems offer tunable consistency), and the related concept of eventual consistency — reflects sophisticated understanding beyond the simplified version.

CAP is a foundational concept frequently referenced in distributed system design and database selection.

Since the CAP theorem frames a fundamental trade-off in distributed systems (consistency vs availability during partitions) that informs system design and database choices, and since understanding the properties, the real C-vs-A trade-off, and the nuances is important for designing distributed systems, understanding the CAP theorem is valuable, practically-relevant system-design knowledge — a fundamental distributed-systems concept framing the consistency-availability trade-off, important for designing distributed systems and choosing databases, and a commonly-referenced concept in system design that reflects understanding of distributed-systems constraints.