# 20 System Design Concepts Every Developer Should Know (NeetCode)

A plain-language guide to NeetCode's 20 system design concepts, from horizontal scaling and CDNs to ACID, sharding, the CAP theorem and message queues.

- Source: https://raleche.com/story/neetcode-20-system-design-concepts
- Published: 2026-11-17
- Author: Tech Team Strategy (RALECHE)
- Speaker: System Design
- Tags: NeetCode, System Design, Scalability, Load Balancing, Caching, APIs, Databases, Software Engineering, Interviews

> An executive summary of this story is available to members at https://raleche.com/story/neetcode-20-system-design-concepts.

---

> Watch the original interview: [YouTube](https://www.youtube.com/watch?v=i53Gi_K3o7I)

**NeetCode** (Navdeep Singh) packs 20 system design concepts into about eleven minutes, the building blocks you need to move past junior developer work and to pass the system design round of a software interview. They fall into four groups: scaling, networking, API patterns and data. Here is each one in plain language.

This article is our own summary, with short quotes, from the video's automatic transcript. Watch the full video above for everything that was said.

## The short version

-   **Scale out, not just up.** Adding RAM or CPU to one server (vertical scaling) is easy but limited. Adding servers (horizontal scaling) scales much further and removes the single point of failure, at the cost of complexity.
-   **Spread and copy the load.** Load balancers route traffic across servers; CDNs and caches keep copies of data close to where it is needed.
-   **Know how machines talk.** IP addresses, TCP/IP, DNS and HTTP are the layers under every web request.
-   **Pick the right API style.** REST is the common standard, GraphQL lets the client ask for exactly what it needs, gRPC is fast for server-to-server calls, and WebSockets push data both ways in real time.
-   **Data is where the trade-offs live.** SQL databases give ACID guarantees; NoSQL gives up strict consistency to scale; sharding, replication, the CAP theorem and message queues decide how data is spread, copied and buffered.
-   His closing line: software engineering "is all about finding new and complicated ways to store and move data around."

## The 20 concepts

### Scaling

1.  **Vertical scaling:** more resources on one server. Simple, but capped.
2.  **Horizontal scaling:** more servers, each handling part of the requests. Adds redundancy and fault tolerance.
3.  **Load balancer:** a server acting as a reverse proxy that sends each request to the right server, for example by round robin or by hashing the request ID, or to the nearest location.
4.  **CDN (content delivery network):** servers around the world that hold copies of static files (images, videos, HTML, CSS, JavaScript) taken from your origin server, by push or pull.
5.  **Caching:** keeping copies of data so it can be fetched faster: browser to disk, disk to memory, memory to the CPU's L1, L2 and L3 caches.

### Networking

1.  **IP address:** the unique identifier of a device on a network.
2.  **TCP/IP:** the Internet Protocol Suite (it also includes UDP). TCP numbers packets so they can be reassembled in order and resends missing ones, which is why HTTP and WebSockets are built on it.
3.  **DNS (domain name system):** a largely decentralized service that translates a domain into an IP address through records such as the A record; your operating system caches the answer.
4.  **HTTP:** the application-level protocol developers use daily. Each request and response has a header (the shipping label) and a body (the package contents).

### API patterns

1.  **REST:** a standard for stateless HTTP APIs with consistent rules: 200 for success, 400-level codes for client errors, 500-level for server errors.
2.  **GraphQL:** introduced by Facebook in 2015. One query fetches exactly the resources you choose, with no over-fetching.
3.  **gRPC:** a framework released by Google in 2016, mostly for server-to-server calls (with gRPC-Web for browsers). It sends protocol buffers, a binary format that is smaller than JSON but less human-readable.
4.  **WebSockets:** two-way communication, so a chat app can push a new message instantly instead of polling.

### Data

1.  **SQL databases** such as MySQL and Postgres store data efficiently in structures like B-trees and retrieve it fast with queries.
2.  **ACID:** durability (data survives a restart), isolation (concurrent transactions don't interfere), atomicity (all or nothing) and consistency (constraints like foreign keys are always enforced).
3.  **NoSQL:** key-value stores, document stores and graph databases that drop consistency and relations to scale more easily.
4.  **Sharding:** splitting a database across machines using a shard key, such as a person's ID.
5.  **Replication:** leader-follower copies to scale reads (writes go to the leader), or leader-leader, which risks inconsistent data and suits one replica per region.
6.  **CAP theorem:** when a network partition happens, a replicated database can favor consistency or availability, not both. He notes "consistency" here differs from ACID, and that the fuller PACELC theorem was created because CAP is somewhat controversial.
7.  **Message queues:** durable, replicable buffers that hold data until the system can process it and decouple parts of an app.

## What it means for your business

1.  **Plan for horizontal growth early.** If your app runs on one server, you have a single point of failure.
2.  **Put a CDN and caching in front of static content.** It is the cheapest speed win for customers far from your servers.
3.  **Choose API styles by use:** REST for public APIs, gRPC between internal services, WebSockets for live updates.
4.  **Decide what must be strictly consistent.** Payments and inventory need ACID; feeds and analytics can often trade consistency for scale.
5.  **Use a queue for spikes.** It protects your system when traffic outruns processing.

## Video details

-   **Title:** 20 System Design Concepts Explained in 10 Minutes
-   **Creator:** NeetCode (Navdeep Singh)
-   **Published by:** NeetCode on YouTube
-   **Watch:** [youtube.com/watch?v=i53Gi\_K3o7I](https://www.youtube.com/watch?v=i53Gi_K3o7I)
-   **Note:** quotes come from the video's automatic transcript and are lightly cleaned. Check the video for exact wording.

## Want to put this to work?

We help owners turn AI trends into a plan, a product and a launch. [Book a free call](https://calendly.com/davidraleche/30min) or [see our services](https://tech-team-strategy.com/services).
