This repository is for my personal learning and interview preparation. It teaches system design from basics to advanced production architecture and big-tech interview readiness.
It is a structured study workspace that starts with first principles, then moves into practical architecture topics, end-to-end case studies, low-level design, quizzes, templates, and timed mock interviews.
Use it as a study path, a review reference, and a place to practice explaining tradeoffs clearly.
This repository is for learners who want to build system design fundamentals, engineers preparing for technical interviews, and experienced developers who want a concise architecture reference. It assumes basic programming experience, but it explains system design concepts from the ground up.
Use the repository as an active study workspace rather than a folder of notes.
| Goal | Best starting point | How to practice |
|---|---|---|
| Learn from scratch | Fundamentals | Read in order, draw each request path, and complete the mini exercises. |
| Build depth | Distributed Systems | Connect each mechanism to consistency, failure, observability, and cost. |
| Prepare for interviews | Interview Guide | Use templates, timed mocks, and case-study rewrites. |
| Review quickly | Cheatsheets | Convert each rule into one interview-ready sentence. |
| Navigate everything | Repository Index | Use the generated index to jump by folder. |
- Purpose
- Who This Is For
- How to Use This Repository
- Start Here
- Beginner Path
- Deep Study Path
- Interview Preparation Path
- Case Study Path
- Mock Interview Path
- Mermaid Roadmap
- Folder Navigation
- Recommended Reading Order
- Root Reference Files
- Progress Checklist
- Quality Promise
- Repository Checks
- Read What Is System Design.
- Open the Roadmap for the full topic order.
- Use Study Plan if you want a weekly schedule.
- Use each folder
README.mdas a local table of contents. - Practice with case studies and mock interviews after you finish the core topics.
Follow this path if you are new to system design:
Focus on intuition, examples, and common mistakes before memorizing patterns.
Use this path when you want stronger production architecture judgment:
- Distributed Systems
- Messaging and Streaming
- Storage Systems
- Architecture Patterns
- Reliability
- Observability
- Security
- Performance
- Cloud Infrastructure
- AI System Design
For each topic, connect the mechanism to a user-visible requirement, a failure mode, and a metric.
Use this path when interviews are approaching:
- Read Interview Guide.
- Work through interview preparation notes.
- Review cheatsheets.
- Fill in templates by hand.
- Redo weak quizzes from quizzes.
- Practice explaining tradeoffs out loud.
Use case studies after you understand fundamentals, databases, caching, scalability, and high-level design. For each case study:
- Read only the problem statement first.
- Spend 35 to 45 minutes designing without looking at the solution.
- Compare your answer with the file.
- Rewrite the weakest section: requirements, estimates, APIs, data model, architecture, reliability, security, observability, or tradeoffs.
- Repeat the same case one week later.
Use mock interviews when you can already design the common systems slowly. For each mock:
- Set a 45-minute timer.
- Clarify requirements before drawing.
- Estimate only numbers that change the design.
- Explain read paths, write paths, and failure paths.
- Close with tradeoffs and the first bottleneck.
- Score yourself with the rubric.
flowchart LR
Start[Start Here] --> Fundamentals[Fundamentals]
Fundamentals --> Networking[Networking]
Networking --> APIs[API Design]
APIs --> Databases[Databases]
Databases --> Caching[Caching]
Caching --> Scalability[Scalability]
Scalability --> Distributed[Distributed Systems]
Distributed --> Messaging[Messaging and Streaming]
Messaging --> Storage[Storage Systems]
Storage --> Patterns[Architecture Patterns]
Patterns --> Reliability[Reliability]
Reliability --> Observability[Observability]
Observability --> Security[Security]
Security --> Performance[Performance]
Performance --> Cloud[Cloud Infrastructure]
Cloud --> HLD[High-Level Design]
HLD --> LLD[Low-Level Design]
LLD --> AI[AI System Design]
AI --> Cases[Case Studies]
Cases --> Mocks[Mock Interviews]
| Folder | What It Covers | Best Use |
|---|---|---|
| fundamentals | Core vocabulary, workflows, state, latency, scale, and interview mindset | First pass study |
| networking | Internet basics, HTTP, TLS, WebSockets, gRPC, proxies, and CDNs | Understand request flow |
| api-design | REST, GraphQL, gRPC, pagination, idempotency, rate limits, and auth | Design service contracts |
| databases | SQL, NoSQL, indexes, transactions, sharding, replication, and storage models | Choose data stores |
| caching | Client, CDN, app, database, distributed cache, invalidation, and eviction | Reduce latency and load |
| scalability | Load balancing, horizontal scaling, autoscaling, backpressure, and hot partitions | Grow systems safely |
| distributed-systems | Consensus, replication, partitions, transactions, clocks, locks, and discovery | Reason about coordination |
| messaging-streaming | Queues, pub-sub, streams, consumer groups, delivery semantics, and dead letters | Decouple work |
| storage-systems | Object, file, block, blob, content-addressed, video, and log storage | Match storage to workload |
| architecture-patterns | Monoliths, microservices, serverless, CQRS, event sourcing, and migration patterns | Compare architecture shapes |
| reliability | SLOs, fault tolerance, retries, redundancy, degradation, recovery, and incidents | Design for failure |
| observability | Logging, metrics, tracing, alerting, dashboards, and debugging | Operate systems |
| security | Authentication, authorization, OAuth, JWT, encryption, secrets, DDoS, and tenancy | Protect systems |
| performance | Latency budgets, profiling, throughput, database performance, network performance, and tests | Improve speed |
| cloud-infrastructure | Compute, containers, Kubernetes, load balancers, managed databases, IaC, and cost | Deploy systems |
| high-level-design | Requirements, estimates, APIs, data modeling, components, scaling, failure, and cost | Structure HLD interviews |
| low-level-design | OOD, SOLID, patterns, diagrams, domain modeling, concurrency, and examples | Structure LLD interviews |
| ai-system-design | Inference, feature stores, training, RAG, vector search, agents, evaluation, and observability | Design AI-backed systems |
| case-studies | End-to-end product and infrastructure designs | Practice complete designs |
| interview-prep | Interview frameworks, estimation, drawing, tradeoffs, follow-ups, and senior signals | Prepare answers |
| mocks | Timed interview prompts with rubrics | Practice performance |
| quizzes | Topic quizzes with explanations | Check recall and reasoning |
| cheatsheets | Compact review sheets | Review before interviews |
| templates | Reusable design templates | Practice structured answers |
| diagrams | Diagram guidance and examples | Improve visual explanations |
| tools | Repository maintenance scripts | Validate links, index, and quality |
Use this order when you want the cleanest learning path:
- Fundamentals
- Networking
- API Design
- Databases
- Caching
- Scalability
- Distributed Systems
- Messaging and Streaming
- Storage Systems
- Architecture Patterns
- Reliability
- Observability
- Security
- Performance
- Cloud Infrastructure
- High-Level Design
- Low-Level Design
- AI System Design
- Case Studies
- Mock Interviews
- Read the root README and roadmap.
- Finish fundamentals.
- Finish networking and API design.
- Finish databases and caching.
- Finish scalability and distributed systems.
- Finish reliability, observability, security, and performance.
- Finish high-level design and low-level design.
- Complete at least 10 case studies.
- Complete at least 5 mock interviews.
- Review cheatsheets and glossary before interviews.
- For each completed case, write the first bottleneck, accepted tradeoff, and alert that would catch user pain.
- Redo weak quizzes as scenarios, not only as multiple-choice recall.
Every important learning file should help with both understanding and interview performance. A strong pass through a topic should answer these questions:
- What user workflow or invariant does this concept protect?
- What is the source of truth, and what data is derived or cacheable?
- What changes at 10x traffic, 10x data, or a regional failure?
- What can be stale, duplicated, delayed, denied, or safely degraded?
- What metric, alert, trace, or audit event proves the design is healthy?
- What tradeoff was accepted, and what signal would make you revisit it?
For case studies and mocks, do not stop at a diagram. Cover requirements, estimates, APIs, data model, architecture, caching, scaling, reliability, observability, security, bottlenecks, tradeoffs, and follow-up questions.
Run these commands after changing content:
python tools/fix_markdown_formatting.py
python tools/generate_repo_index.py
python tools/check_links.py
python tools/check_markdown_quality.py⬅ Previous | 🏠 Home | ➡ Next