Distributed systems often need to handle concurrent writes from multiple replicas. In a traditional design, coordination, locking, or consensus decides which write wins. CRDTs—Conflict-Free Replicated Data Types—take a different approach: they are designed so that replicas can accept updates independently and still converge later without central coordination. That is why CRDTs are often presented as an alternative to consensus for certain workloads.
The idea is elegant. Instead of asking every node to agree before accepting a write, a CRDT embeds the merge rule in the data type itself. If every replica sees the same set of updates, every replica ends in the same state. That promise comes from the formal CRDT work by Nuno Preguiça, Carlos Baquero, and Marc Shapiro, and from earlier foundational work by Marc Shapiro and collaborators.
But CRDTs are not magic. They solve convergence, not every correctness problem. Once systems get larger, two quiet limits appear: metadata growth and semantic merge limits. Those are the places where CRDTs stop being a neat theory story and start becoming an engineering trade-off.
What CRDTs Actually Guarantee
A CRDT allows local updates without remote synchronization, then uses mathematically sound merge rules so that replicas converge once they have seen the same updates. That is the formal promise behind strong eventual consistency. It is why CRDTs are attractive in collaborative apps, offline-first products, and geo-distributed systems.
The key phrase is for certain categories of data. CRDTs work best when the data model is friendly to automatic merging—counters, sets, some lists, and some text structures. They are weaker when the business meaning of a change matters more than the raw data structure.
Why CRDTs Feel So Powerful
With CRDTs, a system can stay responsive even during partitions or offline usage. A user can add an item, edit a note, or increment a counter immediately, without waiting for the server. Later, the replicas synchronize and the merge is deterministic. That gives users a smoother experience than designs that block writes until consensus is reached.
This is also why CRDTs are strongly associated with local-first software and modern collaboration tools. They let software remain usable when connectivity is poor, and they reduce the need for a globally coordinated write path.
The First Quiet Failure: Metadata Growth
The most visible technical downside of many CRDTs is metadata bloat. To make conflict-free merging work, the system often needs to carry extra information such as causal histories, identifiers, tombstones, or positional metadata. That bookkeeping is part of the correctness story.
The problem is that metadata does not always shrink naturally. In many CRDT designs, deleted elements must still be remembered for a while so that other replicas can correctly interpret future merges. That can lead to tombstones and growing history. Over time, the overhead becomes a real storage and transmission cost.
Metadata overhead can grow faster than the content itself
The Second Quiet Failure: Semantic Merge Limits
The deeper limitation is meaning. CRDTs guarantee that replicas converge, but they do not guarantee that the converged result matches what a human would consider the right outcome in every case. That gap between mathematical convergence and user intent is where semantic merge limits appear.
For simple objects, this is easy to miss. A counter that merges additions looks perfect. A set that merges adds and removes can also look clean. But when you move into text editing, lists, documents, or rich objects, the problem becomes harder. A system can converge correctly while still producing surprising or undesirable behavior for users.
Rich text systems need to preserve not just characters, but also formatting spans, positions, and user intent. The Peritext work shows that preserving intent in collaborative editing is much harder than simply merging structures.
Why Consensus Still Matters
This is why consensus never disappears. In systems such as banking, reservations, inventory, or policy enforcement, the system must often maintain invariants that automatic merging cannot safely express. Two replicas cannot both be right if the business rule says only one seat is left or only one transfer may succeed. In those cases, agreement before commit still matters.
CRDTs are not a replacement for consensus in all cases. They are a way to avoid coordination when the data type and the business rules allow it. That is a narrower claim, but it is the correct one.
Where CRDTs Shine
CRDTs are strongest when the application values availability, offline use, and low-latency local writes more than strict coordination. They are a natural fit for collaborative notes, shared whiteboards, local-first apps, and some kinds of document editing. They are also attractive in systems where temporary divergence is acceptable as long as convergence is deterministic later.
They are especially good when operations naturally commute or when the data structure has a merge rule that is easy to reason about. In those cases, CRDTs let the system remain responsive and resilient without making every user action wait for a central decision.
Where CRDTs Quietly Fail
CRDTs become weaker when the application needs one or more of the following:
- bounded metadata over long periods of use, because history and tombstones can keep growing;
- business-level correctness, because convergence does not necessarily equal the right outcome;
- invariant enforcement, because some constraints require coordination;
- human-intent preservation, because the mathematically valid merge can still surprise users.
That is why the best CRDT work today often focuses not just on convergence, but on reducing metadata, improving performance, and making merge behavior more intuitive for real users. The hard part is no longer “can replicas converge?” The hard part is “can they converge in a way that still feels correct?”
What We Have Learned
CRDTs are one of the most elegant answers to a classic distributed systems problem: how to merge conflicting writes without coordination. They provide a strong path to availability, offline support, and deterministic convergence, which is why they are so attractive for collaboration and local-first software. But their promise has a boundary. As systems grow, metadata can accumulate, and as data becomes more human-centered, semantic merge limits become harder to ignore. The real lesson is that CRDTs are not a substitute for every coordination problem. They are a powerful tool for the situations where convergence matters more than centralized agreement—and a reminder that some kinds of correctness still require more than math alone.
