Protocol Explorer · System design
Designed to Scale: system design you can drive
Designed to Scale is the interactive counterpart to Protocol Explorer. Protocol Explorer shows you one exchange, byte by byte; Designed to Scale moves up a layer and shows you the system that carries thousands of those exchanges at once. Forty lessons, ten scenes each, and an instrument panel that never leaves the screen.
There is no video and no slide deck. Each scene starts from a working baseline — one service, one database, a known request rate — and then one pressure is applied. A cache is added. A shard is split. A replica appears. A timeout is shortened. The latency histogram, the throughput counter and the CPU gauge move, and you decide whether the trade was worth it.
The lab at a glance
| Lessons | 40 lessons across 9 tracks, roughly 8 hours of guided practice |
|---|---|
| Scene | 10 steps per lesson; one architectural pressure per step |
| Instruments | P50 and P99 latency, throughput in req/s, CPU utilisation, queue depth |
| Controls | Cache size and TTL, shard count, replica count, timeout budget, consumer rate |
| Runs on | Any modern browser. No install; the first three lessons need no account, buying the pass needs a one-time sign-in |
| Companion | Protocol Explorer, the 33-protocol packet visualiser |
| Reviewed | 20 November 2026 |
What a lesson asks of you
Every lesson keeps one question in view: what did this change cost? Adding a cache lowers the average read, but the first request for every key still pays the miss. Splitting a shard spreads writes, until one key becomes hot and the ceiling drops back to a single machine. A replica absorbs reads, but a stale read is now possible for as long as the replication lag lasts. Designed to Scale puts those second-order effects on the same screen as the change that caused them.
The scenes are deterministic. Replaying a step produces the same numbers, which makes comparison honest: run the baseline, run the change, and hold the two side by side instead of arguing from memory.
Four readings worth learning to read
- P50 latency. The comfortable half. It moves first when a cache warms and last when a queue backs up.
- P99 latency. The tail, where incidents live. A cold cache, a hot shard or one slow consumer shows up here before it shows up anywhere else.
- Throughput. Requests completed per second. It can rise while latency worsens, which is why a single number is never enough.
- CPU and queue depth. The leading indicators. They tell you a limit is approaching before users can feel it.
Where Designed to Scale sits beside Protocol Explorer
The two labs answer different questions about the same request. Protocol Explorer asks how a single exchange works: the DNS lookup, the handshake, the header fields, the bytes on the wire. Designed to Scale asks what happens when a million of those exchanges arrive at once and the architecture has to absorb them. Start in Protocol Explorer if you want to understand the packet; start here if you want to understand the budget it spends.
Because both labs share the same visual language — a topology in the middle, an inspector on the right, and a course tree on the left — moving between them does not require relearning an interface.
Designed for the hour before the incident review
Designed to Scale is written for engineers who already ship a service and now have to defend its shape: backend and full-stack developers, platform engineers who own a latency SLO, and anyone preparing for a system design interview where “add a cache” is the start of the conversation rather than the end of it.
It assumes you know what a request is and have looked at a metrics dashboard. It does not assume a cloud vendor, a certification or a particular framework. Every example runs in the browser, so a laptop is the whole laboratory.
Inside the course
Nine tracks, forty lessons. The first track builds the request lifecycle and the latency budget. The next tracks add scale, storage, communication, reliability, architecture and security, then shipping and whole systems. Each track ends with a lesson that replays the pressures in sequence, so the shape of the whole argument is visible at once.
Every track follows the same rhythm: baseline, one pressure, measure, then a case that breaks the tidy answer — a slow query, a distant user, a shard that carries twice the traffic.
Frequently asked questions
- What is Designed to Scale?
- The system design wing of Protocol Explorer: forty lessons, each a ten-step simulation with live latency, throughput and CPU panels.
- How is it different from Protocol Explorer?
- Protocol Explorer decodes one exchange at byte level. Designed to Scale measures the fleet-level consequences of an architecture change.
- Do I need an account or an install?
- No install and no plugin. The first three lessons run without an account; buying the $4.99 pass needs a one-time sign-in. Progress stays in local storage.
- What does the pass cost?
- $4.99 once for all 40 lessons. It is a separate pass — Protocol Explorer Pro and Exam do not include Designed to Scale.
- How long is a lesson?
- Eight to twelve minutes. Ten steps, each short enough to replay against the instrument panel.
- Which topics are covered?
- Request lifecycle, scaling, data and storage, communication, reliability, architecture, security, shipping and whole systems.
- Can I use it for interview preparation?
- Yes. The scenes are built around the trade-offs interviews probe: hit rate, shard skew, replica lag, queue depth and quorum cost.