| A Concrete Example |
04. Scaling and Bottlenecks |
| A Template for Any Design |
01. The System Design Process |
| Alerting |
20. Monitoring and Observability |
| API Gateway |
17. API Design and Gateways |
| API Versioning |
17. API Design and Gateways |
| Asynchronous Communication |
05. Proxies and Service Communication |
| At-Least-Once vs At-Most-Once vs Exactly-Once |
16. Idempotency and Exactly-Once Delivery |
| B-Tree Indexes |
10. Indexing and Denormalization |
| Backpressure |
15. Message Queues |
| Benefits of Async Processing |
15. Message Queues |
| Beyond CAP |
14. PACELC and Consensus |
| Block Storage vs File Storage |
12. Object Storage and Uploads |
| Bulkheads |
21. Designing for Failure |
| Cache Eviction |
07. Caching |
| Cache Headers |
08. Content Delivery Networks |
| Cache Invalidation |
07. Caching |
| Cache Invalidation at the Edge |
08. Content Delivery Networks |
| Cache Invalidation Strategies |
07. Caching |
| Cache Levels |
07. Caching |
| Cache Strategies |
07. Caching |
| Cache Strategies Examples |
07. Caching |
| CAP Theorem |
13. Consistency and CAP Theorem |
| CDN as DDoS Protection |
08. Content Delivery Networks |
| CDN Integration |
12. Object Storage and Uploads |
| Challenges of Sharding |
11. Database Replication and Sharding |
| Chaos Engineering |
21. Designing for Failure |
| Choosing a Discovery Pattern |
05. Proxies and Service Communication |
| Choosing Sync vs Async |
05. Proxies and Service Communication |
| Choosing the Right Approach |
18. Real-Time Communication |
| Circuit Breakers |
21. Designing for Failure |
| Clarify Requirements |
01. The System Design Process |
| Client-Side Discovery |
05. Proxies and Service Communication |
| Common Algorithms |
19. Rate Limiting |
| Common Systems |
15. Message Queues |
| Composite Indexes |
10. Indexing and Denormalization |
| Consensus Algorithms |
14. PACELC and Consensus |
| Consistency Models |
13. Consistency and CAP Theorem |
| Consistent Hashing |
11. Database Replication and Sharding |
| Consistent Hashing vs Naive Hash Mod |
11. Database Replication and Sharding |
| CP vs AP Systems |
13. Consistency and CAP Theorem |
| Data Modeling Differences |
09. Databases: SQL vs NoSQL |
| Dead Letter Queues |
15. Message Queues |
| Deduplication Strategies |
16. Idempotency and Exactly-Once Delivery |
| Deep Dive |
01. The System Design Process |
| Denormalization |
10. Indexing and Denormalization |
| Design the High-Level Architecture |
01. The System Design Process |
| Distributed Rate Limiting |
19. Rate Limiting |
| DNS |
03. Networking Fundamentals |
| DNS in System Design |
03. Networking Fundamentals |
| DNS Record Types |
03. Networking Fundamentals |
| DNS-Based Discovery |
05. Proxies and Service Communication |
| Error Budgets |
20. Monitoring and Observability |
| Estimate |
01. The System Design Process |
| Estimate Scale |
01. The System Design Process |
| Estimating Bandwidth |
02. Back-of-Envelope Estimation |
| Estimating QPS (Queries Per Second) |
02. Back-of-Envelope Estimation |
| Estimating Servers |
02. Back-of-Envelope Estimation |
| Estimating Storage |
02. Back-of-Envelope Estimation |
| Everything Fails |
21. Designing for Failure |
| Example Timeline |
21. Designing for Failure |
| Example: URL Shortener |
02. Back-of-Envelope Estimation |
| Forward Proxy vs Reverse Proxy |
05. Proxies and Service Communication |
| Graceful Degradation |
21. Designing for Failure |
| GraphQL |
17. API Design and Gateways |
| gRPC |
17. API Design and Gateways |
| Hash Indexes |
10. Indexing and Denormalization |
| Hash Ring Structure |
11. Database Replication and Sharding |
| Health Checks |
06. Load Balancers |
| High-Level Design |
01. The System Design Process |
| How CDN Caching Works |
08. Content Delivery Networks |
| How Resolution Works |
03. Networking Fundamentals |
| HTTP Versions |
03. Networking Fundamentals |
| HTTP/1.1 |
03. Networking Fundamentals |
| HTTP/2 |
03. Networking Fundamentals |
| HTTP/3 |
03. Networking Fundamentals |
| Idempotency Keys |
16. Idempotency and Exactly-Once Delivery |
| Identifying Bottlenecks |
04. Scaling and Bottlenecks |
| Incomplete Upload Cleanup |
12. Object Storage and Uploads |
| Lamport Clocks vs Vector Clocks |
13. Consistency and CAP Theorem |
| Latency Numbers That Matter |
02. Back-of-Envelope Estimation |
| Layer 4 vs Layer 7 |
06. Load Balancers |
| Leader-Follower Replication |
11. Database Replication and Sharding |
| Lifecycle Policies |
12. Object Storage and Uploads |
| Logical Clocks and Vector Clocks |
13. Consistency and CAP Theorem |
| Logs |
20. Monitoring and Observability |
| Long Polling |
18. Real-Time Communication |
| Materialized Views |
10. Indexing and Denormalization |
| Message Ordering and Delivery |
15. Message Queues |
| Metrics |
20. Monitoring and Observability |
| Monitoring tells you something is wrong |
20. Monitoring and Observability |
| Monitoring vs Observability |
20. Monitoring and Observability |
| Multi-Leader Replication |
11. Database Replication and Sharding |
| Multipart Upload Benefits |
12. Object Storage and Uploads |
| Multipart Upload Flow |
12. Object Storage and Uploads |
| Multipart Uploads |
12. Object Storage and Uploads |
| Node Addition and Removal |
11. Database Replication and Sharding |
| Non-Relational Databases (NoSQL) |
09. Databases: SQL vs NoSQL |
| Object Storage vs Block Storage vs File Storage |
12. Object Storage and Uploads |
| Observability tells you why |
20. Monitoring and Observability |
| PACELC Classifications |
14. PACELC and Consensus |
| PACELC Explained |
14. PACELC and Consensus |
| Pagination |
17. API Design and Gateways |
| Paxos |
14. PACELC and Consensus |
| Polling |
18. Real-Time Communication |
| POST Policy Conditions |
12. Object Storage and Uploads |
| POST Policy Use Cases |
12. Object Storage and Uploads |
| Practical Tradeoffs |
13. Consistency and CAP Theorem |
| Pre-Signed Download Flow |
12. Object Storage and Uploads |
| Pre-Signed POST Policies |
12. Object Storage and Uploads |
| Pre-Signed PUT URL vs POST Policy |
12. Object Storage and Uploads |
| Pre-Signed Upload Flow |
12. Object Storage and Uploads |
| Pre-Signed URLs |
12. Object Storage and Uploads |
| Private Content via CDN |
12. Object Storage and Uploads |
| PUT URL vs POST Policy Tradeoffs |
12. Object Storage and Uploads |
| Query Flexibility |
09. Databases: SQL vs NoSQL |
| Queue vs Pub/Sub |
15. Message Queues |
| Raft |
14. PACELC and Consensus |
| Rate Limit Keys |
19. Rate Limiting |
| Real-World Example: E-Commerce Checkout is Slow |
20. Monitoring and Observability |
| Real-World Examples |
16. Idempotency and Exactly-Once Delivery |
| Redundancy |
21. Designing for Failure |
| Relational Databases (SQL) |
09. Databases: SQL vs NoSQL |
| Replication |
11. Database Replication and Sharding |
| Requirements |
01. The System Design Process |
| Response Headers |
19. Rate Limiting |
| REST |
17. API Design and Gateways |
| Reverse Proxy Responsibilities |
05. Proxies and Service Communication |
| Routing Algorithms |
06. Load Balancers |
| Scaling WebSockets |
18. Real-Time Communication |
| Schema Evolution |
09. Databases: SQL vs NoSQL |
| Server-Sent Events (SSE) |
18. Real-Time Communication |
| Server-Side Discovery |
05. Proxies and Service Communication |
| Service Discovery |
05. Proxies and Service Communication |
| Service Mesh |
05. Proxies and Service Communication |
| Service-to-Service Communication |
05. Proxies and Service Communication |
| Sharding (Partitioning) |
11. Database Replication and Sharding |
| Sharding Strategies |
11. Database Replication and Sharding |
| Sidecar Pattern and Service Mesh |
05. Proxies and Service Communication |
| Signed URL Security Constraints |
12. Object Storage and Uploads |
| Single Point of Failure |
06. Load Balancers |
| SLIs, SLOs, and SLAs |
20. Monitoring and Observability |
| Stateless vs Stateful Services |
04. Scaling and Bottlenecks |
| Static vs Dynamic Content |
08. Content Delivery Networks |
| Storage Tiers and Lifecycle |
12. Object Storage and Uploads |
| Storage Type Selection |
12. Object Storage and Uploads |
| Synchronous Communication |
05. Proxies and Service Communication |
| Synchronous vs Asynchronous Replication |
11. Database Replication and Sharding |
| TCP vs UDP |
03. Networking Fundamentals |
| The Cost of Consensus |
14. PACELC and Consensus |
| The Cost of Indexes |
10. Indexing and Denormalization |
| The difference |
20. Monitoring and Observability |
| The Estimation Framework |
02. Back-of-Envelope Estimation |
| The Four Steps |
01. The System Design Process |
| The Sidecar Pattern |
05. Proxies and Service Communication |
| Three Pillars of Observability |
20. Monitoring and Observability |
| Three States |
21. Designing for Failure |
| Throughput vs Latency |
04. Scaling and Bottlenecks |
| Thundering Herd |
07. Caching |
| Timeouts and Retries |
21. Designing for Failure |
| Traces |
20. Monitoring and Observability |
| Tradeoff Analysis |
01. The System Design Process |
| Transactions |
09. Databases: SQL vs NoSQL |
| TTL and Caching |
03. Networking Fundamentals |
| Typical Config |
21. Designing for Failure |
| Vertical vs Horizontal Scaling |
04. Scaling and Bottlenecks |
| Virtual Nodes (Vnodes) |
11. Database Replication and Sharding |
| WebRTC |
18. Real-Time Communication |
| WebSockets |
18. Real-Time Communication |
| What a CDN Does |
08. Content Delivery Networks |
| What Happens When Open? |
21. Designing for Failure |
| What Load Balancers Do |
06. Load Balancers |
| What's Used Today |
03. Networking Fundamentals |
| When Each Matters in System Design |
03. Networking Fundamentals |
| When to Choose What |
09. Databases: SQL vs NoSQL |
| When to Choose Which |
03. Networking Fundamentals |
| When to Denormalize |
10. Indexing and Denormalization |
| When You Don't |
05. Proxies and Service Communication |
| When You Need It |
05. Proxies and Service Communication |
| Where to Rate Limit |
19. Rate Limiting |
| Worked Example: Design a Notification System |
01. The System Design Process |