System Design, end to end.

Follow a single request from a browser to a database and back, hop by hop.

Two numbers people constantly confuse, and the curve that connects them.

A fast system and a scalable one are different achievements, and you can have either without the other.

How a name becomes an address, and why it is the most under-appreciated availability dependency you have.

TCP, UDP, HTTP, RPC, and REST — what each one guarantees and what it costs.

Back-of-the-envelope numbers: the skill that turns a vague requirement into an architecture.

Adding replicas works right up until you reach the thing you cannot replicate.

Spreading traffic across replicas, and what happens when one of them dies.

The layer in front of your servers, and the difference between it and a load balancer.

Put a cache in front of an overloaded database, then take it away and watch what breaks.

Cache-aside, write-through, write-behind, and refresh-ahead — four answers to when the cache gets updated.

Move content close to users, and stop most requests before they reach you at all.

Deciding whose requests to refuse, so the ones you accept keep working.

Splitting a monolith into services buys independent scaling and charges you in network calls.

Connection pools, query cost, and why the database is almost always the thing that breaks.

Why a query takes 4ms or 4 seconds, and the handful of things that decide which.

Read replicas multiply your read capacity and hand you a consistency problem in exchange.

Splitting a database by function, and duplicating data on purpose — two moves before sharding.

Splitting one database into many — the last resort, and the one that changes everything.

Key-value, document, wide-column, and graph — what each is shaped for, and when SQL is still right.

What ACID actually guarantees, what your isolation level quietly does not, and what it costs.

Queues absorb bursts. They do not create capacity, and confusing the two is costly.

Every network call can fail after succeeding. Designing for that is most of distributed systems.

Failing fast on a dependency that is already down, so its outage does not become yours.

Fail-over, redundancy, and the arithmetic that turns nines into minutes of downtime.

The choice a partition forces on you, and the one you make every day when there isn't one.

Metrics, logs, and traces — what each one answers, and why averages hide your worst outages.

Turning reliability from an argument into a number that decides what you work on next.

Least privilege, defence in depth, and the handful of failures behind most real breaches.

Serving users from several regions, and the consistency bill that arrives with it.

Follow a model request from prompt assembly to the first token, then through every costly token after it.

Get machine-usable records out of a probabilistic text generator, and decide what happens when the output does not conform.

Put a gateway in front of several models, send each request to the cheapest one that can handle it, and keep serving when a provider stops answering.

Put external knowledge on the request path, then balance retrieval recall against context, latency, and cost.

Reuse answers for similar prompts while keeping false matches, stale data, and security boundaries visible.

Turn model-selected JSON into controlled side effects with schemas, validation, retries, and approval boundaries.

Bound long-running model/tool loops, persist their state, and resume safely after processes and dependencies fail.