Quick reference

System Design

How to shape systems that stay fast and available as they grow.

Difficulty: advancedTime: 15+ hours105 of 107 sections written

System design is the practice of translating a requirement into an architecture — the components involved, how they communicate, where data lives, and how the whole thing keeps working when something fails.

Sections

107 sections
  1. System Design Fundamentalsbeginner20 min
  2. Functional vs Non-Functional Requirementsbeginner20 min
  3. Requirements Clarificationbeginner20 min
  4. Capacity Estimationbeginner20 min
  5. Back-of-the-Envelope Mathintermediate18 min
  6. Latency and Throughputintermediate22 min
  7. Availability, Reliability and Durabilityintermediate20 min
  8. SLIs, SLOs, SLAs and Error Budgetsintermediate16 min
  9. Basic Architecture Patternsintermediate28 min
  10. Monolith vs Modular Monolith vs Microservicesintermediate24 min
  11. Client-Server and API Gatewaysintermediate18 min
  12. Load Balancingintermediate20 min
  13. Horizontal vs Vertical Scalingintermediate18 min
  14. Stateless Architectureintermediate18 min
  15. Database Fundamentals for System Designintermediate18 min
  16. Data Modelingintermediate18 min
  17. Isolation Levels and Concurrencyintermediate20 min
  18. Replicationintermediate18 min
  19. Sharding and Partitioningadvanced20 min
  20. Caching Fundamentalsintermediate22 min
  21. Redis and Distributed Cachingadvanced22 min
  22. CDN and Edge Cachingintermediate20 min
  23. Messaging and Queuesintermediate22 min
  24. Kafka and Log-Based Messagingadvanced24 min
  25. RabbitMQ and Traditional Message Brokersintermediate20 min
  26. Delivery Semantics and Idempotencyintermediate20 min
  27. Retry Strategyintermediate18 min
  28. Timeouts and Resource Limitsintermediate20 min
  29. Circuit Breakers and Bulkheadsintermediate22 min
  30. Eventual Consistencyintermediate20 min
  31. Distributed Transactionsadvanced22 min
  32. Saga Patternadvanced22 min
  33. Transactional Outbox and Inboxintermediate15 min
  34. Distributed Locksadvanced16 min
  35. Consistent Hashingintermediate15 min
  36. Consistency Modelsadvanced20 min
  37. CAP Theoremintermediate15 min
  38. PACELCintermediate15 min
  39. Leader Election and Coordinationintermediate15 min
  40. Consensusintermediate12 min
  41. Object Storageintermediate18 min
  42. Search Systemsintermediate15 min
  43. Rate Limitingintermediate20 min
  44. Quotas and Fairnessintermediate18 min
  45. Real-Time Systemsintermediate20 min
  46. WebSockets at Scaleintermediate20 min
  47. Batch and Stream Processingintermediate20 min
  48. Backpressureintermediate16 min
  49. File and Large Data Processingintermediate16 min
  50. API Designintermediate26 min
  51. API Gateway and BFFintermediate18 min
  52. API Idempotencyintermediate12 min
  53. Authentication and Authorizationintermediate22 min
  54. Security Architectureintermediate18 min
  55. Encryptionintermediate20 min
  56. Multi-Tenancyintermediate18 min
  57. Observabilityintermediate16 min
  58. Monitoring and Alertingintermediate18 min
  59. SRE and Operational Thinkingintermediate16 min
  60. Disaster Recoveryintermediate15 min
  61. High Availabilityintermediate18 min
  62. Multi-Region Systemsadvanced18 min
  63. Autoscalingintermediate14 min
  64. Container and Kubernetes Conceptsintermediate6 min
  65. Cloud Architectureintermediate16 min
  66. Cost-Aware Designintermediate15 min
  67. Data Lifecycle and Retentionintermediate12 min
  68. Privacy and Compliance Architectureintermediate12 min
  69. Dependency Managementintermediate12 min
  70. Failure Mode Analysisintermediate12 min
  71. Cascading Failuresintermediate12 min
  72. Graceful Degradationintermediate12 min
  73. Load Sheddingintermediate12 min
  74. Rate of Change and Schema Evolutionintermediate16 min
  75. Event Ordering and Duplicate Handlingintermediate14 min
  76. Distributed Time and Clocksintermediate14 min
  77. Data Consistency in User Workflowsintermediate13 min
  78. Payment System Designadvanced20 min
  79. Notification System Designintermediate14 min
  80. URL Shortener Designintermediate12 min
  81. Social Feed Designadvanced18 min
  82. Chat System Designadvanced15 min
  83. File Storage System Designadvanced14 min
  84. Search System Designadvanced18 min
  85. Rate Limiter Designintermediate16 min
  86. Job Scheduling System Designadvanced15 min
  87. Unique ID Generationintermediate15 min
  88. Feed and Timeline Storageadvanced14 min
  89. Ticketing / Reservation Systemsadvanced14 min
  90. Distributed Countersintermediate15 min
  91. Analytics Systemsadvanced15 min
  92. Data Warehouse vs Operational Databaseintermediate17 min
  93. Search vs Databaseintermediate18 min
  94. System Design Interview Processintermediate14 min
  95. High-Level Design vs Low-Level Designintermediate16 min
  96. High-Level Design Checklistintermediate12 min
  97. Low-Level Design Checklistintermediate13 min
  98. Trade-Off Analysisintermediate18 min
  99. Common System Design Anti-Patternsintermediate14 min
  100. System Design Review Checklistintermediate14 min
  101. Practical Projectsadvanced55 min
  102. What a 5-Year Engineer Should Be Able to Explainadvanced16 min
  103. Priority Roadmapintermediate22 min
  104. Recommended Learning Orderbeginner13 min
  105. Final Senior-Level Standardadvanced24 min
  106. Data Modeling4 items
  107. Transactions and ACID1 item

Why it matters

  • Every non-trivial feature eventually needs a design decision, not just code — and those decisions are expensive to reverse once built.
  • Interviews at the senior level test this directly: estimating scale, choosing storage, and reasoning about failure, not writing algorithms.
  • A design that ignores failure modes works in a demo and falls over the first time a dependency is slow or unavailable.
  • The vocabulary here — latency, throughput, availability, consistency — is what makes a design conversation precise instead of hand-wavy.

Where it is used

  • Architecture and design reviews before a feature is built
  • System design interviews for mid-to-senior engineering roles
  • Incident retrospectives, tracing a failure back to a design gap
  • Capacity planning ahead of a launch or a traffic spike

The big picture

The path from requirement to a running system
sized byshapesmust surviveruns as

Requirements

functional + non-functional

Capacity

estimate the scale

Architecture

components, APIs, data model

Failure handling

what breaks, and then what

Operations

scaling, cost, observability

  • Requirements — functional + non-functional
    • leads to Capacity (sized by)
  • Capacity — estimate the scale
    • leads to Architecture (shapes)
  • Architecture — components, APIs, data model
    • leads to Failure handling (must survive)
  • Failure handling — what breaks, and then what
    • leads to Operations (runs as)
  • Operations — scaling, cost, observability