Course contentsShow
← System Design
Lesson 531 of 1,91915. Consistency ModelsFree lesson

What is Eventual Consistency?

Define eventual consistency: all replicas converge to the same state eventually, given no new updates.

What is Eventual Consistency?

You'll learn: What eventual consistency means and why distributed systems use it to prioritize availability over immediate consistency.


The Core Idea

Eventual consistency is a consistency model where all replicas in a distributed system will eventually converge to the same state, given that no new updates arrive. Unlike strong consistency (which guarantees immediate agreement across all nodes), eventual consistency allows replicas to temporarily diverge but promises they'll sync up over time.

This model accepts a period of inconsistency in exchange for higher availability and lower latency—making it an AP choice in the CAP theorem framework.

How It Works in Practice

Imagine three friends keeping shared shopping lists on their phones. When one person adds "milk" to the list, the others don't see it immediately. Their apps might show different items for a few seconds or minutes. But eventually—after their phones sync—everyone's list matches. That's eventual consistency.

In distributed databases:

  1. A write happens on one replica
  2. The system acknowledges success immediately (high availability)
  3. Updates propagate asynchronously to other replicas
  4. Eventually (maybe milliseconds, maybe seconds), all replicas agree

The Promise and the Gap

The guarantee is simple: if you stop writing new data, all replicas will eventually read the same value. The tricky part? "Eventually" has no strict time bound. It might be 10ms or 10 seconds, depending on network conditions, system load, and replication lag.

This makes eventual consistency perfect for scenarios where stale reads are acceptable—like social media feeds, product catalogs, or DNS records.


Key Takeaway: Eventual consistency trades immediate agreement for availability, guaranteeing replicas will converge to the same state once updates stop flowing—prioritizing responsiveness over real-time accuracy.