Advanced System Design Interview Questions

Two-phase commit coordinates an atomic commit across systems, but it blocks if the coordinator fails, and it scales poorly. A saga is a sequence of local transactions, with compensating steps. It scales better, but the data is only eventually consistent.

To avoid a database write succeeding while an event publish fails, you write the event to an outbox table in the same transaction. A separate process then publishes it, reading the table or using change data capture.

Reading a database's change log, and streaming the changes to other systems, such as search or caches. Debezium is a common tool.

Nodes elect a leader by majority vote. The leader replicates a log, and an entry is committed once a majority stores it. A majority always overlaps, so committed data survives a minority of failures.

Require a majority (quorum) to act as leader, and use fencing tokens, so that an old leader's writes are rejected.

UUIDs need no coordination, but are long and random, which suits indexes less well. Snowflake-style IDs combine time, machine ID and a sequence, in 64 bits, and they sort by time. Newer UUIDv7 values are also time-ordered.

Machines' clocks drift, so timestamps cannot reliably order events. Use logical clocks or sequence numbers, or specialised time services, such as Spanner's TrueTime.

Decide between active-passive (simpler, with failover) and active-active (lower latency, but conflicts). Partition users by home region, replicate asynchronously, and plan for data residency laws.

Cache it locally, replicate it, or split it into several keys and sum them, as with a counter. Add a random suffix for writes, to spread the load.

Aggregate in a stream with periodic flushes. For approximate counts of unique items, use HyperLogLog, and for frequency counts, use a Count-Min Sketch.

A small structure that says an item is possibly present, or definitely absent. It avoids unnecessary disk reads and cache-penetration lookups, with a few false positives but no false negatives.

B-trees update pages in place, and they are good for reads. LSM trees buffer writes in memory, and flush sorted files, which suits heavy writes, but reads and compaction cost more. RocksDB and Cassandra use them.

Write to both old and new (dual writes), backfill old data, compare, then move reads gradually, and finally stop writing to the old one. Keep a rollback path.

Use expand and contract. Add the new column, deploy code that handles both, backfill, switch reads, and remove the old column later.

A way for a slow consumer to signal producers to slow down, through bounded queues, rejected work or flow control, rather than failing from overload.

Deliberately rejecting some work when overloaded, starting with the least important, so that the system keeps serving the rest.

Use exponential backoff with jitter, retry budgets, circuit breakers, and retry only at one layer.

Use load tests, game days, and chaos engineering, which injects failures in a controlled way, along with regular failover and restore tests.

Use canary or blue-green releases, feature flags, automatic rollback on bad metrics, and backward-compatible changes.

Find the largest drivers, usually storage, network traffic and compute. Use caching, compression, cold storage and autoscaling, and estimate the cost per user.