All Designs
— topicsHow Kafka reimagines the message queue as a distributed, append-only log — covering topics, partitions, consumer groups, and delivery guarantees at scale.
Work through the decisions an engineer faces when building Kafka from scratch — log segments, partition leadership, consumer group coordination, and replication trade-offs.
Understanding how traces span service boundaries — exploring span propagation, context passing, sampling strategies, and the observability tools that make distributed debugging tractable.
Design a distributed tracing system from the ground up — span propagation, context injection, sampling decisions, and the storage layer that makes traces queryable at scale.
When ACID breaks across service boundaries — comparing two-phase commit, sagas, and eventual consistency patterns for building correct systems without coordination overhead.
Step through four real-world consistency patterns side-by-side — Two-Phase Commit, Saga, Transactional Outbox, and Idempotency with Reconciliation — with animated walkthroughs and failure scenarios.
A build session — design a distributed transaction coordinator from scratch before seeing the reference. Each segment asks you to draw, decide, or write pseudocode covering requirements, coordination protocols, and failure recovery.
Why choosing a load balancing strategy starts with understanding your traffic shape — comparing Round Robin, Least Connections, IP Hash, and Weighted strategies against real-world constraints.
Walk through designing a production load balancer — from health checking and connection tracking to weighted routing and the session-stickiness trade-offs operators actually face.
Follow a single HTTP request hop by hop — from DNS resolution through TLS handshake, load balancer, backend, and back — with one sharp question at each checkpoint.
How to pick the right NoSQL store for your access patterns — comparing document, key-value, wide-column, and graph models against CAP theorem constraints and real system requirements.
Design a NoSQL store from first principles — choosing the right storage engine, partition strategy, consistency model, and compaction approach for your target workload.
Internals of SQL engines — covering B-tree indexes, WAL-based durability, MVCC for concurrency control, and the query planner decisions that separate fast queries from slow ones.
Design a SQL engine from scratch — parsing queries into plans, choosing index access paths, managing transactions with MVCC, and handling crash recovery through write-ahead logging.