CAP Theorem

Saurav Kumar
4 min readNov 17, 2023

The CAP theorem, or Brewer’s theorem, states that in a distributed system, it is impossible to simultaneously achieve Consistency, Availability, and Partition tolerance, proposed by computer scientist Eric Brewer, describes the trade-offs in distributed systems. You can prioritize two of these aspects, but the third will be compromised. Let’s break down the three components:

  1. Consistency (C): All nodes in a distributed system see the same data at the same time. In a consistent system, if a write is successful, all subsequent reads will reflect that write.
  2. Availability (A): Every request to the system receives a response, without guarantee that it contains the most recent version of the information. An available system continues to function and respond to requests even in the face of network failures.
  3. Partition Tolerance (P): The system continues to operate despite network partitions (communication breakdowns) that might occur. Partition tolerance is crucial in distributed systems where nodes are geographically separated, and network issues can occur.

Now, let’s explore the trade-offs with an example:

Consider a distributed database system with nodes in different locations. During a network partition (P), two sets of nodes can’t communicate with each other. Now, you have to choose between consistency and availability:

  • If you prioritize Consistency (CP): In the face of a partition, you might decide to stop accepting write requests until the partition is resolved to ensure that all nodes have the same data. This sacrifices availability during the partition.
  • If you prioritize Availability (AP): You might choose to continue accepting write requests even during a partition, ensuring that the system remains available. However, this might lead to inconsistencies across nodes due to the lack of communication during the partition.
  1. CA System Example (Traditional Database):
  • Consistency: In a traditional relational database, when a write operation occurs, all nodes are updated before the write is considered complete. This ensures strong consistency.
  • Availability: The system ensures that all nodes are always available for read and write operations.
  • Partition Tolerance: These systems typically struggle with partition tolerance. If there’s a network partition, the nodes might be unable to communicate, and the system might become unavailable.

2. CP System Example (e.g., MongoDB with Replication):

  • Consistency: MongoDB with replication can be configured for strong consistency. Write operations are acknowledged only after the data has been replicated to a majority of nodes.
  • Partition Tolerance: MongoDB is designed to handle network partitions. If some nodes are unreachable, the system can continue to operate but write availability may be impacted to maintain consistency.
  • Availability: During network partitions, MongoDB might sacrifice availability for consistency. In other words, write operations might be rejected to ensure that all nodes have the same data.

3. AP System Example (e.g., Couchbase or DynamoDB):

  • Availability: Systems like Couchbase or Amazon DynamoDB prioritize availability. They ensure that read and write operations can proceed even in the presence of network partitions.
  • Partition Tolerance: These systems are designed to be highly tolerant of network partitions. Nodes can continue to operate independently, and the system remains available.
  • Consistency: During network partitions, these systems might exhibit eventual consistency, meaning that all nodes will eventually converge to the same state, but there might be a temporary inconsistency.

It’s important to note that the choice between CA, CP, or AP depends on the specific requirements of the application. For example, in systems where data consistency is critical (e.g., financial applications), a CP system might be more appropriate. In contrast, applications that prioritize high availability and can tolerate eventual consistency might opt for an AP system.

Here are scenarios in which the CAP theorem is applicable:

  1. Distributed Database Design:
  • When designing a distributed database system, you’ll need to make decisions about how the system should behave in the face of network partitions. The CAP theorem helps you understand the trade-offs and make informed decisions about consistency, availability, and partition tolerance.

2. Architecting Distributed Systems:

  • Any application or service that needs to scale horizontally and distribute its data and processing across multiple nodes can benefit from considering the implications of the CAP theorem. This includes cloud-based applications, microservices architectures, and other distributed computing scenarios.

3. Selecting Database Systems:

  • When choosing a database system for a particular application, understanding the CAP theorem can guide your decision-making. Different database systems have different trade-offs, and choosing one that aligns with your application’s requirements is crucial.

4. Handling Network Failures:

  • In real-world scenarios, network partitions and failures are common. The CAP theorem provides a framework for thinking about how your system should behave in the presence of these failures and how to balance consistency and availability.

5. Understanding System Behavior:

  • Even if you’re not directly involved in designing distributed systems, having a basic understanding of the CAP theorem can help you make more informed decisions about system behavior and trade-offs when working with distributed applications.

6. Scalability Considerations:

  • As systems scale, the challenges of distributed computing become more prominent. The CAP theorem is especially relevant when considering the scalability of a system and how it can maintain its performance and reliability as it grows.

It’s important to note that not all systems need to explicitly adhere to the CAP theorem; rather, it provides a framework for thinking about the inherent trade-offs in distributed systems. Depending on the specific requirements and goals of your application, you may choose to prioritize consistency, availability, or partition tolerance based on the nature of the application and its use cases.



Saurav Kumar

I'm a Software engineer at Kantar, skilled in Java and Spring Boot. Passionate about coding and delivering high-quality solutions.