Himanshu Bhatt

Posted on Jan 11

Level 1 - Foundations #1. Client-Server Model

#systemdesign #distributedsystems #tutorial #beginners

👋 Short Intro (Why I’m Writing This)

I’m currently learning System Design and decided to learn in public by documenting my journey.

This blog is part of my System Design 101 series, where I’m learning System Design step by step from scratch.

This series is not written by an expert — it’s a beginner learning out loud, sharing:

what I understand,
what confuses me,
and what I learn along the way.

The goal is to build consistency, clarity, and invite discussion.

📌 What This Blog Covers

In this post, I’ll cover:

What the Client–Server model is
Who acts as a client and who acts as a server
How request–response communication works
What is inside an HTTP request and response
Stateless vs stateful servers (with intuition)
Single-server vs multi-server architectures

📂 GitHub Repository

All my notes, examples, and practice code live here:

👉 GitHub Repo:

https://github.com/dmz-v-x/system-design-101

This repo is updated as I continue learning.

📚 Learning Notes

1. What is the Client-Server Model?

The simplest definition is that we have two machines one act as a client and other act as a server.

Client: A Client requests something
Server: A Server responds with something.

That's the core of Client-Server Model.

2. A Slightly better definition

The Client-Server model is an architectural pattern where:

Client initiates requests
Server processes requests and return responses
They talk (communicate) over a network

Now let's get deeper into each component.

3. Who is the Client?

A Client is someone who initiates the request.

Examples of clients:

Browser (Chrome, Firefox)
Mobile App (Android / iOS)
CLI tools (curl, wget)
Another backend service (microservices)

⚠️ Important gotcha:

A Client is not always a browser
A backend can be a client to another backend

4. Who is the Server?

A server is a component that listens for clients requests, processes requests and sends back responses.

Examples of servers:

Web servers (Node.js, Django, Spring)
Database servers (Postgres, MongoDB)
File servers
Authentication servers

Gotcha:

“Server” is a role, not a machine
One machine can act as client + server at the same time

5. The request-response flow

Step by Step flow:

Client prepares a request
Client sends request over network
Server receives request
Server processes request
Server sends response
Client receives response

6. What exactly is inside a request?

A request usually contains:

Method (what do you want?)

GET, POST, PUT, PATCH, DELETE

Endpoint

/users

Headers

Auth token, content-type

Body (optional)

Data you're sending

Example (HTTP request)

GET /users/123
Authorization: Bearer xyz

7. What exactly is inside a response?

A response contains:

Status Code

200 OK
404 Not Found
500 Server Error

Headers

Body

JSON, HTML, binary data

Example (HTTP Response)

200 OK
{
  "id": 123,
  "name": "Alice"
}

8. Stateless vs Stateful Servers

Stateless Server

Does not remember past requests
Every request is independent of past requests.
Server forgets everything between requests
Easy to scale
Used in modern systems

Client → Request A → Server
Client → Request B → Server

Stateful Server

Server remembers client data
Sessions stored in memory
Hard to scale

9. Single-server vs Multi-server

Single Server (early stage)

For early stage of our product.
Single point of failure.
Limited Scaling can be done.

Multi-server (real world)

In real world we have multiple servers
We have a load balancer that distributes loads across different servers

10. A Real-World Example (Putting It All Together)

When you open Instagram and refresh your feed:

Your mobile app (client) sends a request to Instagram servers
The request goes through a load balancer
One backend server processes the request
The server fetches data from the database
The server sends the response back
Your app renders the feed on screen

11. Why the Client–Server Model Matters in System Design

Almost every system design discussion starts with:

Who is the client?
Who is the server?
How do they communicate?
Where does state live?

Understanding this model is the foundation for:

APIs
Load balancing
Scalability
Microservices
Caching

✅ Key Learnings & Takeaways

Foundations of Client-Server Model.
How communication between client and server happens through a request response cycle.
How load balancers & multiple backend servers work together.
Basics of Stateless & Stateful servers.

If you faced any issues or have any questions, do let me know in the comments 🙂

💬 Feedback & Discussion

💡 I’d love your feedback!

If you notice:

something incorrect,
a better explanation,
or have suggestions to improve my understanding,

please comment below. I’m happy to learn and correct mistakes.

⭐ Support the Learning Journey

If you find these notes useful:

⭐ Consider giving the GitHub repo a star —

it really motivates me to keep learning and sharing publicly.

🐦 Stay Updated (Twitter / X)

I share learning updates, notes, and progress regularly.

👉 Follow me on Twitter/X:

https://x.com/_himanshubhatt1

🔜 What’s Next

In the next post, I’ll be covering:

👉 OSI model/TCP/IP fundamentals

I’ll also continue updating the GitHub repo as I progress.

🙌 Final Thoughts

Thanks for reading!

If you’re also learning System Design, feel free to:

follow along,
share your experience,
or drop questions in the comments 👋

📘 Learning in public

📂 Repo: https://github.com/dmz-v-x/system-design-101
🐦 Twitter/X: https://x.com/_himanshubhatt1
💬 Feedback welcome — please comment if anything feels off
⭐ Star the repo if you find it useful

DEV Community