User opens the app. Show the nearest 10 coffee shops. Sounds simple until you realize ’nearest’ means computing distance against millions of locations in under 100ms.

Manhattan has 50,000 restaurants. Rural Wyoming has 3 per county. A fixed-size grid wastes cells on empty space and overloads dense areas. Quadtrees adapt.

Your user is at latitude 37.7749, longitude -122.4194. Your database has 10 million locations. A full table scan comparing every coordinate pair isn’t going to work.

You split work evenly across 4 threads. Two finish in 10ms, two take 10 seconds. Half your CPU sits idle while the other half grinds. Work stealing fixes this.

Send a reminder in 24 hours. Retry this job in 5 minutes. Expire this hold at midnight. Delayed execution is everywhere, and Thread.sleep isn’t the answer.

Three nodes, one job. Without leader election, all three run it simultaneously. With leader election, exactly one does the work while the others stand by.

Your dataset is 10TB. One machine can’t hold it, let alone process it. MapReduce splits the work across hundreds of machines with a deceptively simple API.

A batch job runs for three hours and crashes at hour two. Without checkpointing, you restart from zero. With it, you lose ten minutes of work.

FIFO queues treat every message equally. But urgent config updates shouldn’t wait behind a thousand bulk sync jobs. Priority queues fix this, if you handle starvation.

Your database says one thing. The external system says another. Reconciliation is how you find the drift before your users do.

Boolean flags and status strings create impossible states. An explicit state machine tells you exactly where a workflow is, what transitions are valid, and how to recover.

Two-phase commit guarantees atomicity across multiple databases. It also blocks everything if the coordinator dies. Here’s why microservices moved on.

Every public write endpoint is an abuse vector. Layered defense with validation, rate limiting, and async scanning keeps your system safe without killing performance.

100% availability is impossible and pursuing it wastes engineering time. SLOs turn reliability into a number you can reason about.

A 64-bit integer is 19 digits. Encode it in base62 and it’s 7 characters. The math behind compact, URL-safe identifiers.

Auto-increment IDs break the moment you have more than one database. Snowflake IDs, UUIDs, and database sequences each solve this differently.

Showing every individual event overwhelms users. Grouping related events into summaries is a distributed systems problem hiding as a UX problem.

A follows table with two columns seems trivial. Until you need to query it from both directions, across shards, for millions of users.

Showing content in time order is simple until your users follow thousands of sources. Scoring and ranking turns a firehose into a useful stream.

Routing file uploads through your API server is a scaling bottleneck. Pre-signed URLs let clients upload directly to object storage.

Green dot means online. Simple, right? Behind that dot is a distributed system making heartbeat-based guesses about user liveness.

User posts an update. Do you push it to all followers immediately, or let them pull it when they check? The trade-off shapes your entire architecture.

Your client needs real-time updates from the server. HTTP wasn’t built for this. Here’s how long polling, SSE, and WebSockets solve it differently.

ALTER TABLE on a 2M row table locks it for minutes. Your users see errors. Here’s how expand-contract and shadow writes let you migrate without downtime.

Why one cache isn’t enough. How to layer local, distributed, and CDN caches for maximum performance without losing your mind on consistency.

There are only two hard things in computer science: cache invalidation and naming things. Here’s why invalidation is so tricky, and what actually works.

The four fundamental caching patterns every engineer should know. When to use cache-aside vs write-through vs write-behind vs read-through.

How distributed systems spread information without a central coordinator. The surprisingly effective technique of random peer-to-peer chatter.

How distributed systems agree on state. A practical look at Raft’s Leader Election and Log Replication, finally making sense of consensus.

Why the CAP Theorem is the most misunderstood rule in system design. Addressing the ‘Pick 2’ lie and how it sets the stage for consensus algorithms.