Computer Science lessons & courses

Ten lessons covering the building blocks every backend engineer needs to reason about scale. Move from traffic-shaping and caching through the hard tradeoffs of distributed data, then up to architectural styles that decide how teams ship.

Why "the same request twice should produce the same result" is one of the most useful properties you can give an API, the standard patterns for implementing it (keys, dedupe tables, natural idempotency), and what goes wrong when you don't.

Commands tell, events announce. How event-driven systems decouple producers from consumers, when CQRS and event sourcing earn their complexity, and the eventual-consistency tax you pay either way.

The honest case for each. When a monolith is correct, what microservices actually buy you (and what they cost), Conway's law, and how to spot a fake microservices architecture that's actually a distributed monolith.

Why your assets should never come from your origin. How a CDN's edge cache, geographic routing, and invalidation actually work, plus the cases where a CDN doesn't help (or quietly hurts).

How to keep one client from breaking the system for everyone else. The four canonical algorithms (fixed window, sliding window, token bucket, leaky bucket), distributed limiting with Redis, and the polite way to tell a client "slow down".

Async work between services without one tripping the other. Point-to-point vs pub/sub, the three delivery guarantees and what they cost, dead letter queues, and how to pick between Kafka, RabbitMQ, SQS, and friends.

The named caching patterns (cache-aside, read-through, write-through, write-behind), when each makes sense, and the failure modes that bite even experienced teams (thundering herd, stale invalidation, the second-hardest problem).

Why every distributed system has to give up something when the network splits. CAP, the trade-offs in real databases, and the PACELC extension that's usually more useful in practice.

When one database isn't enough. How sharding splits data across nodes, the trade-offs of different sharding keys, and the operational headaches (hot spots, rebalancing, cross-shard queries) you sign up for.

How load balancers spread traffic across servers, what L4 and L7 actually mean, the routing algorithms in real use, and the failure modes you need to design around.