Skip to content
System Design · DSA · Behavioural

Reason about systems
at Staff-engineer level.

A complete interactive learning environment for Senior/Staff/Lead engineering interviews. This academy teaches you to derive architectures from requirements, constraints, and failure modes — not memorize them.

Start the roadmap How to study ☕ Support this academy

Not beginner-friendly — assumes 2+ years shipping production code

interview-prep / roadmap

01 System design fundamentals + simulations

02 DSA patterns, not random LeetCode

03 Behavioural — STAR+Reflection, Staff-level

Your roadmap is ready
3Learning phases
31Priority sims + DSA vizs
40+System design exercises
LocalPrivate progress tracking

Get started

  • Start Here — Roadmap

    3-phase learning plan from "I can build an API" to "I can reason about planetary-scale systems."

  • How to Study

    Interview modes, three-level explanation model, and how to navigate the academy. Role-based routes: Learning paths.

  • Learn — System Design

    CAP, sharding, Kafka, caching, reliability, observability, Kubernetes — with visual simulations.

  • Practice — DSA Patterns

    Problem-solving patterns, not random LeetCode. Animated visualizers included.

  • Behavioural

    STAR+Reflection, seniority differentiation, Staff-level examples.

  • Design Exercises

    Guided designs from URL shortener through video calling. See project status.

  • Simulations

    15 priority simulations (hashing, Kafka, Raft, K8s, capacity, …) plus DSA visualizers on pattern pages.

  • Your Progress

    Points, streaks, badges and completion by section. Tracked locally in your browser.

  • Project Status

    Honest Complete / Interactive / Planned. Never treat a stub as finished.

What You Will Learn

Give me an unfamiliar system, its workload and constraints, and I can derive a sensible architecture, explain its trade-offs, predict how it will fail, debug it in production, and evolve it as the organization and scale grow.

This academy teaches you to derive architectures from requirements — not memorize them.

Every concept answers: WHAT? WHY? HOW? WHEN? WHAT BREAKS? WHAT ARE THE TRADE-OFFS?

Three-Level Understanding

Simple language + mental models + diagrams. Interview-ready explanations.

Algorithms, architecture, operational behaviour, bottlenecks, internal mechanics.

Scale limits, failure modes, monitoring, cost, security, debugging, real incidents.

Who This Is For

  • Senior Software / Backend / Platform / Distributed Systems Engineers
  • Staff Engineer & Tech Lead candidates
  • Senior SRE/DevOps engineers
  • Engineers targeting ₹40–70+ LPA (India) or equivalent global senior interviews
  • Engineers who already ship production code and want to reason about scale, trade-offs, and failure — not learn to write their first API

Assumes you already have:

  • 2+ years writing and shipping production code in at least one language
  • Working knowledge of core data structures & algorithms (arrays, hash maps, trees, graphs, sorting, recursion) — this is not where you learn what a hash map is
  • Comfort with basic OOP/API design, HTTP, SQL, and using a database in an application
  • Enough exposure to a real system in production to know that things fail, requests are slow sometimes, and "it works on my machine" isn't the bar

Does not assume: deep distributed-systems knowledge (CAP, consensus, sharding, replication) — that's what this academy teaches, built on top of the fundamentals above.

This is not a beginner-friendly course

There is no "what is an API" or "what is a database" page here. Concept pages open at the level of "here's the problem this solves and why it's hard," not "here's the definition." If you're early-career or interviewing for your first engineering role, you'll get more value from a general DSA/CS-fundamentals course first — come back here once you're designing (or want to design) systems that actually have to survive production traffic, failure, and scale.

Who This Is Not For

  • Engineers preparing for entry-level or new-grad interviews — the interview-question bar here starts at Senior and goes to Staff
  • Anyone looking for "definitions" or a glossary-first learning style — start with Reference → Glossary elsewhere and come back
  • Anyone who wants memorized architectures for common systems — this academy deliberately makes you derive the design instead of handing you a finished diagram to memorize

Priority Topics (Gold Standard Modules)

Module Type Status
Design methodology Concept First release
CAP Theorem Concept First release
Database Sharding Concept + sim First release
Consistent Hashing Concept + sim First release
Kafka Consumer Groups Concept + sim First release
Cache Stampede Concept + sim First release
Circuit breaker Concept + sim First release
Tail latency Concept + sim First release
Raft Concept + sim First release
URL Shortener Design First release
Rate limiter Design First release
WhatsApp Design First release
Payment Processing Design First release
Sliding Window DSA First release
BFS & DFS DSA First release
Dynamic programming DSA First release
Technical Disagreement Behavioural First release
Production Incident Behavioural First release
Debugging playbook Production First release
Kubernetes debugging Production First release

Local Development

git clone https://github.com/sanketn26/interview-prep.git
cd interview-prep
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt
mkdocs serve
# Open http://127.0.0.1:8000

Learning Philosophy

Guiding Principle

Do not teach people to memorize architectures. Teach them how to derive architectures from requirements, constraints, failure modes and trade-offs.

Every concept page follows the same structure:

  1. Why this exists
  2. Mental model
  3. Architecture (Mermaid diagram)
  4. How it works internally
  5. Realistic example
  6. Interactive explainer / simulation
  7. Failure modes
  8. Production debugging
  9. Scaling limits
  10. Trade-offs
  11. Interview questions (basic → senior → staff)
  12. Reasoning exercises
  13. Key takeaways