Prerequisites

Two Different Questions

The persistent confusion between these models dissolves once you recognize that linearizability and serializability answer entirely separate questions. They are not points on one scale.

Linearizability

Linearizability makes a replicated system behave as though only one copy of the data exists. Every operation appears to take effect instantaneously at some point between its invocation and its response.

The Recency Guarantee

The essential property is real-time ordering. If a write completes before a read begins, that read must observe the written value or something newer, regardless of which replica serves it.

Where It Is Genuinely Required

Serializability

Serializability concerns transactions rather than individual reads. It guarantees that concurrent transactions produce a result equivalent to executing them one after another in some order.

Anomalies It Prevents

Write Skew Deserves Attention

Write skew is the anomaly that snapshot isolation permits and serializability prevents. Each transaction reads a valid state, writes a different row, and the combination violates a constraint neither transaction could observe alone.

-- Invariant: at least one doctor must remain on call

-- Transaction A
BEGIN;
SELECT COUNT(*) FROM on_call
 WHERE shift_id = 42 AND is_on_call = TRUE;   -- returns 2

UPDATE on_call SET is_on_call = FALSE
 WHERE doctor_id = 101 AND shift_id = 42;
COMMIT;

-- Transaction B, running concurrently
BEGIN;
SELECT COUNT(*) FROM on_call
 WHERE shift_id = 42 AND is_on_call = TRUE;   -- also returns 2

UPDATE on_call SET is_on_call = FALSE
 WHERE doctor_id = 102 AND shift_id = 42;
COMMIT;

-- Result: zero doctors on call, invariant violated

Comparing the Two Directly

Strict Serializability

Combining both yields strict serializability: transactions behave as if executed serially, and that serial order respects real time. It is the strongest practical guarantee.

Eventual Consistency

Eventual consistency promises only convergence: if updates cease, all replicas will eventually reach the same state. It makes no statement about when, or what is returned meanwhile.

Anomalies It Permits

Causal Consistency

Causal consistency occupies valuable middle ground. It preserves the order of causally related operations while allowing concurrent operations to be seen in any order.

The Full Hierarchy

Implementing Session Guarantees

class SessionContext {
    constructor(sessionId) {
        this.sessionId = sessionId;
        this.observedVersions = new Map();
    }

    recordWrite(key, version) {
        const current = this.observedVersions.get(key) ?? 0;
        this.observedVersions.set(key, Math.max(current, version));
    }

    requiredVersion(key) {
        return this.observedVersions.get(key) ?? 0;
    }
}

async function sessionAwareRead(key, session) {
    const required = session.requiredVersion(key);
    const local = await datastore.readLocalReplica(key);

    if (local.version >= required) {
        session.recordWrite(key, local.version);
        return { value: local.value, path: "local" };
    }

    const quorum = await datastore.readQuorum(key);
    session.recordWrite(key, quorum.version);

    return { value: quorum.value, path: "quorum-escalation" };
}

Tracking observed versions per session delivers read-your-writes and monotonic reads while serving most requests from a fast local replica.

Selecting a Model Per Operation

const CONSISTENCY_MODEL = {
    "lock.acquire":       "linearizable",
    "username.claim":     "linearizable",
    "funds.transfer":     "strict-serializable",
    "inventory.reserve":  "serializable",
    "cart.read":          "session",
    "comments.list":      "causal",
    "catalog.read":       "eventual",
    "counter.increment":  "eventual"
};

function requiredModel(operation) {
    const model = CONSISTENCY_MODEL[operation];

    if (!model) {
        throw new Error(
            `Operation ${operation} has no declared consistency model`
        );
    }

    return model;
}

The Cost of Each Model

Frequent Misunderstandings

Verifying Consistency Claims

Consistency violations are rare, timing-dependent, and invisible in ordinary testing. They require deliberate verification.

describe("inventory serializability", function () {
    it("prevents overselling under concurrency", async function () {
        await inventory.set("sku-501", 1);

        const attempts = Array.from({ length: 20 }, () =>
            inventory.reserve("sku-501", 1).catch(() => null)
        );

        const results = await Promise.all(attempts);
        const succeeded = results.filter(Boolean).length;
        const remaining = await inventory.get("sku-501");

        expect(succeeded).toBe(1);
        expect(remaining).toBe(0);
    });
});

Monitoring Consistency

Common Design Mistakes

System Design Interview Discussion

Design Checklist

Knowledge Check

Summary

Linearizability and serializability are commonly confused because both are described as strong, yet they constrain different things. Linearizability is a recency guarantee for a single object, ensuring reads never return a value older than a completed write. Serializability is an ordering guarantee across transactions, ensuring concurrent execution is equivalent to some serial order.

Neither implies the other. A serializable system may return stale data, and a linearizable key-value store may still permit write skew across keys. Strict serializability combines both and is the strongest practical guarantee, at correspondingly high cost.

Eventual consistency promises only convergence when writes cease, permitting stale reads, missing own writes, time moving backwards, and causal violations. Session guarantees address the anomalies users actually notice at modest cost, and causal consistency is the strongest model that remains available during a network partition.

The practical approach is to identify which invariants matter, assign a model per operation, verify what your database actually provides rather than what marketing claims, and test concurrency deliberately because these violations are invisible under sequential testing.