Replication

Replication keeps multiple copies of the same data. It buys four things: durability (a dead node doesn't lose data), read scaling (spread reads across copies), geographic locality (a copy near each region), and failover (promote a copy when the primary dies).

This is a different problem from sharding. Sharding splits data so each node holds a part; replication copies data so each node holds the same part. They're orthogonal, and most real systems do both — shard for capacity, replicate each shard for durability and reads (Sharding).

The most common model: one leader takes all writes, then streams changes to followers that serve reads. Writes have a single ordering point (no write conflicts), and reads scale by adding followers. The tension is in when a write is considered done.

Replication lag is the gap between a write hitting the leader and reaching a follower. Read from a lagging follower right after writing and your own change is missing — a read-your-writes violation. This is where session guarantees come in: pin a user to the leader for their own reads, or track the version they've seen (Consistency Models).

When the leader dies, the system detects it, picks a follower, and promotes it. Sounds simple; three things make it hard.

With multiple leaders — typically one per region — each takes writes locally and replicates to the others. Writes are fast and local everywhere, and no single leader is a bottleneck or a distant round trip. The price is write conflicts: two regions can edit the same record at the same time, and both are "correct" locally.

Resolving conflicts is the whole problem. Last-write-wins is simplest and silently drops one of the two writes — sometimes fine, sometimes data loss you'll regret. CRDTs (conflict-free replicated data types) are data structures designed so concurrent updates merge deterministically without loss — the right tool for counters, sets, and collaborative text, at the cost of constrained operations. Multi-leader is the write side of active-active regions (Multi-Region).

Leaderless stores (Dynamo, Cassandra) drop the leader entirely. A client writes to several replicas and reads from several, and overlap guarantees freshness. With N replicas, requiring W to ack a write and R to answer a read, the rule W + R > N forces every read set to overlap every write set by at least one up-to-date replica.

Two repair mechanisms keep replicas honest. Read repair: when a read notices a stale replica, it writes the fresh value back. Anti-entropy: a background process compares replicas and reconciles differences. And a sloppy quorum with hinted handoff keeps writes flowing during a partition — a temporary node accepts the write and hands it off when the real owner returns, trading strictness for availability.

Underneath every model above sits one idea: log first, apply second. Before a database changes a page, it appends the change to a write-ahead log on durable storage. If the process crashes mid-operation, it replays the log on restart and recovers. The log is the source of truth; the data files are a materialized view of it.