Chapter 01 — System Design Foundation | Topic 05
A feature can work perfectly and still create a poor system.
Sounds strange, right?
Let's take a simple example:
Customer should be able to place an order.
We can implement this feature successfully.
But is that enough?
What if the API takes 10 seconds to respond?
What if an unauthorized user can place an order?
What if the system crashes when thousands of customers place orders together?
The feature works.
But the system doesn't work well.
This is why we need to understand the difference between Functional Requirements and Non-Functional Requirements.

The Simple Difference
The easiest way to remember it is:
Functional Requirement
What should the system do?
Non-Functional Requirement
How should the system work?
Both are important for building a real-world application.
Let's Take One Feature
Consider an Order Management System.
One requirement is:
Customer should be able to place an order.
Now let's look at this requirement from two different views.
Functional View — What Should Happen?
From the functional perspective, we ask:
What should the system do when a customer places an order?
For example:
Customer selects products
Customer submits the order
System validates the order
System creates the order
Order details are stored
Customer receives confirmation
These describe the actual behavior and functionality of the system.
So we can create an API such as:
POST /api/ordersThe API may receive:
{
"customerId": 101,
"productId": 25,
"quantity": 2
}The requirement is about the feature:
Customer can place an order.
Non-Functional View — How Should It Work?
Now ask different questions.
Performance
How quickly should the order API respond?
For example:
95% of requests should respond within an acceptable response time.
Security
Who is allowed to place an order?
For example:
Only authenticated customers can place orders.
Scalability
What happens when the number of customers increases?
For example:
The system should support significantly higher traffic during peak periods.
Availability
What happens if one application instance fails?
For example:
The application should remain available with minimal interruption.
These are not new features.
They describe how well the feature should work.
Same Feature, Two Views
Let's put everything together.
Feature: Place an Order
Functional Requirements
Customer can place an order
System validates order details
System creates the order
System stores order information
Customer receives confirmation
Non-Functional Requirements
API should respond quickly
Only authorized users can place orders
System should handle increased traffic
Order data should be secure
System should remain available
Notice something important:
The feature is the same.
Only the perspective is different.
Why Does This Matter for System Design?
Suppose the functional requirement is:
Customer can place an order.
If we only think about functionality, we may create:
Controller
↓
Service
↓
DatabaseAnd the feature may work.
But now suppose the business says:

Join the conversation! Your thoughts help the community grow.