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.
A compact 26-point revision guide covering ACID, two-phase commit, sagas, eventual consistency, and compensation patterns — built for fast pre-interview review.
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.
A deep design review covering when 2PC is justified, why saga is a product decision as much as a technical one, and how compensation differs from rollback — built around real mutual fund and settlement flows.
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.
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.
A deep dive into SQL indexes — how B-tree and hash indexes work under the hood, when to use composite vs. covering indexes, and the trade-offs that determine query performance.
Core principle: don't add architecture because it is fashionable. Add it because a measurable bottleneck or reliability requirement demands it. 67 progressive notes from scratch to scale.
Requirements are the foundation of good system design. 25 notes on translating vague problems into functional and non-functional requirements that constrain a real solution.
Capacity estimation answers one fundamental question: how big does this system need to be? Covers throughput, storage, and bandwidth estimation — the numbers that drive every architecture decision.
How and why systems move from stateful to stateless architectures — covering session management, distributed caching, and the scalability unlocks that come with eliminating server-side state.
How to design a job scheduler that guarantees at-least-once execution across nodes — covering distributed locks, leader election, idempotency, and failure recovery patterns.
Why sequential writes are faster than random writes, how compaction trades write amplification for read performance, and the durability promise that WAL files make.
Access-pattern-first design for wide-column and document stores — partition key decisions, denormalization tradeoffs, and why schema thinking never left NoSQL.
Design an OAuth2 server from scratch — covering authorization code flow, token lifecycle, security boundaries, and failure modes that shallow implementations miss.
How to design a read-optimized social graph at scale — fan-out strategies, celebrity hot partition handling, and why ranking is a product decision as much as a technical one.
Building a durable message queue — visibility timeouts, at-least-once delivery, dead-letter queues, and why failure handling is the real design challenge.
How to design a system that detects and resolves discrepancies between data sources — covering idempotent runs, precision vs recall tradeoffs, and correctness-first architecture.
A mental model — twenty problems from the relational model down to the write-ahead log, and the one tension every layer is fighting.
Two stages, fifteen problems — design a distributed tracing system from span propagation through storage and query. Work through each problem before revealing the answer.
Design a DR system that finds failure before it finds you — active-active topology, intelligent failover, and the tie-breaker decisions that separate resilient systems from merely redundant ones.