Learn System Design in 30 Days

Start with the words every system design conversation uses: latency, throughput, bandwidth, availability, and the difference between them. Get these right and the rest of the month is easier.

Follow one request from a browser to a server and back: DNS, TCP and TLS handshakes, HTTP, and where the time goes. This is the mental model you reuse forever.

Why one server is never enough, and how a load balancer spreads traffic. Round robin, least connections, health checks, and Layer 4 versus Layer 7.

Forward proxies, reverse proxies, and the API gateway. What sits in front of your servers and why it matters for TLS, caching, and security.

The single highest-leverage performance tool. What to cache, where to cache it, and the cost of a stale read. Client, CDN, and server caches.

Cache-aside, read-through, write-through, write-back, and how LRU and LFU decide what to throw away. Cache stampede and how to avoid it.

Tables, indexes, transactions, and ACID. How a B-tree index turns a slow scan into an instant lookup, and what an index costs you on writes.

Relational, document, key-value, wide-column, and graph stores. When each one fits, and why the answer is almost never just one of them.

Primary and replica, synchronous versus asynchronous, and replication lag. How you read your own writes without lying to the user.

Splitting data across machines, choosing a shard key, consistent hashing, and the pain of rebalancing and hot partitions.

Strong, eventual, causal, and read-your-writes consistency. The CAP and PACELC trade-offs, explained with real outages instead of theory.

REST, gRPC, GraphQL, and when to use each. Versioning, idempotency, pagination, and designing an API you will not regret in a year.

Queues versus pub/sub, Kafka versus RabbitMQ, delivery guarantees, and why asynchronous processing is the backbone of scale.

A lighter day on purpose. Re-read anything that did not click, and sketch a simple design end to end using only what you have learned so far.

Monolith versus services, service boundaries, inter-service communication, the saga pattern, and the operational cost nobody warns you about.

Regions, availability zones, compute and storage primitives, and the building blocks AWS, GCP, and Azure all share under different names.

Why containers won, what Kubernetes actually does, pods, services, and the scheduling and self-healing that make orchestration worth it.

CDNs, edge caching, how Netflix puts servers inside your ISP, and the difference between static and dynamic content delivery.

Pipelines, blue-green and canary deployments, feature flags, and infrastructure as code. Shipping safely and often.

Authentication versus authorization, OAuth and JWT, encryption in transit and at rest, and the threats you design against from day one.

PII, GDPR, data retention, auditing, and the constraints that quietly shape real architectures in regulated industries.

The hard problems: clocks and ordering, consensus, quorums, and why agreement across machines is so much harder than it looks.

Raft and Paxos at the level an interview needs, leader election, and how systems like etcd and ZooKeeper keep everyone in agreement.

Batch versus stream, windowing, exactly-once processing, and the lambda and kappa architectures for handling data at scale.

Availability in nines, circuit breakers, bulkheads, retries with backoff, and graceful degradation. Designing for failure as the normal case.

Active-passive versus active-active, RPO and RTO, backups that actually restore, and chaos engineering the Netflix way.

Metrics, logs, and traces, the difference between monitoring and observability, SLOs and error budgets, and alerting without fatigue.

Threat modeling, penetration testing, incident response, and keeping a running system secure rather than just shipping it secure.

Put it together. Work through a full design like a URL shortener, a news feed, or a chat system, from requirements and back-of-the-envelope math to the final architecture.

Do a timed design out loud, then review it against the rubric. Practice the structure: clarify, estimate, design, justify trade-offs, and handle scale.