Open-ended design rounds broken into the building blocks they draw on, plus full case studies worked end to end with explicit trade-off reasoning.
17 published across 12 topics.
System design fundamentals60 short answers on one page, for revising rather than studying.Requirements gathering, capacity estimation, and structuring the first ten minutes of a design round.
Spend roughly three minutes agreeing the functional scope, three pinning the numbers that change the architecture, and four turning those numbers into a derived estimate of request rate, storage and bandwidth — then state which design decision each number forces.
Horizontal versus vertical scaling, load-balancer strategies, and stateless service design.
Scale up while one machine can still hold the workload, because it costs no distributed complexity; scale out once you need redundancy or exceed the largest instance. Scaling out only works if the tier is stateless, which means externalising session state rather than pinning users to a node.
Cache placement, eviction, invalidation, and the stampede and coherence failure modes.
Pick a write policy that matches your consistency requirement rather than treating invalidation as an afterthought, then defend against the three failure modes that only appear under load: stampede on expiry, staleness from lost invalidation messages, and unbounded growth from missing eviction.
Choose the layer by who else can reuse the same bytes and how tolerable staleness is that far from the user, then size it from the working set rather than the dataset. Watch the miss rate, not the hit rate: origin load is proportional to misses, so 99 percent falling to 95 is a fivefold traffic increase.
Choosing a store, sharding and partitioning, replication topologies, and storage-engine trade-offs.
Choose the store from the dominant access pattern and the invariants it must enforce, not from a category label. Choose the shard key so the most frequent query is answerable from one shard, the key has enough distinct high-traffic values to spread load, and shards can be split later without rewriting every row.
Put the equality predicates first in a composite index and the ordering column last, so one index serves the filter, the sort and the limit. Every index is a write tax, and whether that tax is a random in-place page update or a sequential append is the difference between a B-tree engine and an LSM engine.
CAP and PACELC in practice, consistency models, consensus, and what you give up under partition.
The write committed on the primary and the reload was served by a replica that had not applied it yet. Fixing it means giving that session a read-your-writes guarantee, either by routing its reads to the primary for a bounded window or by carrying the commit position and refusing to read a replica behind it.
Under partition you either reject requests on the side that cannot reach a quorum, or serve them and accept divergent replicas that need reconciling. CAP's C is linearisability, not ACID's C, and the choice binds only while partitioned.
Queues versus logs, delivery guarantees, ordering, backpressure, and exactly-once claims.
A queue distributes work and forgets each message once acknowledged; a log is a retained, partitioned, replayable record that many consumers read independently at their own offsets.
Resource modelling, pagination, idempotency, versioning, and backward compatibility.
Model resources around client workflows, paginate with an opaque keyset cursor because offset pagination skips and duplicates rows under concurrent writes, make unsafe operations replayable with a client-supplied idempotency key, and evolve additively so that versioning stays a last resort rather than a routine.
Accept the request, return 202 with the location of an operation resource, and do the work behind a queue. Clients poll that resource or receive a signed callback, and either way the operation id is the contract - one that a callback can reach before the submitter has finished recording it.
Throttling algorithms, circuit breakers, retries with jitter, bulkheads, and graceful degradation.
Fixed windows permit twice the limit across a boundary; the two sliding windows fix that at a memory or an accuracy cost; token bucket permits a bounded burst and leaky bucket smooths output instead. Across a fleet the counter must sit in one store mutated atomically, or each node silently enforces its own limit.
Inverted indexes, relevance scoring, and the ingestion-to-query pipeline of a search product.
An inverted index maps terms to posting lists, built by an analysis chain that must run identically over documents and queries, ranked by BM25 plus business signals, and fed by a change stream of denormalised documents with reindexing behind an alias treated as routine.
Metrics, logs, traces, cardinality control, and designing systems that can be debugged live.
Metrics tell you something is wrong and when it started, traces tell you which hop owns the latency, logs tell you what happened to one request. Cardinality is what makes metrics expensive, sampling is what makes traces affordable, and the goal is answering new questions from data already held.
Tenant isolation, secrets management, defence in depth, and threat modelling a distributed system.
Isolation runs from a tenant_id column through separate schemas and databases to a stack per tenant, trading efficiency against blast radius. Careful filtering is not an isolation model: push the predicate below the application with row-level security and scope caches and object prefixes too.
Complete designs worked end to end: URL shortener, news feed, chat, ride-hailing, and more.
Size it first: 200M daily actives opening the feed six times a day is 42k reads/s at peak, while 100M posts fanned out to 200 followers each is 231k feed writes/s, so writes dominate. Push to ordinary accounts, pull for high-follower ones, and store ids so deletes and blocks filter on read.
Clarify scale first, then size it: 100M new links a day at a 100:1 read ratio gives roughly 1.2k writes/s and 116k redirects/s, needing 7-character base62 keys. Generate keys from leased counter blocks scrambled by a bijection, serve reads from cache and CDN, and redirect with 302 rather than 301.