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.

By Tech Team Strategy · Nov 17, 2026 · 4 min read

20 System Design Concepts Every Developer Should Know (NeetCode)
Watch the interview

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."
Rate this story
00
Vocabulary18 terms

The words worth stealing from this conversation, what they mean, and who said them.

Elegant words

decoupled
Separated or disconnected, allowing different parts of a system to operate independently.
Navdeep Singh: “in doing so we also get the added benefit that different parts of our app can become decoupled”
fault tolerance
The ability of a system to continue operating properly in the event of the failure of some of its components.
Navdeep Singh: “it also adds redundancy and fault tolerance because if one of our servers goes down all of the other servers can continue to fulfill requests”
single point of failure
A part of a system that, if it fails, will stop the entire system from working.
Navdeep Singh: “this eliminates our previous single point of failure but the downside is that this approach is much more complicated”
trade-offs
Situations that involve losing one quality or aspect of something in return for gaining another.
Navdeep Singh: “the cap theorem was created to weigh trade-offs with replicated design”

Tech vocabulary

caching
Storing copies of data in a temporary storage location so that they can be accessed more quickly.
Navdeep Singh: “but cdns are just one technique for caching which is all about creating copies of data so that it can be refetched faster in the future”
CAP theorem
A concept stating that a distributed data store can simultaneously provide at most two of three guarantees.
Navdeep Singh: “it states that given a network partition in a database as database designers we can only choose to favor either data consistency or data availability”
content delivery networks
A geographically distributed network of proxy servers and their data centers to provide high availability and performance.
Navdeep Singh: “if you're just serving static files like images videos and sometimes even HTML CSS and JavaScript files you can just use a CDN”
domain name system
A decentralized system that translates human-readable domain names into numerical IP addresses.
Navdeep Singh: “for that we have the domain name system which is a largely decentralized service that works to translate a domain to its IP address”
GraphQL
A query language for APIs that allows clients to request exactly the data they need.
Navdeep Singh: “with graphql you can just make a single request AKA a query and you can choose exactly which resources you want to fetch”
horizontal scaling
Adding more servers to a network to distribute the workload and handle more traffic.
Navdeep Singh: “A better approach would be to add replicas so that each server can handle a subset of requests this is known as horizontal scaling”
load balancer
A server that distributes incoming network traffic across a group of backend servers.
Navdeep Singh: “for that we'll need a load balancer which is just a server known as a reverse proxy”
message queues
Systems that store messages temporarily to enable different applications or services to communicate asynchronously.
Navdeep Singh: “if our system was receiving more data than it can process it would be good to introduce a message queue so that our data can be persisted”
REST
A standardized architectural style for web services that makes APIs stateless and consistent.
Navdeep Singh: “the most popular one being rest which is a standardization around HTTP apis making them stateless and following consistent guidelines”
sharding
A database partitioning strategy that splits very large databases into smaller, faster, more easily managed parts.
Navdeep Singh: “if we don't have to enforce any foreign key constraints that means we can break up our database and scale it horizontally with different machines this technique is called sharding”
vertical scaling
Adding more resources like RAM or CPU to a single server to handle increased load.
Navdeep Singh: “the easiest thing to do would be to add more resources like Ram or maybe upgrade your CPU this is known as vertical scaling”
WebSockets
A protocol providing full-duplex, bi-directional communication channels over a single TCP connection.
Navdeep Singh: “but unlike HTTP 1 websockets support bi-directional communication so when you get a new message it's immediately pushed to your device”

Trends and buzzwords

gRPC
A high-performance, open-source remote procedure call framework initially developed by Google.
Navdeep Singh: “another API pattern is grpc though it's really considered a framework released by Google in 2016 it was also meant to be an improvement over rest apis”
NoSQL
A non-relational database design that does not require a fixed schema and scales horizontally easily.
Navdeep Singh: “this one is really important because it led to the creation of nosql or non-relational databases”
Quiz: two questions+10

Get both right to win 10 tokens. One try only.

  1. 1. According to the summary, which API style is recommended for internal communication between services?

  2. 2. Which of the following use cases is recommended to use ACID guarantees for strict consistency?

Free account. Your answers are kept while you sign in.

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
  • 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 or see our services.

Full transcript

Read the whole interview, word for word, with a timestamp on every answer. Free with a sign-in.

Sign in to read it

Originally published by Tech Team Strategy

What did you think of this story?

+10 tokens

Tap to vote ↓

GreatAverageNot great

Sign in to vote

Comments

Sign in to commentJoin the conversation and earn 10 tokens.

  • No comments yet. Be the first.

Get the briefing

The week's essential stories, free in your inbox.

More