A ten-minute sprint through the vocabulary every system design interview assumes you already know, from a single overloaded server all the way to globally replicated databases. The through-line: software engineering is mostly about finding new and complicated ways to store and move data around.

Scaling and load

Vertical scaling means giving one server more resources, such as extra RAM or a faster CPU. It is the easiest fix but hits a hard ceiling because a single machine can only grow so far.

Horizontal scaling adds replica servers so each handles a subset of requests. It scales almost infinitely on cheap machines and adds redundancy and fault tolerance, since a failed server no longer means a single point of failure, at the cost of much more coordination complexity.

Load balancer is a server (a reverse proxy) that spreads incoming requests across the pool so no single server gets overwhelmed while others sit idle. It routes using algorithms like round robin or hashing the request ID, and can also send a request to the geographically nearest server.

Caching and content delivery

CDN (content delivery network) is a worldwide network of servers that copies static files (images, video, sometimes HTML/CSS/JS) from your origin server so users fetch them from a nearby location. CDNs run no application logic and populate their copies on either a push or pull basis.

Caching is the general technique of keeping copies of data closer so it can be refetched faster. It happens at every layer: browsers cache to disk, the OS copies hot data into memory, and the CPU pulls a subset into its L1/L2/L3 caches, each step trading capacity for speed.

Networking foundations

IP address is the unique identifier assigned to every device on a network so machines can find one another.

TCP/IP (Internet Protocol Suite) is the set of protocols governing how data crosses the internet; it also includes UDP. TCP breaks data into numbered packets, reassembles them in order at the destination, and resends anything lost, which makes it a reliable protocol that HTTP and WebSockets build on top of.

DNS (domain name system) is a largely decentralized service that translates a domain name into its IP address. Buying a domain lets you create an A (address) record pointing at your server’s IP; your computer queries DNS, uses that mapping, then caches the result to avoid repeating the lookup.

HTTP is an application-level protocol built on TCP so developers do not have to manage raw packets. It follows the client-server model: a client sends a request with a header (metadata, like a shipping label) and a body (the contents), and the server responds with its own header and body.

API and communication patterns

REST is the most popular HTTP API pattern, standardizing stateless APIs around consistent conventions such as status codes (200 for success, 400 for a bad client request, 500-level for server errors).

GraphQL (Facebook, 2015) lets a client fetch exactly the resources it needs in a single query, avoiding both the many round-trips and the over-fetching that REST often causes.

gRPC (Google, 2016) is an RPC framework, mainly for server-to-server communication, with a gRPC-web variant for browsers. Its speed comes from Protocol Buffers, which serialize data into a compact binary format rather than REST’s human-readable but bulkier JSON.

WebSockets is an application-layer protocol supporting bi-directional communication, unlike HTTP where a chat app would have to poll repeatedly for new messages. Messages are pushed instantly in both directions the moment they are sent or received.

Data storage

SQL / relational databases (RDBMS) like MySQL and PostgreSQL store data in rows and tables, using structures such as B-trees for efficient storage and SQL queries for fast retrieval.

ACID describes the guarantees relational databases usually provide: Atomicity (each transaction is all-or-nothing), Consistency (foreign-key and other constraints are always enforced), Isolation (concurrent transactions do not interfere), and Durability (committed data survives restarts because it is on disk).

NoSQL / non-relational databases drop the consistency constraint and the notion of relations because consistency makes databases hard to scale. Popular types include key-value stores, document stores, and graph databases.

Scaling data and reliability trade-offs

Sharding splits a database horizontally across machines, made possible once foreign-key constraints are dropped. A shard key (for example a person’s ID) decides which slice of data lives on which machine.

Replication is a simpler scaling approach that makes copies of a database. In leader-follower replication all writes go to the leader and propagate to read-only followers; in leader-leader replication every replica can read and write, which risks inconsistency and suits one replica per region.

CAP theorem states that during a network partition a database can favor either consistency or availability, but not both. Its “consistency” means something different from ACID’s, and its incompleteness motivated the more thorough PACELC theorem.

Message queues offer durable, replicable, shardable storage like databases but serve different roles. They buffer data when a system receives more than it can process immediately, and they decouple different parts of an application.

Key takeaways

  • Scaling starts vertical (simple, limited) and moves horizontal (redundant, complex), fronted by a load balancer.
  • CDNs and multi-layer caching cut latency by keeping copies of data close to where it is needed.
  • The networking stack layers cleanly: IP addresses devices, TCP/IP moves reliable packets, DNS resolves names, HTTP rides on top.
  • API patterns trade off differently: REST for ubiquity, GraphQL for precise fetching, gRPC for fast server-to-server calls, WebSockets for real-time push.
  • Relational databases give ACID guarantees; NoSQL sacrifices consistency to scale, and sharding plus replication extend either, with CAP and PACELC naming the trade-offs.
  • Message queues absorb bursts and decouple components.

Sources