Skip to content
System Design
Search
Ctrl
K
Cancel
GitHub
Select theme
Dark
Light
Auto
Concepts
caching
Cache Invalidation
Write-Through Cache
cap
The CAP Theorem
Eventual Consistency
cdn
CDN Cache Busting
CDN: Push vs. Pull Zones
communication
REST vs. RPC
Synchronous vs. Asynchronous Communication
databases
Database Sharding
Read Replicas
SQL vs. NoSQL
dns
Common DNS Record Types
DNS Resolution Process
failure
The Circuit Breaker Pattern
Idempotency
load-balancing
Layer 4 vs. Layer 7 Load Balancing
Load Balancing Algorithms
messaging
Idempotent Consumers
Message Queues vs. Logs
The Publish/Subscribe (Pub/Sub) Pattern
observability
The Four Golden Signals
The Three Pillars of Observability
performance
Caching Strategies for Performance
Latency vs. Throughput
reliability
Error Budget
SLA, SLO, SLI
scalability
Horizontal vs. Vertical Scaling
Statelessness
security
Authentication vs. Authorization
OWASP Top 10
service-discovery
Client-Side vs. Server-Side Discovery
Service Registry
Topics
caching
Caching
cap
Consistency and Availability
cdn
Content Delivery Networks (CDNs)
communication
Inter-Service Communication
databases
Databases
dns
Domain Name System (DNS)
failure
Failure and Resilience
load-balancing
Load Balancing
messaging
Messaging and Streaming
observability
Observability
performance
Performance and Latency
reliability
Reliability and SLAs
scalability
Scalability
security
Security
service-discovery
Service Discovery
Prompts
Cache Invalidation Adversarial Ttl Theater
Cache Invalidation Application Feed
Cache Invalidation Failure Dropped Events
Cache Invalidation Recall Core
Cache Invalidation Tradeoff Ttl Vs Explicit
Eventual Consistency Adversarial Misuse
Eventual Consistency Application User Expectations
Eventual Consistency Failure Partition
Eventual Consistency Recall Core
Eventual Consistency Tradeoff Feed
Idempotent Consumers Adversarial Exactly Once
Idempotent Consumers Application Payments
Idempotent Consumers Failure Crash
Idempotent Consumers Recall Core
Idempotent Consumers Tradeoff Broker Vs App
Read Replicas Adversarial Debugging
Read Replicas Application Debug
Read Replicas Failure Spike
Read Replicas Recall Core
Read Replicas Tradeoff Cache Vs Replica
Write Through Cache Adversarial Availability
Write Through Cache Application Profile
Write Through Cache Failure Partial
Write Through Cache Recall Core
Write Through Cache Tradeoff Scale
Archive
The Professional Coding Guide
A Guide to Caching in System Design
Content Delivery Networks (CDNs)
Inter-Service Communication
A Guide to Databases in System Design
Domain Name System (DNS)
Load Balancers and Reverse Proxies
Asynchronous Messaging
A Guide to System Monitoring & Observability
Security in System Design
Service Discovery
Service Level Agreements (SLAs)
Distributed Systems
Computer Science Fundamentals
Fundamentals of Concurrency
Data Structures and Algorithms Guide
Behavioral Interview Master Guide
System Design Interview Guide
Technical Interview Master Guide
Software Design Guide
System Design
GitHub
Select theme
Dark
Light
Auto
Read Replicas Recall Core
Prompt
Explain replication lag and why it is unavoidable in asynchronous replication.