Hands-On: System Design for Intermediate Engineers

Transitioning a system from a single instance to a distributed architecture introduces a massive amount of complexity, and getting the design wrong early on leads to cascading performance and reliability issues. This course breaks down how to architect and scale real-world systems, built up step-by-step through practical diagrams. You will start with the transition to stateless services and horizontal scaling, learning how to manage a shared session store, spread instances across Availability Zones, and autoscale workers based on queue depth. Once you have multiple instances, we cover how to manage traffic using layered load balancing, rate limiting at the edge, and bulkheads to isolate service pools. From there, the course tackles the data tier. You will see how to scale reads using database replication, manage replica lag, and implement a read/write splitting tier. When a single database hits its ceiling, we explore partitioning and sharding by key, including how to route requests, avoid hot partitions, and combine sharding with replication.

To further reduce database load and absorb traffic spikes, you will explore multi-layer caching, combining local, shared, and edge caches while preventing cache stampedes. Operating a scaled system requires deep visibility, so we cover the three pillars of observability: centralized logging, metrics, and distributed tracing, including tracing across an asynchronous boundary. You will learn how to tie these metrics to health checks at the load balancer, track SLOs, and build alerting for production services. Finally, the course moves into advanced asynchronous scaling patterns. You will design systems using CQRS to separate read and write models, implement the Outbox pattern for reliable event publishing, and handle failures using idempotent consumers and a dead letter queue.