Introduction to System Design

System design is the process of planning how different parts of a software application work together to serve millions of users without breaking down. Think of it like designing a city — roads, electricity, water supply, and buildings all need to work together smoothly. In software, the "roads" are networks, the "buildings" are servers, and the "electricity" is data flow.

Every app people use daily — YouTube, Amazon, WhatsApp — runs on a carefully designed system. Understanding system design helps developers and architects build software that handles heavy traffic, stores data safely, and stays fast under pressure.

Why System Design Matters

A poorly designed system crashes under load, loses data, or becomes too expensive to run. A well-designed system scales gracefully, recovers from failures, and delivers a smooth experience. System design interviews also form a core part of hiring at top tech companies, making this knowledge critical for career growth.

Key Goals of a Good System Design

Every system design aims to achieve four main goals:

Scalability – The system handles more users or data as demand grows.
Reliability – The system keeps running even when parts fail.
Availability – The system stays accessible to users with minimal downtime.
Performance – The system responds quickly to every request.

Core Building Blocks of a System

Every large-scale system is built from a few standard components. Recognizing these blocks makes it easier to design any application:

Component	What It Does	Simple Example
Client	Sends requests to the system	A browser or mobile app
Server	Receives and processes requests	A web server running your app
Database	Stores and retrieves data	MySQL storing user accounts
Cache	Stores frequently used data for fast access	Redis holding session data
Load Balancer	Spreads traffic across multiple servers	Nginx distributing requests
Message Queue	Handles tasks asynchronously	RabbitMQ processing orders
CDN	Delivers content from nearby servers	Cloudflare serving images fast

How a Simple Request Flows Through a System

Understanding request flow is the foundation of system design. Here is a step-by-step diagram of what happens when someone opens a website:

+--------+        +----------------+        +-------------+        +----------+
|        |  HTTP  |                |  Query |             |  Data  |          |
| Client | -----> |  Load Balancer | -----> |   Server    | -----> | Database |
| (User) |        |                |        |             |        |          |
+--------+        +----------------+        +-------------+        +----------+
                                                   |
                                                   | Check Cache First
                                                   v
                                            +-------------+
                                            |    Cache    |
                                            |   (Redis)   |
                                            +-------------+

Step-by-step flow:

The user types a URL and the browser sends an HTTP request.
The load balancer receives the request and forwards it to an available server.
The server checks the cache. If the data is there, it returns it immediately.
If the data is not in cache, the server queries the database.
The database returns the data, the server stores it in cache, then sends the response back.

Types of System Design

High-Level Design (HLD)

High-level design focuses on the big picture. It defines which components exist, how they connect, and how data moves between them. HLD answers questions like "Should we use SQL or NoSQL?" and "How many servers do we need?"

Low-Level Design (LLD)

Low-level design goes deeper into each component. It covers class structures, database schemas, API contracts, and algorithms. LLD answers questions like "How does the User class look?" and "What columns does the orders table have?"

Functional vs Non-Functional Requirements

Before designing any system, two types of requirements must be clear:

Functional Requirements

These define what the system must do. Example: "Users can upload photos", "Payments process in under 3 seconds", "Notifications send within 1 minute."

Non-Functional Requirements

These define how well the system must perform. Example: "The system must support 10 million users", "Uptime must be 99.9%", "Page load time must stay under 2 seconds."

Requirement Type	Focus	Example
Functional	What the system does	User can search for products
Non-Functional	How well it performs	Search results appear in under 500ms

Estimating System Scale

Good system design always starts with numbers. Rough estimations help decide how many servers, how much storage, and what kind of database a system needs.

For example, consider designing a URL shortener like bit.ly:

Expected writes per second: 100 new URLs
Expected reads per second: 10,000 redirects
Storage for 5 years: 100 writes/sec × 86,400 sec × 365 days × 5 years = ~15 billion records

These numbers immediately tell a designer that reads are far more frequent than writes, so the system needs heavy caching and optimized read performance.

Common Mistakes Beginners Make in System Design

Jumping into solutions without understanding requirements
Ignoring failure scenarios and edge cases
Over-engineering a simple system
Forgetting about data consistency and security
Not thinking about how the system will grow over time

Summary

System design is the art and science of planning large-scale software. It starts with understanding requirements, estimating scale, and then selecting the right components. Every decision in system design involves trade-offs — speed vs consistency, cost vs reliability, simplicity vs flexibility. Mastering these trade-offs is what makes a great system designer.

Back to courses

Next lessons