System Design That Actually Makes Sense

I thought System Design was all about memorizing patterns for interviews. Turns out, that was the...

I thought System Design was all about memorizing patterns for interviews. Turns out, that was the problem.

I used to think System Design was something abstract and only meant for interviews. But the more I learned, the more I realized it is actually about something very simple i.e. Handling growth.

Imagine you are opening a tiny pizza shop. At first, it is just you, a small oven, and a few neighbors stopping by. But what happens if suddenly 10,000 people want pizza at the exact same time?

That is the heart of System Design.

What is System Design and Why It Matters

System design is the process of defining the architecture, components, modules, interfaces, and data for a system to satisfy specific requirements. It is essentially creating a blueprint for a complex software system to ensure it is efficient, reliable, and scalable.

This is you drawing the floor plan for your pizza shop, deciding where the oven goes, how the pantry is organized, and how many chefs you need so the shop doesn't collapse when 1,000 customers show up.

Why It Matters in Real World Engineering

As developers level up, companies stop paying for just code and start paying for architectural decisions that handle high traffic and balance cost with performance.

A junior chef knows how to bake one pizza but a Senior Chef knows how to design a kitchen that can bake 500 pizzas an hour without the building catching fire.

Functional vs Non-Functional Requirements

Functional requirements are the specific features the system must offer (the "what"). Non-functional requirements are quality constraints like scalability, reliability, and security (the "how").

A functional requirement is "The user can order a pepperoni pizza.". A non-functional requirement is "The pizza must be ready in under 15 minutes" (latency) or "The shop must stay open even during a storm" (availability).

The technical trade-offs or limits you must work within, such as hardware capacity, budget, or the laws of physics.

You only have room for two ovens, or you cannot afford to hire 50 chefs.

How to Approach a Design Problem

Requirement Clarification

This is the process of asking questions to define the exact scope of a vague problem.

Before building the kitchen, you ask: "Are we a small local shop or a global delivery giant?"

Scope Definition

Deciding what features are included or excluded to manage complexity and time.

You decide, "Today we will focus on baking and delivery, but we will not build the pizza review system yet."

Back of the Envelope Estimation

Quick calculations to estimate the scale of the system, such as requests per second or storage.

If we have 10,000 customers and each orders one pizza, we need enough dough to make 10,000 pizzas every day.

Identifying Bottlenecks Early

Finding the slowest part of the system that will break first under heavy load.

You realize that even if you have 100 chefs, you only have one oven. That oven is your bottleneck.

Core System Concepts

Client-Server Architecture and Request Flow

A client-server model is where a client (like a browser) sends a request and a server responds to it.

The request lifecycle looks like this:

1. Customer places an order
2. Chef receives the order
3. Chef checks the pantry (database)
4. Pizza is prepared and sent back

The customer is the client. The pizza shop is the server.

Latency vs Throughput

Latency is the time it takes to complete a single action. Throughput is the number of actions completed in a given time.

Latency is how long you wait for your pizza. Throughput is how many pizzas the shop can make in one hour.

Vertical vs Horizontal Scaling

Vertical scaling is adding more power to a single machine. Horizontal scaling is adding more machines to share the load.

Vertical scaling is buying a super oven. Horizontal scaling is buying five ovens and hiring five more chefs.

Networking Basics

HTTP vs HTTPS

HTTP is the protocol used to transfer data. HTTPS is the secure version that encrypts that data.

HTTP is like shouting your order across the street. HTTPS is like handing your order in a locked briefcase.

DNS Resolution

DNS translates a domain name into an IP address.

You know the shop name, but DNS gives you the exact location so you can reach it.

TCP vs UDP

TCP is reliable and ensures data arrives correctly. UDP is faster but may lose some data.

TCP is like a pizza delivery where the rider waits until you confirm you received the order correctly. UDP is a promo flyer about pizza deals thrown at your door you might get it, you might not.

Load Balancers

A load balancer distributes incoming requests across multiple servers.

It is like a manager at the entrance telling customers which chef to go to so no one gets overwhelmed.

Data Storage Basics

SQL vs NoSQL

SQL databases store data in structured tables with fixed schemas. NoSQL databases are more flexible and can store data in multiple formats.

SQL is like a structured recipe book. NoSQL is like sticky notes where anything can be written.

When to Use Which

Use SQL when relationships and structure matter. Use NoSQL when data is large, flexible, and needs to scale quickly.

Use SQL for payments and orders. Use NoSQL for user-generated content.

Indexing

An index helps the database find data quickly. Instead of scanning everything, it jumps directly to the required data. It is like a table of contents in a book.

Instead of checking every order slip, the chef uses a labeled rack (veg, non-veg, pending) to instantly find the right order.

ACID Properties

ACID stands for Atomicity, Consistency, Isolation, and Durability. It ensures transactions are reliable.

If a customer pays, either the money is transferred completely or nothing happens. There is no partial state.

• Atomicity: Either the pizza order is fully placed or not placed at all
• Consistency: Order details (price, items) are always correct
• Isolation: Two customers ordering at the same time don’t mix up orders
• Durability: Once the order is confirmed, it won’t disappear even if the system crashes

Caching Fundamentals

What Problem Caching Solves

Caching stores frequently used data in faster storage so it can be accessed quickly. Instead of checking the database repeatedly, the system uses cached data.

Think of a pizza shop. Popular pizzas (like Margherita) are kept ready on the counter. Instead of making it from scratch every time (database), the shop serves the ready pizza (cache) instantly.

Cache-Aside Pattern

The system checks the cache first. If the data is not found, it fetches it from the database and stores it in the cache.

Customer asks for a pizza:

• If it’s already on the counter, serve immediately
• If not kitchen prepares it, then keeps a copy ready for the next customer

TTL (Time-to-Live)

TTL defines how long data stays in the cache before it is refreshed. This ensures outdated data is not used.

Pizzas can’t sit forever. After some time, they’re thrown away and made fresh again. That “expiry time” is TTL.

Monolith vs Microservices

Monolith

A monolith is a single system where everything is tightly connected. It is easier to build but harder to scale.

One big kitchen where the same team handles orders, cooking, billing, and delivery. Simple setup but if too many orders come in, everything slows down.

Microservices

Microservices break the system into smaller independent services. Each service does one thing and communicates with others.

It is harder to build but easier to scale.

Separate teams:

• One for taking orders
• One for cooking
• One for delivery

Each team works independently, so the system handles more customers efficiently.

When Each Works

Monolith works well for small systems. Microservices work well for large, complex systems with multiple teams.

Monolith when small pizza shop with limited orders and one kitchen is enough. Microservices when large pizza chain with separate teams and scalable operations.

Beginner Design Case Studies

System Design is not about memorizing answers. It is about understanding how systems behave when they grow. It is about thinking ahead.

Take a simple system and think through it.

• Where will it break
• How will you scale it
• What decisions will you make

Because at the end, every system is just a pizza shop trying to serve more people without breaking.

If this helped you understand things better, I would love to know.

What should I break down next?