Practice Scenarios Generator

The Interview Simulator

Click the button below to generate a random System Design problem. But wait—real life isn’t that simple. Once you have your problem, click “Reveal Constraints” to see the hidden requirements that would trip you up in a real interview.

?

</div>

Deep Dive Strategic Roadmap
Pivoting from High-Level Design to Technical Depth
THE HLD MAP
🌎
SCALE PATH
• Sharding Strategy
• Geo-Replication
• Hotspot Mitigation
🛡️
RELIABILITY PATH
• Consensus (Raft)
• Failover Modes
• Correctness checks
🚀
PERFORMANCE PATH
• Zero-GC logic
• Ring Buffers
• Custom Protocols
STAFF SIGNAL:
Justify trade-offs between these paths using constraints.
Data Vol.
Data Integrity
Low Latency

Whiteboard Management

Designing a system is 50% technical and 50% presentation. A messy whiteboard suggests a messy mind.

The 4-Quadrant Layout

Divide your whiteboard (or Excalidraw canvas) into 4 clear zones. This helps you and the interviewer keep track of the discussion.

1. Requirements & Math
• Functional Reqs
• Non-Functional
• QPS / Storage Calc
2. Architecture Diagram
• Client -> LB -> App -> DB
• The "Big Picture"
• Data Flow Arrows
3. Data Models / API
• POST /tweet
• JSON Objects
• Table Schemas
4. Deep Dives
• Sharding Logic
• Caching Strategy
• Algorithms
Zone Content Purpose
1. Requirements North Star Keep QPS and Core Features visible so you don’t lose focus.
2. Architecture The Map The main visual (represented as “The HLD Map” in our roadmap).
3. Data/API The Contract Define how data moves.
4. Deep Dives Strategic Path Use this to branch into the Scale, Reliability, or Performance paths shown in our roadmap.

[!TIP] Don’t Erase History. Instead of erasing your High-Level Design to draw the Deep Dive, try to keep the HLD visible and draw a “Zoom In” box for the detailed component in Zone 4.

Sample Whiteboard Layouts

Here are two examples of how to organize your whiteboard for common system design problems. Notice how the 4-quadrant structure keeps the information dense but readable.

Example 1: Design Twitter (News Feed)

1. Reqs & Math
DAU: 100M
QPS: 500M tweets/day (~6k WPS)
Read:Write = 100:1

Func:
- Post Tweet
- View Feed
- Follow User
2. High Level Design
Client -> LB -> API Gateway
|
v
[Fanout Service]
/ \
[Redis] [DB Cluster]
3. Data Model / API
POST /tweet { text, media_id }
GET /feed?cursor=...

Table: Users (PK: id)
Table: Tweets (PK: id, FK: user_id)
Table: Follows (from, to)
4. Deep Dives
- Fan-out on Write (Push)
vs Fan-out on Read (Pull)
- Hybrid for Celebrities
- Cache Eviction (LRU)
- Sharding: UserID vs TweetID

Example 2: Design a URL Shortener

1. Reqs & Math
Users: 100M/month
Write: 100M URLs/mo
Read:Write = 100:1
Storage: 100M * 120mo * 500B
~ 6TB Total

Func: Shorten, Redirect (301)
2. High Level Design
Client
|
[LB]
|
[Shortener Svc] -- [KGS]
|
[NoSQL DB]
3. Data Model / API
POST /api/v1/shorten
-> { short_url: "xyz" }
GET /xyz -> 301 Redirect

Table: Mapping
PK: hash (7 chars)
Val: long_url, created_at
4. Deep Dives
- Collision Handling (Base62)
- KGS (Key Generation Service)
to pre-generate tokens
- 301 vs 302 Redirect
- Analytics (Kafka stream)

The First Principles Approach

What happens when you get a question you’ve never seen before?

  • “Design a system to count the number of cigarettes smoked in Paris in real-time.”
  • “Design a control system for a nuclear reactor.”

Don’t panic. Fall back on First Principles.

  1. Inputs & Outputs: Where does data come from (Sensors? Users?) and where does it go (Dashboard? Alert?).
  2. Volume & Velocity: Is it a firehose (1M events/sec) or a drip (1 event/hour)?
    • High Velocity -> Branch into the Performance Path (Zero-GC, Ring Buffers).
    • High Volume -> Branch into the Scale Path (Sharding, Geo-Replication).
    • Low Velocity -> REST API and SQL DB.
  3. Storage: Do we need to keep it forever?
    • Yes -> S3 / Data Lake.
    • No -> Redis (TTL).
  4. Bottlenecks: Where will it break?
    • DB is slow -> Add Cache.
    • Server is slow -> Add Load Balancer.
    • Network is slow -> Add CDN.

Useful References

Interactive Architecture Board

Practice your High-Level Design by dragging and dropping components onto the canvas. Draw lines to connect them.

Drag to move. Shift+Drag to connect. Double click to delete.