| 0-RTT connection setup |
03. Networking Fundamentals |
| 3-way handshake |
03. Networking Fundamentals |
| 429 Too Many Requests |
19. Rate Limiting |
| ACID |
09. Databases: SQL vs NoSQL |
| Active-active |
06. Load Balancers |
| Active-passive |
06. Load Balancers |
| Amazon SQS |
15. Message Queues |
| anycast |
08. Content Delivery Networks |
| AP |
13. Consistency and CAP Theorem |
| API gateway |
17. API Design and Gateways |
| at-least-once |
01. The System Design Process, 15. Message Queues |
| At-most-once |
15. Message Queues |
| atomic check-and-set |
16. Idempotency and Exactly-Once Delivery |
| Authoritative nameserver |
03. Networking Fundamentals |
| availability zones |
21. Designing for Failure |
| AWS Fault Injection Simulator |
21. Designing for Failure |
| AWS X-Ray |
20. Monitoring and Observability |
| B-trees |
10. Indexing and Denormalization |
| BGP |
08. Content Delivery Networks |
| Block Storage |
12. Object Storage and Uploads |
| bottleneck |
04. Scaling and Bottlenecks |
| Browser cache |
07. Caching |
| buffer pool |
07. Caching |
| bulkheads |
21. Designing for Failure |
| Cache-aside |
07. Caching |
| Cache-Control |
08. Content Delivery Networks |
| caching |
01. The System Design Process |
| canary deploys |
03. Networking Fundamentals |
| CAP theorem |
13. Consistency and CAP Theorem |
| Cassandra |
09. Databases: SQL vs NoSQL |
| Causal consistency |
13. Consistency and CAP Theorem |
| CDN |
01. The System Design Process, 08. Content Delivery Networks |
| Chaos Monkey |
21. Designing for Failure |
| circuit breaker |
21. Designing for Failure |
| circuit breakers |
04. Scaling and Bottlenecks |
| Cloudflare |
08. Content Delivery Networks |
| Cloudflare Workers |
08. Content Delivery Networks |
| CloudWatch |
20. Monitoring and Observability |
| CockroachDB |
14. PACELC and Consensus |
| composite index |
10. Indexing and Denormalization |
| Congestion control |
03. Networking Fundamentals |
| Connection migration |
03. Networking Fundamentals |
| Connection registry |
18. Real-Time Communication |
| Consensus algorithms |
14. PACELC and Consensus |
| Consistent hashing |
06. Load Balancers, 11. Database Replication and Sharding |
| Constraints |
01. The System Design Process |
| Consul |
05. Proxies and Service Communication, 14. PACELC and Consensus |
| consumer groups |
15. Message Queues |
| consumers |
15. Message Queues |
| CP |
13. Consistency and CAP Theorem |
| Cursor-based pagination |
17. API Design and Gateways |
| Datadog |
20. Monitoring and Observability |
| DAU |
02. Back-of-Envelope Estimation |
| DDoS |
08. Content Delivery Networks |
| dead letter queue |
15. Message Queues |
| deduplication |
01. The System Design Process |
| Denormalization |
10. Indexing and Denormalization |
| Directory-based sharding |
11. Database Replication and Sharding |
| distributed cluster |
02. Back-of-Envelope Estimation |
| distributed systems |
05. Proxies and Service Communication |
| DNS |
03. Networking Fundamentals, 08. Content Delivery Networks |
| Document stores |
09. Databases: SQL vs NoSQL |
| dotted version vectors |
13. Consistency and CAP Theorem |
| DynamoDB |
09. Databases: SQL vs NoSQL |
| EBS |
12. Object Storage and Uploads |
| edge locations |
08. Content Delivery Networks |
| Edge-side includes |
08. Content Delivery Networks |
| EFS |
12. Object Storage and Uploads |
| Elasticsearch |
09. Databases: SQL vs NoSQL |
| ELK Stack |
20. Monitoring and Observability |
| Envoy |
05. Proxies and Service Communication |
| Error budgets |
20. Monitoring and Observability |
| ETag |
07. Caching |
| etcd |
05. Proxies and Service Communication, 14. PACELC and Consensus |
| Event streams |
05. Proxies and Service Communication |
| Event-driven invalidation |
07. Caching |
| eventual consistency |
01. The System Design Process, 13. Consistency and CAP Theorem |
| Exactly-once |
15. Message Queues |
| Exponential backoff |
21. Designing for Failure |
| failover |
11. Database Replication and Sharding |
| fan-out |
10. Indexing and Denormalization |
| FCM |
01. The System Design Process |
| FIFO |
07. Caching |
| File Storage |
12. Object Storage and Uploads |
| Fixed Window |
19. Rate Limiting |
| Flow control |
03. Networking Fundamentals |
| Followers |
11. Database Replication and Sharding |
| forward proxy |
05. Proxies and Service Communication |
| full table scan |
10. Indexing and Denormalization |
| full-duplex |
18. Real-Time Communication |
| Functional requirements |
01. The System Design Process |
| GCS |
12. Object Storage and Uploads |
| GeoDNS |
03. Networking Fundamentals |
| Global Secondary Index |
09. Databases: SQL vs NoSQL |
| golden signals |
20. Monitoring and Observability |
| Graph databases |
09. Databases: SQL vs NoSQL |
| GraphQL |
05. Proxies and Service Communication, 17. API Design and Gateways |
| Gremlin |
21. Designing for Failure |
| gRPC |
05. Proxies and Service Communication, 17. API Design and Gateways |
| HAProxy |
05. Proxies and Service Communication |
| Hash indexes |
10. Indexing and Denormalization |
| Hash-based sharding |
11. Database Replication and Sharding |
| HDD |
02. Back-of-Envelope Estimation |
| Head-of-line (HOL) blocking |
03. Networking Fundamentals |
| Header compression |
03. Networking Fundamentals |
| health check |
06. Load Balancers |
| Horizontal scaling |
04. Scaling and Bottlenecks |
| HTTP/2 |
17. API Design and Gateways |
| HTTP/REST |
05. Proxies and Service Communication |
| hybrid logical clocks |
13. Consistency and CAP Theorem |
| ICE |
18. Real-Time Communication |
| idempotency key |
16. Idempotency and Exactly-Once Delivery |
| idempotent |
01. The System Design Process, 15. Message Queues |
| idempotent operation |
16. Idempotency and Exactly-Once Delivery |
| IP Hash |
06. Load Balancers |
| Istio |
05. Proxies and Service Communication |
| Jaeger |
20. Monitoring and Observability |
| Jitter |
21. Designing for Failure |
| joins |
09. Databases: SQL vs NoSQL |
| Kafka |
01. The System Design Process, 15. Message Queues |
| Key-value stores |
09. Databases: SQL vs NoSQL |
| Kinesis |
05. Proxies and Service Communication |
| Kubernetes |
01. The System Design Process |
| Lambda@Edge |
08. Content Delivery Networks |
| Lamport clocks |
13. Consistency and CAP Theorem |
| Latency |
04. Scaling and Bottlenecks |
| Layer 4 |
06. Load Balancers |
| Layer 7 |
06. Load Balancers |
| leader |
11. Database Replication and Sharding |
| Leaky Bucket |
19. Rate Limiting |
| Least Connections |
06. Load Balancers |
| LFU |
07. Caching |
| Lifecycle policies |
12. Object Storage and Uploads |
| Linkerd |
05. Proxies and Service Communication |
| Litmus |
21. Designing for Failure |
| Load Balancer |
01. The System Design Process, 06. Load Balancers |
| Logs |
20. Monitoring and Observability |
| Loki |
20. Monitoring and Observability |
| long polling |
18. Real-Time Communication |
| LRU |
07. Caching |
| materialized view |
10. Indexing and Denormalization |
| Memcached |
07. Caching, 09. Databases: SQL vs NoSQL |
| Message queues |
05. Proxies and Service Communication |
| Metrics |
20. Monitoring and Observability |
| Microservices |
01. The System Design Process |
| MongoDB |
09. Databases: SQL vs NoSQL |
| Monitoring |
20. Monitoring and Observability |
| mTLS |
05. Proxies and Service Communication |
| Multi-leader replication |
11. Database Replication and Sharding |
| Multipart Upload |
12. Object Storage and Uploads |
| Multiplexing |
03. Networking Fundamentals |
| MySQL |
09. Databases: SQL vs NoSQL |
| Neo4j |
09. Databases: SQL vs NoSQL |
| Nginx |
05. Proxies and Service Communication, 08. Content Delivery Networks |
| Non-functional requirements |
01. The System Design Process |
| Normalization |
10. Indexing and Denormalization |
| normalize |
09. Databases: SQL vs NoSQL |
| NoSQL |
09. Databases: SQL vs NoSQL |
| object storage |
02. Back-of-Envelope Estimation, 12. Object Storage and Uploads |
| Observability |
20. Monitoring and Observability |
| offset-based pagination |
17. API Design and Gateways |
| OpenTelemetry |
20. Monitoring and Observability |
| Origin Access Control |
12. Object Storage and Uploads |
| over-fetching |
17. API Design and Gateways |
| p99 latency |
04. Scaling and Bottlenecks |
| PA/EL |
14. PACELC and Consensus |
| PACELC |
14. PACELC and Consensus |
| Pareto principle |
02. Back-of-Envelope Estimation |
| partition key |
09. Databases: SQL vs NoSQL |
| Paxos |
14. PACELC and Consensus |
| PC/EC |
14. PACELC and Consensus |
| peer-to-peer |
18. Real-Time Communication |
| Persistent connections |
03. Networking Fundamentals |
| polling |
18. Real-Time Communication |
| POSIX |
12. Object Storage and Uploads |
| POST policies |
12. Object Storage and Uploads |
| PostgreSQL |
01. The System Design Process, 09. Databases: SQL vs NoSQL |
| pre-signed URL |
12. Object Storage and Uploads |
| Probabilistic early expiration |
07. Caching |
| producers |
15. Message Queues |
| Prometheus |
20. Monitoring and Observability |
| Propagation delay |
03. Networking Fundamentals |
| Protocol Buffers |
05. Proxies and Service Communication, 17. API Design and Gateways |
| Proxies |
05. Proxies and Service Communication |
| Pub/Sub |
15. Message Queues |
| publish-subscribe |
05. Proxies and Service Communication |
| QPS |
02. Back-of-Envelope Estimation |
| queue |
01. The System Design Process |
| QUIC |
03. Networking Fundamentals |
| RabbitMQ |
05. Proxies and Service Communication, 15. Message Queues |
| Raft |
14. PACELC and Consensus |
| Range-based sharding |
11. Database Replication and Sharding |
| read replicas |
04. Scaling and Bottlenecks |
| Read-through |
07. Caching |
| read-to-write ratio |
02. Back-of-Envelope Estimation |
| Read-your-writes |
13. Consistency and CAP Theorem |
| Recursive resolver |
03. Networking Fundamentals |
| Redis |
01. The System Design Process, 07. Caching, 09. Databases: SQL vs NoSQL, 19. Rate Limiting |
| Redis SET NX |
16. Idempotency and Exactly-Once Delivery |
| Redis Streams |
15. Message Queues |
| Relational databases |
09. Databases: SQL vs NoSQL |
| Replication |
11. Database Replication and Sharding |
| REST |
17. API Design and Gateways |
| retry storm |
21. Designing for Failure |
| reverse proxy |
05. Proxies and Service Communication |
| reverse proxy cache |
08. Content Delivery Networks |
| Root nameserver |
03. Networking Fundamentals |
| Round Robin |
06. Load Balancers |
| Round-robin DNS |
03. Networking Fundamentals |
| RTP |
03. Networking Fundamentals |
| S3 |
02. Back-of-Envelope Estimation, 12. Object Storage and Uploads |
| schema-on-read |
09. Databases: SQL vs NoSQL |
| schema-on-write |
09. Databases: SQL vs NoSQL |
| SDP |
18. Real-Time Communication |
| semi-synchronous |
11. Database Replication and Sharding |
| SendGrid |
01. The System Design Process |
| service mesh |
05. Proxies and Service Communication, 17. API Design and Gateways |
| service registry |
05. Proxies and Service Communication |
| session affinity |
06. Load Balancers |
| SFU |
18. Real-Time Communication |
| shard |
11. Database Replication and Sharding |
| sharding |
01. The System Design Process, 11. Database Replication and Sharding |
| sidecar |
05. Proxies and Service Communication |
| signaling server |
18. Real-Time Communication |
| Signed cookies |
12. Object Storage and Uploads |
| SLA |
20. Monitoring and Observability |
| SLI |
20. Monitoring and Observability |
| Sliding Window Counter |
19. Rate Limiting |
| Sliding Window Log |
19. Rate Limiting |
| SLO |
20. Monitoring and Observability |
| sort key |
09. Databases: SQL vs NoSQL |
| span |
20. Monitoring and Observability |
| SQS |
05. Proxies and Service Communication |
| Squid |
05. Proxies and Service Communication |
| SSD |
02. Back-of-Envelope Estimation |
| SSE |
18. Real-Time Communication |
| SSO |
17. API Design and Gateways |
| Stale-while-revalidate |
07. Caching |
| stateful |
04. Scaling and Bottlenecks |
| stateless |
04. Scaling and Bottlenecks |
| sticky routing |
04. Scaling and Bottlenecks |
| Sticky sessions |
18. Real-Time Communication |
| Storage tiers |
12. Object Storage and Uploads |
| Strong consistency |
13. Consistency and CAP Theorem |
| structured logs |
20. Monitoring and Observability |
| structured process |
01. The System Design Process |
| TCP |
03. Networking Fundamentals |
| Throughput |
04. Scaling and Bottlenecks |
| thundering herd |
07. Caching |
| timeout |
21. Designing for Failure |
| TLD nameserver |
03. Networking Fundamentals |
| Token Bucket |
19. Rate Limiting |
| Traces |
20. Monitoring and Observability |
| Transactional outbox pattern |
16. Idempotency and Exactly-Once Delivery |
| TTL |
03. Networking Fundamentals, 07. Caching |
| TTL jitter |
07. Caching |
| tunable consistency |
14. PACELC and Consensus |
| TURN server |
18. Real-Time Communication |
| Twilio |
01. The System Design Process |
| Two Generals Problem |
16. Idempotency and Exactly-Once Delivery |
| two-phase commit |
11. Database Replication and Sharding |
| UDP |
03. Networking Fundamentals |
| under-fetching |
17. API Design and Gateways |
| UUID |
16. Idempotency and Exactly-Once Delivery |
| Varnish |
05. Proxies and Service Communication, 08. Content Delivery Networks |
| Vector clocks |
13. Consistency and CAP Theorem |
| Version keys |
07. Caching |
| Versioned URLs |
08. Content Delivery Networks |
| Vertical scaling |
04. Scaling and Bottlenecks |
| virtual IP |
06. Load Balancers |
| virtual nodes |
11. Database Replication and Sharding |
| WebRTC |
03. Networking Fundamentals, 18. Real-Time Communication |
| WebSocket |
03. Networking Fundamentals |
| Weighted DNS |
03. Networking Fundamentals |
| Weighted Round Robin |
06. Load Balancers |
| Wide-column stores |
09. Databases: SQL vs NoSQL |
| Write-behind |
07. Caching |
| Write-through |
07. Caching |
| Zipkin |
20. Monitoring and Observability |
| ZooKeeper |
05. Proxies and Service Communication, 13. Consistency and CAP Theorem, 14. PACELC and Consensus |