System Design flashcards, generated for you.

To build scalable, reliable, and maintainable systems that meet functional and non-functional requirements within constraints (latency, throughput, cost).

Scalability is the ability to handle growing load. Vertical scaling: add more resources to a single machine (CPU, RAM). Horizontal scaling: add more machines to distribute load.

Vertical scaling is simpler but has hard limits (max CPU/RAM per machine) and causes single points of failure. Horizontal scaling is unlimited but adds complexity (distributed systems challenges, synchronization, data consistency).

Availability is the percentage of time a system is operational. Measured in 'nines': 99% (two nines) = 3.6 days downtime/year; 99.9% (three nines) = 8.7 hours/year; 99.99% (four nines) = 52 minutes/year.

A distributed system can guarantee at most 2 of 3 properties: Consistency (all nodes see same data), Availability (system always responds), Partition tolerance (survives network splits). Must choose CA, CP, or AP.

Strong consistency: all reads return latest write, but requires coordination (higher latency, lower availability). Eventual consistency: reads may return stale data briefly, but high availability and low latency. Choose based on use case (e.g., banking needs strong; social feed tolerates eventual).

Load balancer distributes traffic across multiple servers to improve availability and throughput. Failure modes: (1) load balancer itself becomes a bottleneck/single point of failure, (2) poor distribution algorithms cause uneven load (hotspots).

Replication copies data across multiple database nodes for redundancy and read scaling. Synchronous replication: writes wait for all replicas (strong consistency, high latency). Asynchronous replication: writes return after primary write (eventual consistency, low latency).

Sharding partitions data across multiple databases by a key (e.g., user_id). Solves: single database throughput/storage limits. Major challenge: uneven shard distribution (hot shards) or future resharding complexity when data outgrows a shard.

SQL: ACID guarantees, complex queries, schema enforced—but less scalable horizontally. NoSQL: horizontal scalability, high throughput, flexible schema—but weaker consistency guarantees and limited query flexibility.