SYSTEM DESIGN SIMULATOR
Practice with 106 browser-based HLD, distributed-systems, database-internals, and DSA simulators. Watch queues, caches, Raft, B-trees, and algorithms run instead of memorizing static diagrams.
27 curated architectures (URL shortener, WhatsApp, YouTube, Google Drive, payment system, stock exchange) with step-by-step walkthroughs, component swap, and in-browser stress simulator.
Explore all 27 →32 working implementations of the algorithms that power modern systems: B-tree, LSM, Raft, CRDTs, isolation levels, plus DNS, TLS, HTTP/3, XSS and CSRF walkthroughs.
Explore all 32 →47 animated algorithm widgets across 11 groups — trees, graphs, DP, greedy, backtracking, bit tricks. Each widget ships with real Java code and LeetCode links.
Explore all 47 →System Design Simulator is an interactive, browser-based study platform for engineers who want to actually see distributed systems work, not just read about them. Every topic on the site is built as a live widget: diagrams animate, requests flow through queues and caches, replicas fail over, and you can swap components to watch the trade-offs change in real time. No PDFs, no slides, no passive watching.
The site exists because the current canon of system-design prep — books, blog posts, whiteboard videos — does a great job explaining concepts but a poor job showing them in motion. When a real interviewer asks what happens if the primary dies mid-write, most candidates have read the answer but never watched it unfold. This simulator closes that gap.
It is built for three audiences: engineers preparing for FAANG and top-tier system-design interviews, teachers and mentors who want moving visuals for a concept they are explaining, and self-learners who prefer experimentation to textbooks. Content is organized around three pillars — HLD Designs, System Internals, and DSA — and every widget ships with authored prose, real Java code, complexity analysis, pitfalls, and trade-offs so the explanation keeps up with the animation.
Start with focused walkthroughs for common long-tail searches: URL shortener system design, WhatsApp system design, distributed rate limiter design, news feed system design, Google Drive system design, and Raft consensus explained. Each page links onward to related designs, internals, and DSA topics so you can move from one interview question to the surrounding concepts.
Reading about a quorum write is not the same as watching one fail. A book can tell you that LSM-trees amplify writes; a simulator lets you push a million keys through one and count the compaction passes. The goal of this site is to replace abstract descriptions with concrete, reproducible behavior you can poke at.
There are great books, courses, and cheat sheets out there. Here is how System Design Simulator fits in — the goal is not to replace the canon but to give you a practice lab where you can watch the canonical concepts run.
| Resource | Interactive? | HLD Designs | Internals | DSA | Free? |
|---|---|---|---|---|---|
| System Design Simulator you are here | Fully interactive | 27 walkthroughs | 32 simulators | 47 visualizations | 100% free |
| Alex Xu — System Design Interview | Static diagrams | 26 designs | Limited | None | Paid book |
| DDIA (Kleppmann) | Text only | None | Deep coverage | None | Paid book |
| Database Internals (Petrov) | Text only | None | Deep coverage | None | Paid book |
| Educative System Design | Text + static | 20+ designs | Some | Some | Paid subscription |
| Neetcode / LeetCode | Code only | Limited | None | Strong | Freemium |
| System Design Primer (GitHub) | Text + images | 20+ concepts | Good | Limited | Free |
Best workflow: read Alex Xu's books and DDIA for theory, then come here to watch the concepts run. Use this as your practice lab, not your only reference.
Not sure where to begin? Pick the entry point that fits your timeline and learning style.
It is a free, browser-based learning site that turns system-design and data-structures topics into interactive simulations. Instead of diagrams on a page, every topic is an animated widget you can poke at: swap a component, run a stress test, step through a failure. It currently covers 27 high-level designs (URL shortener, WhatsApp, YouTube, payment systems, and more), 32 systems-internals topics (B-Tree, LSM, Raft, quorum, CRDTs, TLS, HTTP/3), and 47 DSA patterns with Java code. The goal is to make the invisible parts of distributed systems — replication, consensus, compaction, failover — concretely visible.
Books are linear and static; this site is non-linear and interactive. A book tells you leader election takes a few round trips — the simulator shows you the actual messages, the split-brain scenario, and what happens when two nodes both think they are leader. You still get the prose explanation on every page, drawn from the same canon engineers already trust, but the animation and the stress-test mode turn passive reading into a lab. It is meant to complement books like DDIA and Alex Xu, not replace them — you read the theory, then come here to watch it run.
Yes — the curriculum is explicitly built around the designs and follow-up questions that Google, Meta, Amazon, Netflix, and similar companies ask. Every HLD widget covers the classic interview script: clarifying questions, capacity estimation, API design, data model, high-level architecture, scaling bottlenecks, and trade-offs. The Internals track prepares you for the deep-dive probes senior interviewers use to separate candidates — "walk me through a write under read-committed," "what happens when a Raft leader is partitioned" — and the DSA track covers the coding rounds. It is a single integrated prep loop.
Yes. The DSA track ships with 47 interactive widgets covering the patterns that actually appear in coding interviews: two pointers, sliding window, binary search variants, monotonic stacks, KMP, LRU, AVL and red-black trees, union-find, topological sort, Dijkstra, Bellman-Ford, Floyd-Warshall, classic DP (LIS, LCS, edit distance, knapsack, matrix chain), backtracking (N-Queens, Sudoku, word search), and more. Every widget has an animated walkthrough, real Java code, time and space complexity, common pitfalls, and a link to the canonical LeetCode problems so you can practice immediately after watching the pattern execute.
No. The application is a pre-rendered SPA built with React and Vite, code-split into per-widget and
per-design chunks, and served from Vercel's edge CDN. All interactive widgets — the B-tree simulator,
Raft consensus, Dijkstra's algorithm, the stress tester — execute entirely client-side as
JavaScript modules; there is no application server, no database, and no API round-trip in the request
path. Widget state lives in localStorage only (for persisting your selected tab and design);
nothing is sent over the network after the initial page load. The site has no sign-up, no email capture,
and no third-party trackers. Open the home page, click any widget, and it continues
to work offline after the first load thanks to the browser's HTTP cache.
Yes — 100% free, with no paywalls, no premium tier, no "unlock the full curriculum" upsell. Every widget, every walkthrough, every LeetCode link, and every code sample is open to everyone. There are no ads on the page and no tracking beyond basic, privacy-respecting analytics. The project is a personal contribution to the engineering community, not a product, so the business model is simply: keep it free, keep it good, keep it growing. If you find it useful, share it with a teammate prepping for interviews — that is the only "payment" asked.
The curriculum is deliberately grounded in the engineering canon rather than invented from scratch. The HLD track draws heavily on Alex Xu's System Design Interview Volumes 1 & 2 for the classic designs and the interview-script structure. The Internals track draws on Martin Kleppmann's Designing Data-Intensive Applications (DDIA) for replication, consistency, and stream processing, and on Alex Petrov's Database Internals for storage engines, B-Trees, LSM-Trees, and transaction mechanics. Networking and scaling patterns lean on the community-maintained System Design Primer. Reading these books alongside the simulator is the intended workflow.
Yes — contributions, bug reports, and topic suggestions are genuinely welcome. The project source is mirrored on GitHub at github.com/RahulKumarNitP/HLDSimulator, where you can open an issue for a broken animation, a typo in a walkthrough, a missing edge case, or a topic you would like to see covered next. For direct messages, questions that do not fit an issue, or private feedback, use the contact page. The privacy and terms pages cover the usual legal basics.
Rahul Kumar — Senior Software Engineer
Backend & Distributed Systems
I build backend infrastructure for data-intensive systems — distributed services, event pipelines, the storage layer underneath. Java, Python, and C++ are my daily languages; Kafka, Redis, PostgreSQL, Cassandra, Docker, Kubernetes, and AWS show up often. I built System Design Simulator as the study tool I wish existed when I was preparing for interviews at top-tier companies. Shipping it publicly because the process of building each widget taught me more than any textbook.
Mentorship: I am open to providing mentorship on system design, distributed systems, and interview preparation. If you are looking for guidance, reach out on LinkedIn or email rahul.nitpatna.cse@gmail.com with a short note on what you are working on and what kind of help would be most useful.
GitHub · LinkedIn · Email · Contact page