How does eventual consistency work and how do you handle it?

A write is acknowledged by one replica and propagated asynchronously to others. Different replicas can return different values for a period. The guarantee is convergence, not immediacy, and it says nothing about how long the window lasts.

async function updateProfile(userId, patch) {
  const next = { ...patch, version: Date.now() };
  await store.put({ pk: "USER#" + userId, ...next });
  await cache.del("user:" + userId);
  return next;
}

async function readProfile(userId, minVersion) {
  const item = await store.get({ pk: "USER#" + userId });
  if (item.version < minVersion) {
    return store.getStrong({ pk: "USER#" + userId });
  }
  return item;
}

Guarantees that make it usable

• Read-your-writes: after a write, that client sees its own change, often by routing to the leader
• Monotonic reads: a client never moves backwards to an older version
• Writes follow reads: a write is ordered after the read it depended on
• Causal consistency: operations that are causally related are seen in order by everyone

Design mutations to be idempotent, because retries and duplicate delivery are normal. Use a client-generated request id or a conditional write so replaying the same operation does not double-charge or double-append.