Prerequisites

Why Conflicts Exist

A conflict occurs when two writes to the same data are made independently, neither aware of the other. There is no correct ordering between them, because causally they are unordered.

The Last-Writer-Wins Trap

The most common strategy compares timestamps and keeps the later write. It is trivial to implement, requires no metadata, and is the default in many systems. It is also the strategy most likely to destroy data.

The Strategy Landscape

Field-Level Merge

Rather than treating a record as one indivisible value, track versions per field. Concurrent writes to different fields then merge cleanly, and only same-field conflicts require a decision.

{
    "entityId": "profile-4821",
    "fields": {
        "displayName": {
            "value": "R. Ansari",
            "version": { "replica-east": 4 }
        },
        "email": {
            "value": "user@example.com",
            "version": { "replica-west": 3 }
        },
        "timezone": {
            "value": "Asia/Kolkata",
            "version": { "replica-east": 2 }
        }
    }
}

function mergeByField(siblingA, siblingB) {
    const merged = {};
    const unresolved = [];

    const fields = new Set([
        ...Object.keys(siblingA.fields),
        ...Object.keys(siblingB.fields)
    ]);

    for (const field of fields) {
        const a = siblingA.fields[field];
        const b = siblingB.fields[field];

        if (!a) { merged[field] = b; continue; }
        if (!b) { merged[field] = a; continue; }

        const relation = compareVectors(a.version, b.version);

        if (relation === "a-after-b")      merged[field] = a;
        else if (relation === "b-after-a") merged[field] = b;
        else if (relation === "equal")     merged[field] = a;
        else {
            unresolved.push({ field, candidates: [a, b] });
            merged[field] = a;
        }
    }

    return { merged, unresolved };
}

Semantic Merge

The strongest approach applies domain knowledge. What two concurrent changes should produce together is a business question, and only the application can answer it.

const MERGE_POLICY = {
    "cart.items":        { rule: "union",        onTie: "merge-quantities" },
    "post.tags":         { rule: "union",        onTie: "deduplicate" },
    "order.status":      { rule: "precedence",   order: ["delivered", "shipped", "packed", "cancelled", "confirmed", "created"] },
    "account.entries":   { rule: "append-all",   onTie: "deduplicate-by-id" },
    "permissions.roles": { rule: "safest-wins",  bias: "restrictive" },
    "document.title":    { rule: "preserve-both", onTie: "require-user-choice" }
};

function semanticMerge(path, candidates) {
    const policy = MERGE_POLICY[path];

    if (!policy) {
        return {
            resolved: false,
            reason: `no merge policy declared for ${path}`,
            siblings: candidates
        };
    }

    switch (policy.rule) {
        case "union":
            return { resolved: true, value: unionValues(candidates) };

        case "precedence":
            return {
                resolved: true,
                value: candidates
                    .slice()
                    .sort((a, b) =>
                        policy.order.indexOf(a.value) -
                        policy.order.indexOf(b.value)
                    )[0].value
            };

        case "safest-wins":
            return { resolved: true, value: mostRestrictive(candidates) };

        case "append-all":
            return { resolved: true, value: dedupeById(candidates) };

        default:
            return { resolved: false, siblings: candidates };
    }
}

Conflict-Free Replicated Data Types

CRDTs sidestep resolution entirely by constraining data to shapes whose merge function is mathematically guaranteed to converge, regardless of order or repetition.

Common CRDT Shapes

class PNCounter {
    constructor(nodeId) {
        this.nodeId = nodeId;
        this.increments = {};
        this.decrements = {};
    }

    increment(amount = 1) {
        this.increments[this.nodeId] =
            (this.increments[this.nodeId] ?? 0) + amount;
    }

    decrement(amount = 1) {
        this.decrements[this.nodeId] =
            (this.decrements[this.nodeId] ?? 0) + amount;
    }

    value() {
        const sum = obj =>
            Object.values(obj).reduce((a, b) => a + b, 0);

        return sum(this.increments) - sum(this.decrements);
    }

    merge(other) {
        for (const side of ["increments", "decrements"]) {
            for (const [node, count] of Object.entries(other[side])) {
                this[side][node] = Math.max(
                    this[side][node] ?? 0,
                    count
                );
            }
        }
    }
}

Deletion and Tombstones

Deletion is the hardest case in any convergent system, because the absence of data is indistinguishable from never having received it.

{
    "setId": "cart:user-4821",
    "elements": [
        { "value": "sku-501", "addedBy": "replica-east", "tag": "e-14" },
        { "value": "sku-733", "addedBy": "replica-west", "tag": "w-09" }
    ],
    "tombstones": [
        {
            "value": "sku-910",
            "removedTags": ["e-11"],
            "removedAt": "2026-09-24T05:42:18Z",
            "expiresAt": "2026-10-24T05:42:18Z"
        }
    ]
}

Preserving Siblings

Where no automatic rule is defensible, the honest approach is to return both versions and let the application or user decide.

async function readWithConflictHandling(key, resolver) {
    const result = await datastore.read(key);

    if (result.siblings.length === 1) {
        return { value: result.siblings[0].value, conflicted: false };
    }

    metrics.increment("conflict.detected", {
        key: key,
        siblingCount: result.siblings.length
    });

    const resolution = resolver(result.siblings);

    if (!resolution.resolved) {
        return {
            conflicted: true,
            siblings: result.siblings,
            requiresUserChoice: true
        };
    }

    await datastore.write(key, resolution.value, {
        context: result.causalContext
    });

    return { value: resolution.value, conflicted: true, autoResolved: true };
}

Avoiding Conflicts Entirely

The most effective strategy is arranging for conflicts not to arise. Several design choices achieve this.

Choosing a Strategy

A Worked Example

Monitoring

Testing Merge Logic

describe("merge function properties", function () {
    it("is commutative", function () {
        const a = makeReplicaState("A");
        const b = makeReplicaState("B");

        expect(merge(a, b)).toEqual(merge(b, a));
    });

    it("is associative", function () {
        const [a, b, c] = ["A", "B", "C"].map(makeReplicaState);

        expect(merge(merge(a, b), c))
            .toEqual(merge(a, merge(b, c)));
    });

    it("is idempotent", function () {
        const a = makeReplicaState("A");

        expect(merge(a, a)).toEqual(a);
    });

    it("does not resurrect deleted elements", function () {
        const a = addThenRemove("sku-910");
        const b = stillContaining("sku-910");

        expect(merge(a, b).elements)
            .not.toContain("sku-910");
    });
});

Common Design Mistakes

System Design Interview Discussion

Design Checklist

Knowledge Check

Summary

Conflicts arise when writes are made independently with no causal relationship between them. Neither is wrong, so resolution is a question about what two intentions should mean together, which is a domain decision rather than a storage one.

Last-writer-wins is the default in many systems and guarantees data loss. It discards a valid write silently, and clock skew can mean the discarded one was actually newer. It is acceptable only where the value is a disposable snapshot.

Field-level merge reduces conflicts by narrowing granularity. Semantic merge applies domain rules and produces the best outcomes where the correct answer is definable. CRDTs guarantee convergence mathematically for data fitting supported shapes, but cannot enforce invariants spanning replicas.

Deletion requires tombstones, whose retention must exceed maximum replica lag to prevent resurrection. Most importantly, many conflicts are created by the data model itself: expressing changes as deltas and events rather than as absolute final state removes them before any resolution is required.