Phase 01 — System Design Fundamentals | Topic 09
Imagine two applications that receive exactly 500,000 requests every day.
At first glance, they appear to have the same traffic.
But there is an important difference.
The first application receives mostly requests to read data.
The second application receives mostly requests that create or update data.
Should we design both systems in the same way?
No.
The ratio between read and write traffic can significantly influence database design, caching, scaling, consistency, and the overall architecture.

What Is Read Traffic?
Read traffic consists of requests that retrieve existing information without changing the stored data.
For example, an e-commerce application may receive requests such as:
GET /api/products
GET /api/products/25
GET /api/orders/1001
GET /api/categoriesThese operations are primarily reading information from the system.
When a user opens a product page, checks an order, or views a list of products, the application is generating read traffic.
What Is Write Traffic?
Write traffic consists of requests that create, update, or delete information.
For example:
POST /api/orders
PUT /api/orders/1001
DELETE /api/cart/25These operations modify data.
When a customer places an order, the application may need to create an order, update inventory, store payment information, and update other related data.
Write operations therefore require more careful handling of data consistency and concurrency.
Every System Has Both
Most real-world applications have both read and write traffic.
The important question is:
What is the ratio between them?
For example, imagine an application receives:
500,000 requests per day
If:
80% are reads
and:
20% are writes
then the application receives:
400,000 read requests
and:
100,000 write requests
That makes the workload relatively read-heavy.
Now imagine another application with:
20% reads
and:
80% writes
That application has a very different workload.
The total traffic is the same, but the architecture may need to be different.
What Is a Read-Heavy System?
A read-heavy system receives significantly more read requests than write requests.
Consider an e-commerce application.
A customer may:
Browse many products.
Open product details.
Check categories.
Search for products.
View reviews.
But that same customer may place only one or two orders during a session.
Therefore, the system may receive many more read operations than write operations.
Other examples can include:
Content platforms.
News websites.
Product catalog systems.
Reporting applications.
Documentation platforms.
Social media feeds.
In these systems, improving read performance can have a significant impact.
How Can We Handle Read-Heavy Traffic?
One common technique is caching.
Suppose thousands of users repeatedly request the same product information.
Without caching, every request may go to the database.
Users
↓
ASP.NET Core API
↓
SQL ServerWith caching, frequently requested information can be served from a cache.
Users
↓
ASP.NET Core API
↓
Cache
↓
SQL ServerFor example, Redis can be used as a distributed cache in a multi-server ASP.NET Core application.
The goal is to reduce unnecessary database reads and improve response time.
Read Replicas
Another technique that can help larger read-heavy systems is using read replicas.
The basic idea is that read operations can be distributed to additional database instances while writes continue through the primary database.
Conceptually:
┌── Read Replica
│
Application ─────┼── Read Replica
│
└── Primary Database
↑
WritesThis can reduce the pressure on the primary database when the application has a large amount of read traffic.
The exact implementation depends on the database technology and consistency requirements.
What Is a Write-Heavy System?
A write-heavy system receives a large proportion of requests that create or modify data.
Examples include:
Payment processing systems.
Booking systems.
Transaction systems.
Inventory systems.
High-frequency data collection systems.
Certain real-time applications.
For example, consider an inventory system during a major sale.
Thousands of customers may attempt to purchase products at the same time.
The application may need to update stock quantities while ensuring that the same inventory is not incorrectly sold to multiple customers.
This makes write performance, concurrency, and consistency extremely important.
Why Are Writes Different?
A read operation can often retrieve existing data without changing anything.
A write operation may need to:
Validate business rules.
Modify existing records.
Create new records.
Maintain relationships.
Execute a transaction.
Handle concurrent requests.
Maintain data consistency.
For example, when placing an order, the application may need to update inventory.
If two customers try to purchase the last available product simultaneously, the system must carefully handle the concurrent writes.
Otherwise, the database could end up with an incorrect inventory value.
Caching Is Not the Same Solution for Everything
Caching is extremely useful for read-heavy workloads.
However, it does not solve every write-related problem.
Imagine an inventory system where the latest stock quantity is critical.
If the cache contains outdated inventory information, the application could make an incorrect decision.
Write-heavy systems therefore require more attention to:

Join the conversation! Your thoughts help the community grow.