Modern System Design

This series is a simple, ordered path through system design — from the first building blocks to how modern products and AI systems are put together.

Layers

1. Layer 1 — The building blocks

2. What Actually Makes a System "Distributed"?

3. Requests, Responses and Latency

4. Horizontal vs Vertical Scaling

5. Load Balancers

6. Reverse Proxies

7. API Gateways

8. DNS

9. CDNs

10. Caching

11. Redis

12. Databases

13. SQL vs NoSQL

14. Database Indexes

15. Replication

16. Sharding

17. Fallacies of Distributed Computing

18. Little's Law

19. Amdahl's Law

20. Consistent Hashing

21. Cache Stampede

22. Hot Keys and Hot Partitions

23. Layer 2 — Communication

24. REST APIs

25. gRPC

26. Synchronous vs Asynchronous Communication

27. Message Queues

28. Kafka

29. Pub/Sub

30. Event-Driven Architecture

31. WebSockets

32. Server-Sent Events

33. Webhooks

34. Delivery Guarantees

35. Poison Messages

36. Head-of-Line Blocking

37. Backends for Frontends

38. Layer 3 — Reliability

39. Timeouts

40. Retries

41. Exponential Backoff

42. Idempotency

43. Circuit Breakers

44. Bulkheads

45. Rate Limiting

46. Backpressure

47. Replication

48. Failover

49. Leader Election

50. Quorum

51. CAP Theorem

52. Consistency Models

53. Two Generals Problem

54. Byzantine Generals Problem

55. FLP Impossibility

56. PACELC

57. Split-Brain

58. Consensus: Paxos and Raft

59. Fencing Tokens and Leases

60. Layer 4 — Data

61. ACID

62. Transactions

63. Isolation Levels

64. Optimistic vs Pessimistic Locking

65. Eventual Consistency

66. Distributed Transactions

67. Two-Phase Commit

68. Sagas

69. CQRS

70. Event Sourcing

71. Change Data Capture

72. BASE

73. Transactional Outbox

74. Dual Writes

75. CRDTs

76. Logical Clocks

77. Bloom Filters

78. Layer 5 — Modern infrastructure

79. Containers

80. Kubernetes

81. Service Discovery

82. Service Meshes

83. Distributed Tracing

84. Observability

85. Configuration Management

86. Secrets Management

87. Autoscaling

88. Multi-region Architecture

89. Active-Active vs Active-Passive

90. Disaster Recovery

91. Sidecar Pattern

92. Cell-Based Architecture

93. SLOs, SLIs, and Error Budgets

94. Layer 6 — Modern systems

95. Designing a Notification System

96. Designing a Real-Time Chat System

97. Designing a Search System

98. Designing a Recommendation System

99. Designing a Feature Flag System

100. Designing a Distributed Scheduler

101. Designing a Payment System

102. Designing a Metrics Pipeline

103. Designing a Log Aggregation System

104. Designing a File Storage System

105. What Is an LLM Inference Server?

106. Streaming LLM Responses

107. Token Streaming

108. LLM Request Queues

109. GPU Scheduling

110. Model Routing

111. AI Rate Limiting

112. Semantic Caching

113. Vector Databases

114. RAG Architecture

115. Building an AI Agent

116. Agent Memory

117. Tool Calling

118. Multi-Agent Systems

119. AI Observability

120. LLM Cost Management

121. Layer 7 — Patterns and problems

122. The End-to-End Argument

123. Conway's Law

124. Strangler Fig

125. Tail at Scale

126. Gossip Protocol