Every design decision involves tradeoffs. Knowing these helps you make informed choices and explain your reasoning.

Consistency vs Availability (CAP): Strong consistency → some requests fail during partition. High availability → potentially stale data.
Latency vs Throughput: Batching improves throughput but increases per-item latency. Real-time = optimize latency; analytics = optimize throughput.
Read vs Write Performance: Indexes speed reads but slow writes. Denormalization speeds reads but complicates writes.
Memory vs CPU vs Disk: Cache in RAM (fast, expensive) to save CPU/disk (slow, cheap).
Cost vs Performance: SSD vs HDD, reserved vs spot instances, CDN fees vs origin load.
Simplicity vs Flexibility: REST is simpler. GraphQL is more flexible but more complex.
Strong vs Eventual Consistency: Strong = slower, more coordination. Eventual = faster but lag windows.
Monolith vs Microservices: Monolith simpler to develop/debug. Microservices scale/deploy independently.
Normalization vs Denormalization: Normalized saves space, avoids anomalies. Denormalized faster reads.
SQL vs NoSQL: SQL has ACID + JOINs. NoSQL has horizontal scale + flexible schemas.
Push vs Pull: Push is real-time but wastes resources when no data. Pull is wasteful polling but simpler.
Sync vs Async: Sync is simpler to reason about. Async is more resilient and decoupled.
Vertical vs Horizontal Scaling: Vertical is simpler. Horizontal is resilient and unlimited.
Security vs Usability: More auth steps = more secure but worse UX.
Accuracy vs Speed: Exact count requires locks. Approximate count (HyperLogLog) is orders of magnitude faster.

System Design Study Guide

Vertical (Scale Up): Add CPU/RAM to existing machine. Simple but limited — eventually hits hardware ceiling. Creates a single point of failure.
Horizontal (Scale Out): Add more machines, distribute load. Requires stateless app design + load balancers, but virtually unlimited.