Consistency Models Explained Simply

Consistency Models Explained Simply

Consistency models describe how a distributed system presents updates to readers. Understanding these models helps you select the right datastore and set correct expectations for clients.

Strong Consistency

All reads see the latest write. This is the simplest model to reason about but often requires coordination across replicas, which increases latency.

Eventual Consistency

Replicas converge over time. Reads may return stale data, but availability and scalability improve.

Causal Consistency

Preserves the order of causally related operations. If event B depends on event A, all readers will see A before B.

Read-Your-Writes and Monotonic Reads

Client-centric guarantees such as:

• Read-your-writes: a client sees its own updates.
• Monotonic reads: once a value is seen, later reads do not go backward.

These guarantees can be layered on top of eventual consistency with session tracking.

Tradeoffs in Practice

Model	Latency	Availability	Complexity
Strong	Higher	Lower	Moderate
Eventual	Lower	Higher	Higher
Causal	Moderate	High	High

Spring Boot Example: Consistency-Aware Reads

@RestController
@RequestMapping("/profiles")
public class ProfileController {
    private final ProfileService profileService;

    public ProfileController(ProfileService profileService) {
        this.profileService = profileService;
    }

    @GetMapping("/{id}")
    public ProfileView getProfile(@PathVariable String id,
                                  @RequestHeader(value = "Consistency", required = false) String consistency) {
        ConsistencyLevel level = ConsistencyLevel.from(consistency);
        return profileService.getProfile(id, level);
    }
}

Summary

Consistency models are a spectrum. Choose strong consistency for correctness-critical workflows and eventual or causal consistency when availability and scalability dominate.