Once a first-pass design has a request path and a primary store, interviews and production systems ask what happens to copies, placement, and failure.

This course introduces advanced system design through those follow-ups: how data is replicated, how keys are placed, how consistency is visible to clients, how a stateful primary fails over, and where large files live. It is designed for engineers who can already draw a 101 design and need the vocabulary for senior and staff questions.

You will learn how to choose a copy topology, explain what a partition costs, reason about isolation and transactions, and separate “this request’s health” from “this primary is dead”—without reteaching caches, load balancers, or API contracts.

Optional sections then cover the mechanisms that specific senior follow-ups reach for: how to reject lookups for keys that don’t exist without a database read, how nodes agree, how a workflow across services recovers from a half-finished failure, how a lock stays safe when its holder stalls, how a write-heavy store lays data on disk, and how search and “nearby” queries are indexed at scale.

What You Will Learn

• Database replication: copy topologies, lag, and failover as a data-role change
• Consistent hashing and remap cost
• CAP theorem and what a partition forces you to choose
• Consistency models and what a client can actually observe
• Database sharding and partitioning
• Availability and failover patterns for stateful primaries
• Transactions and isolation
• Object and blob storage
• Bloom filters (optional)
• Consensus algorithms and agreement (optional)
• Distributed transactions: 2PC, outbox, and sagas (optional)
• Distributed locking (optional)
• Storage engines: B+tree vs LSM-tree (optional)
• Search indexing at scale (optional)
• Geospatial indexing (optional)

How This Course Works

Rather than memorizing cluster diagrams, the course focuses on why copies, placement, and failover exist—and what they cost.

For each topic, we start from a 101-shaped system that already works at modest scale, show where a single primary or a single key space breaks, and add the mechanism that answers that follow-up. Health checks and load-balancer ejection stay in 101; this course owns dead primaries, lag, and split-brain.

By the end of the course, you should be able to take a first-pass design and systematically answer the distribution and failure questions that come next, while clearly explaining trade-offs. Full product prompts such as Design Twitter remain classic system-design interviews, not this course.

Who This Course Is For

This course is suitable for software engineers who can already assemble a 101 request path and want to move from placing the first boxes to reasoning about copies, partitions, and failover.

You should be comfortable with APIs, a primary store, caches, and load balancers. Those topics live in System Design 101 and are not taught again here.