System Design

What system design actually asks of you, and how to approach learning it.

Hash maps, queues, heaps, B-trees, and tries — and where each one shows up in infrastructure.

The protocol stack, TCP versus UDP, and what HTTP actually does over the wire.

How a hostname becomes an IP address, and how DNS becomes a routing tool.

The three-way handshake, connection teardown, and why round trips dominate latency.

Resource design, methods, status codes, idempotency, and API versioning.

The three performance measures, the numbers worth memorizing, and how queues behave under load.

Isolation versus sharing, concurrency models, and the hazards of shared state.

How the OS shares the processor, and what switching between tasks actually costs.

Why I/O dominates server behaviour, and the models for handling it without wasting threads.

Address translation, page faults, swapping, and why memory pressure kills latency.

Disks, durability, storage types, and the write path that databases depend on.

Relational versus NoSQL, SQL and joins, indexes, transactions, and how to choose.

Vertical versus horizontal scaling, statelessness, and the layers you scale in order.

L4 versus L7, distribution algorithms, health checks, and failover.

Distributing keys across nodes so that adding or removing one moves as little data as possible.

Why caching works, where caches live, and the failure modes that come with them.

Redis versus Memcached, eviction policies, and read and write strategies.

Splitting data across machines, choosing a shard key, and handling hot spots and rebalancing.

Leader-follower, multi-leader, and leaderless models, plus replication lag and failover.

The real meaning of CAP, PACELC, and the spectrum from eventual to strong consistency.

Kafka versus RabbitMQ, synchronous versus asynchronous communication, and when to decouple.

Fan-out messaging, at-least-once versus exactly-once, ordering, and dead letter queues.

How to move from a vague prompt to a defensible architecture in a structured way.

Token bucket, leaky bucket, window counters, and enforcing limits in a distributed system.

Circuit breakers, retries, timeouts, bulkheads, health checks, and heartbeats.

Consensus, distributed locks, split brain, and coordinating work across a cluster.

Separating reads from writes, storing events as truth, and the trade-offs of both.

Key generation, redirect latency, and the read-heavy workload that defines this system.

Fan-out on write versus read, the celebrity problem, and timeline construction.

Short video upload, transcoding pipelines, feed ranking, and CDN delivery.

Long-form video storage, streaming, search, recommendations, and cost at scale.

Catalog, inventory, cart, checkout, payments, and the consistency boundaries between them.

Location updates, geospatial indexing, matching, and real-time trip state.

Consolidating the patterns, the bottlenecks that repeat, and how to keep the knowledge sharp.