System design interview mind map: requirements to trade-offs
The short answer
How do I build a mind map for system design interview prep?
Follow the order of the interview: requirements, estimates, API, data model, high-level components, deep dives, then bottlenecks and failures. In each node's note record the choice, the alternatives you rejected and why, the failure mode and the numbers that justify it.
Researched and drafted by an AI agent that works for Mappy. The technical content is standard textbook material and the arithmetic is shown so you can check it. Mappy does not generate or grade system designs.
Map the interview flow, not a list of technologies
Most system design study material is a pile of technologies: caches, queues, load balancers, databases. A pile is hard to use under pressure, because the hard part of the interview is not recalling that a cache exists. It is deciding where one belongs, what it costs and what happens when it fails.
So put the shape of the conversation in the map. Make the central node the question "Design X" and give it one branch per stage: Requirements, Estimates, API, Data model, High-level components, Deep dives, Bottlenecks and failures, and a short Mobile branch. In Mappy, Tab adds a child and Enter adds a sibling, so the skeleton takes a minute. This guide covers the design process; for algorithm questions see the coding interview patterns guide.
Requirements: functional, non-functional and out of scope
Give the Requirements branch three children. Functional: what the system does, in a few verbs (create a short link, redirect, optionally view click counts). Non-functional: availability, latency targets, durability, consistency needs, scale, and cost limits. Out of scope: what you chose not to build, stated aloud so the interviewer can correct you.
Write the non-functional items as testable sentences with a number or a word that can be argued with, such as "redirects should feel instant" or "a lost link is worse than a slow one". Every later choice should point back to one of these lines. If you cannot say which requirement a component serves, either the requirement is missing or the component is not needed.
Worked estimate: a URL shortener
Estimates are for choosing between designs, not for precision. Below, every input is an assumption that you would confirm or replace in a real conversation.
- Assumption: 100 million new short URLs per month.
- Assumption: 100 reads (redirects) for every write.
- Assumption: each record (short key, long URL, timestamps, owner) is about 500 bytes.
- Assumption: records are kept for 5 years.
- Assumption: peak traffic is 3 times the average.
Now the arithmetic, using a 30-day month of 2,592,000 seconds:
- Writes per second: 100,000,000 / 2,592,000 is about 38.6, so roughly 39 writes/s.
- Reads per second: 38.6 × 100 is about 3,858 reads/s.
- Peak reads: 3,858 × 3 is about 11,574 reads/s.
- Records over 5 years: 100,000,000 × 12 × 5 = 6,000,000,000 (6 billion).
- Storage: 6,000,000,000 × 500 bytes = 3,000,000,000,000 bytes, about 3 TB.
- Key length: a 7-character key over 62 characters (a-z, A-Z, 0-9) gives 627 = 3,521,614,606,208, about 3.5 trillion keys, far more than 6 billion, so 7 characters is enough.
- Cache size, if the hottest 20% of a day's reads are cached: 3,858 × 86,400 is about 333 million reads/day; 20% of that is about 66.7 million records × 500 bytes is about 33 GB, which fits in memory on a few machines.
What the numbers say: about 39 writes/s is trivial for one database, 3 TB fits on modest storage, and the read side is where a cache earns its place. Write that conclusion in the node, not only the numbers. Then change one assumption (1,000 reads per write, or 10 times the volume) and see which conclusion flips. That is the skill being tested.
API sketch and data model
Keep the API branch small: one node per operation with method, path, key parameters, response and error cases. For the shortener: POST /links with a long URL and an optional expiry, returning the short key; GET /{key} returning a redirect. Note the choices that need a "why": a 301 redirect can be cached by browsers (fewer hits, but you lose click counts and cannot reliably redirect those browsers to a new target), while a 302 is not cached the same way. Also note idempotency: what happens if a client retries a create after a timeout?
For the data model, list entities, their keys and the access patterns they must serve. "Look up a link by key" is a point read, which suits a key-value store or an indexed table. Write the access pattern first and the storage choice second, then add a note on what you give up, for example ad hoc queries or multi-row transactions.
High-level components and the node template
Under High-level components, add one child per box in your diagram: clients, load balancer, application servers, cache, database, and any queue or background worker. Open each node into a full note (every node in Mappy can expand into a note with headings, lists, checklists and code blocks) and paste the component template below. The fields that matter most are the ones people skip:
- Alternatives rejected, and why. A choice with no named alternative is a habit, not a decision.
- Failure mode. Say what breaks and what the user sees, for example "if the cache is down, reads fall through to the database, which must survive the extra load or shed it".
- Numbers. Point to the estimate node (or draw a connection to it) rather than retyping it, and state the point at which the choice stops working.
Deep dives: record the trade-off, not the definition
Give each deep-dive topic a node with the same three lines: what it buys, what it costs, when you would choose otherwise.
- Caching. Buys lower latency and less database load. Costs staleness and invalidation complexity. Decide the pattern (read-through, write-through, write-behind), the eviction policy and the time-to-live, and note the risk of many requests hitting the database at once when a popular entry expires.
- Partitioning (sharding). Buys capacity beyond one machine. Costs cross-partition queries and rebalancing. Hash partitioning spreads load evenly but makes range scans hard; range partitioning keeps ranges together but can create hot spots. Name the partition key and what a hot key would do.
- Replication. Buys availability and read capacity. Costs replica lag, so a read right after a write may be stale unless you read from the primary. Note what happens when the primary fails.
- Queues. Buy decoupling and smoothing of bursts, and let slow work happen in the background. Cost extra latency and the need to handle duplicates: most queues deliver at least once, so consumers should be idempotent.
- Rate limiting. Protects the system from abuse and overload. Decide what to limit (user, key, IP), the algorithm (token bucket or sliding window are common), where it runs, and what the client gets back (typically HTTP 429).
- Consistency. Under a network partition a system must choose between staying consistent and staying available (the CAP trade-off). PACELC adds that even without a partition there is a trade-off between latency and consistency. Write which promise each piece of data needs: a bank balance and a like count do not need the same one.
Bottlenecks and failure modes
End with a branch that revisits the diagram and asks, for each box, "what if this is slow, full or gone?" Children worth having: single points of failure, hot keys or hot partitions, retry storms (clients retrying in lockstep against an overloaded service, usually softened by backoff with jitter), slow dependencies and timeouts, data loss and backups, and what you would monitor (latency percentiles, error rate, queue depth, replica lag). Because you filled in the failure-mode field for every component, this branch is mostly pointers back to those notes.
A short mobile system design branch
Mobile questions change the constraints: the client is unreliable, battery and data are limited, and you cannot update every device at once. Add a Mobile branch with these children, each with the same trade-off note:
- Offline and sync. Decide what is stored locally, how local changes are queued, and how conflicts are resolved (last write wins is simple but loses edits; merging is harder). Say what the user sees while offline.
- Pagination. Cursor-based pages stay stable when new items arrive; offset pages can skip or repeat items. Note the page size and how the list behaves at the end.
- Image caching. A memory cache for speed and a disk cache for persistence, with size limits and eviction, plus requesting an image size that matches the screen.
- Battery and network. Batch requests, avoid constant polling, back off on failure, and compress payloads. Consider push notifications instead of polling.
- API versioning. Old app versions stay in use, so changes to the API must stay compatible.
Practice loop and getting started
Pick one system, build the full map, then close the notes and redraw the design from the canvas alone while saying each trade-off aloud. Afterwards, check what you skipped. In Mappy, Cmd+Shift+F focuses one branch, which is handy for rehearsing a single deep dive, and F1 shows the shortcuts. PDF export can include the map's notes, so print or share the finished map that way. For writing code snippets or API examples in notes, see the programming notes guide, and for data structure fundamentals, the data structures map.
Building and saving your own maps needs Mappy's one-time Full Unlock. The free download shows a guided tour and an editor preview, but it does not create or save maps, so use the template below on paper or in any notes app if you are only trying the method.
System design component node template
Use this outline in any notes editor, or recreate its branches in Mappy. It is a plain-text worksheet, not an automatically importable .mindmap file. No signup is needed for the template.
Download the text template (.txt)
COMPONENT NODE
Component (cache, queue, database, ...):
Purpose in one sentence:
Requirements it serves (functional / non-functional):
Choice made:
Why this choice (the trade-off you accept):
Alternatives rejected, and why each lost:
1.
2.
Failure mode (what breaks, what the user sees):
How we detect it and recover:
Consistency promise (what a reader may see, and how stale):
Numbers (with assumptions labeled):
Load it must handle:
Size of data it holds:
Capacity at which this choice stops working:
Question to answer without notes:Researched and drafted by an AI agent that works for Mappy. The worked estimate in this guide uses assumptions that are labeled as assumptions, and the arithmetic was calculated step by step. How these guides are written.