Most people think system design is about building the “best” architecture. It’s not—instead, it’s about making the right tradeoffs for a given workload and constraints.
Explore all 50 categorized tradeoffs below. Click any card to expand its description.
1. Performance, Latency & Throughput
1. Latency vs Throughput
Batching many requests together can reduce network, serialization & processing overhead and increase throughput. Yet the downside is individual requests wait longer while a batch forms. Use batching when throughput matters and individual requests when low latency matters.
2. Latency vs Tail Latency
A system can have excellent median latency while a tiny number of slow requests create poor p95 and/or p99 latency. Redundant/hedged requests can reduce these long tails, but they consume extra capacity.
3. Compression vs CPU Usage
Compressing data reduces network bandwidth & storage requirements. Yet compression and decompression require CPU and add processing latency. Use compression when bandwidth/storage matters, and uncompressed data when low CPU usage matters.
4. Telemetry Fidelity vs Observability Cost
Recording ALL distributed traces gives deep visibility for debugging. Sampling reduces storage costs, but risks missing occasional critical traces.
5. High Utilization vs Capacity Headroom
Running infrastructure close to maximum utilization reduces unit costs, while extra headroom allows the system to better absorb traffic bursts and latency spikes.
6. Synchronous Blocking vs Asynchronous Non-Blocking
Blocking calls simplify control flow but tie up threads and limit concurrency. Asynchronous models maximize resource utilization and throughput at the cost of complex callback/event handling.
7. Polling vs Event-Driven Push
Polling is simple to implement and manage on server endpoints, but creates wasted network traffic and idle overhead. Event-driven push is highly efficient for real-time updates but requires robust broker infrastructure.
8. Batch vs Stream Processing
Batch processing handles massive data chunks efficiently with lower operational overhead, whereas stream processing provides real-time insights with higher architectural complexity.
2. Data Management, Storage & Access Patterns
9. Database Indexes vs Cheaper Writes
Database indexes boost query performance, but consume storage and add overhead when rows get inserted, updated, or deleted. Use indexes when query speed matters; keep them minimal when write performance is critical.
10. Normalization vs Denormalization
Normalized data reduces duplication and eases consistency. Denormalization makes reads faster and avoids expensive joins, but requires synchronization logic for duplicate data.
11. Relational Databases vs NoSQL
Relational databases excel at flexible queries and complex relationships. NoSQL databases scale horizontally around known access patterns, but adding new query patterns is harder.
12. B-Tree Storage vs LSM-Style Storage
B-trees organize data for fast point and range reads. LSM trees optimize for heavy write throughput by writing data sequentially and compacting in the background.
13. Leveled vs Universal LSM Compaction
Leveled compaction does more rewrites to keep data neatly organized for fast reads. Universal compaction does fewer rewrites to maximize write efficiency at the cost of read performance.
14. Range Partitioning vs Hash Partitioning
Range partitioning keeps nearby keys together for efficient range queries. Hash partitioning spreads writes evenly across partitions but sacrifices natural key locality.
15. Row-Oriented vs Column-Oriented Storage
Row-oriented storage is optimized for transactional workloads (OLTP) and fast single-record lookups. Column-oriented storage is tailored for analytical queries (OLAP) reading subset columns across massive datasets.
16. In-Memory vs Disk-Backed Storage
In-memory storage delivers sub-millisecond read/write latencies but is limited by RAM capacity and volatile risk. Disk-backed storage offers massive capacity and persistence at the expense of I/O latency.
17. Append-Only Logs vs Mutable Storage
Append-only logs provide extreme write speeds and audit safety, but require periodic compaction and secondary indexing to query efficiently. Mutable storage allows direct updates but risks fragmentation and locking overhead.
18. Hot/Cold Tiering vs Unified Storage
Tiering hot data on fast SSDs and cold data on cheap object storage optimizes infrastructure cost, but adds retrieval latency and management complexity.
3. Replication, Consistency & Distributed Systems
19. Consistency vs Availability (CAP Theorem)
Replicas cannot coordinate during network partitions. Strong consistency requires rejecting updates, while available replicas temporarily diverge. Prioritize consistency when stale data is unacceptable, and availability during partitions.
20. Cross-Region Consistency vs Write Latency
Synchronously coordinating data across distant regions ensures strong consistency, but network round-trips significantly increase transaction write latency.
21. Read Quorum vs Write Quorum
Larger read quorums provide stronger read guarantees at the cost of latency and resource consumption, while larger write quorums secure write durability.
22. Synchronous vs Asynchronous Replication
Synchronous replication waits for replica acknowledgment before committing to reduce data loss risk. Asynchronous replication gives faster writes but risks replica lag.
23. Single-Region vs Multi-Region Deployment
Single-region setups simplify architecture and lower write latency, whereas multi-region deployments improve geographic resilience and read proximity at high replication cost.
24. Replica Reads vs Primary Reads
Reading from nearby replicas reduces latency and scales read capacity, but risks returning stale data if replication lags behind the primary.
25. Strong Consistency vs Eventual Consistency
Strong consistency guarantees all nodes show identical data immediately at the cost of latency. Eventual consistency maximizes availability and speed, converging over time.
26. Leader-Based vs Leaderless Replication
Leader-based architectures simplify write coordination and routing, but create a single point of failure and write bottleneck. Leaderless systems offer high write availability but complicate conflict resolution.
27. Centralized vs Decentralized Gossip Protocols
Centralized cluster registries provide deterministic state views with coordination overhead, while decentralized gossip protocols scale smoothly with eventual state discovery.
4. Concurrency, Transactions & Conflict Resolution
28. Serializable vs Weaker Transaction Isolation
Serializable isolation prevents all concurrency anomalies but increases transaction aborts and retries under contention. Weaker isolation allows higher concurrency at the expense of data anomalies.
29. Optimistic vs Pessimistic Concurrency Control
Optimistic concurrency allows operations to proceed and checks for conflicts later, ideal when conflicts are rare. Pessimistic locking prevents conflicts upfront but causes blocking.
30. Last-Write-Wins vs Concurrent Updates
Last-write-wins automatically resolves conflicts simply, while version tracking and explicit merging preserve concurrent updates at the cost of metadata and application logic.
31. Distributed Transactions (2PC/Saga) vs Localized Consistency
Distributed 2PC transactions enforce strict atomicity across services at severe latency and availability costs, whereas Saga patterns use compensating actions for eventual consistency.
32. Idempotency Overhead vs At-Least-Once Delivery Duplicates
At-least-once messaging guarantees delivery but produces duplicate events that require stateful idempotency checks and deduplication storage overhead.
33. Lock-Free vs Lock-Based Concurrency
Lock-free data structures utilize atomic CPU instructions (CAS) to eliminate thread blocking and context-switching overhead, but can introduce heavy CPU spin contention under high concurrency.
34. Thread-Per-Request vs Event Loop Concurrency
Thread-per-request models simplify synchronous programming state management but hit memory limits under high concurrency. Event loops maximize I/O throughput with lightweight task scheduling.
35. Rate Limiting vs Queue Buffering
Rate limiting immediately rejects excess traffic to protect downstream services, while queue buffering absorbs traffic spikes but increases end-to-end processing latency.
5. Caching & State Management
36. Cache Freshness vs Cache Hit Rate (TTL Tuning)
Longer TTLs increase cache hit rates and reduce origin load, but keep stale data cached longer. Shorter TTLs prioritize data freshness.
37. Local Cache vs Shared Remote Cache
In-process local caches avoid network overhead for ultra-fast reads, while shared remote caches make data easily shareable across instances at the cost of network latency.
38. Write-Through vs Write-Back Caching
Write-through caches write data to cache and backing store simultaneously for strong consistency, while write-back caches queue writes in memory for high speed with durability risk.
39. Cache Aside vs Read-Through Caching
Cache-aside places application logic in charge of loading and invalidating cache entries. Read-through delegates cache population transparently to the caching layer.
40. Stateless vs Stateful Application Instances
Stateless instances scale horizontally with ease and simplify failover, whereas stateful instances maintain local session context to eliminate external lookups at scaling cost.
41. Client-Side vs Server-Side State Management
Client-side state reduces server compute load and enables offline capability, but introduces security validation challenges and client sync discrepancies.
42. Distributed Sessions vs Sticky Sessions
Sticky sessions route users to the same server for simple local caching, while distributed session stores prevent load imbalances and instance failover loss.
6. Scalability, Reliability & Operations
43. Replication vs Sharding
Replication copies identical data to improve redundancy and read capacity. Sharding splits different data across nodes to scale aggregate storage and write capacity while complicating routing.
44. Circuit Breaking vs Graceful Degradation
Circuit breakers fail fast when downstream dependencies degrade to protect system resources, whereas graceful degradation serves fallback static content to maintain core usability.
45. Bulkheads & Isolation vs Resource Sharing
Isolating resources into bulkheads prevents cascading failures across tenants or services, but lowers overall hardware utilization efficiency.
46. Graceful Shutdown vs Fast Deployment Turnaround
Allowing active connections to drain gracefully prevents client errors during deployments, but increases CI/CD pipeline deployment times.
47. Automated Failover vs Manual Intervention
Automated failover minimizes recovery downtime during outages, but risks split-brain anomalies and flapping during transient network blips.
48. Monolith vs Microservices Architecture
Monoliths simplify initial development, deployment, and transactional consistency. Microservices enable independent scaling and team autonomy at the cost of distributed networking and operational complexity.
49. Containerization vs Virtualization
Containers share the host OS kernel for lightweight startup and high density, whereas virtual machines provide strict hardware-level isolation and guest OS flexibility.
50. Comprehensive Staging Fidelity vs Velocity & Cost
Mirroring production environments in staging catches subtle integration bugs early, but incurs high infrastructure costs and slows release velocity.