Phase 01 — System Design Foundation | Topic 04
Imagine your Order Management System works perfectly.
Customers can place orders.
Admins can update orders.
Order history works.
But there is one problem.
The API takes 10 seconds to respond.
Would you call the system successful?
Probably not.
This is where Non-Functional Requirements become important.
Functional Requirements tell us:
What should the system do?
Non-Functional Requirements tell us:
How should the system work?

What Are Non-Functional Requirements?
Non-Functional Requirements describe the quality, performance, security, reliability, and operational behavior of a system.
For example:
How fast should the application respond?
How many users should it support?
How available should it be?
How secure should it be?
What should happen when traffic increases?
How should the system behave when something fails?
These requirements may not represent a specific feature, but they strongly influence our architecture and technical decisions.
Let's Take a Real Example
Suppose the requirement says:
“Build an Order Management System for customers and administrators.”
From our previous topic, we identified functional requirements such as:
Customer can place an order
Customer can view order history
Admin can view orders
Admin can update order status
Now let's add Non-Functional Requirements:
⚡ Performance
Order APIs should normally respond within an acceptable response time.
🟢 Availability
The application should remain available even when individual components experience problems.
🔐 Security
Only authorized users should be able to access customer and administrative operations.
📈 Scalability
The system should continue supporting users as traffic grows.
Now our system requirements are much more complete.
⚡ 1. Performance — How Fast Should It Be?
Performance is about how quickly the system responds.
Consider this:
User → API → Database → ResponseIf the database query takes too long, the entire API becomes slow.
For example, this query could become a problem when the Orders table becomes very large:
var orders = await _context.Orders
.ToListAsync();Why?
Because you're potentially loading every order into memory.
Instead, pagination may be more appropriate:
var orders = await _context.Orders
.AsNoTracking()
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync();The goal isn't simply:
“Make the code faster.”
The real question is:
“What performance does the business require?”
That requirement influences database queries, indexes, caching, pagination, API design, and architecture.
🟢 2. Availability — Should the System Always Be Accessible?
Imagine customers are trying to place orders, but your application is unavailable.
Even if all your features are perfectly implemented, the system isn't useful at that moment.
Availability asks:
How often should the system be available?
For example:
“The application should be available 99.9% of the time.”
Availability requirements can influence decisions such as:
Multiple application instances
Load balancing
Health checks
Database availability
Monitoring
Automatic recovery
This is why availability is not just an infrastructure concern.
It starts with a business requirement.
🔐 3. Security — Who Can Do What?
Security requirements define how the system should protect users, data, and operations.
For our Order Management System:
A customer should be able to see their own orders.
An admin may be allowed to see all orders.
A customer should not be able to call an admin-only operation.
ASP.NET Core provides built-in mechanisms for this.
For example:
[Authorize]
[HttpGet("my-orders")]
public IActionResult GetMyOrders()
{
return Ok();
}
[Authorize(Roles = "Admin")]
[HttpPut("{id}/status")]
public IActionResult UpdateOrderStatus(
int id,
UpdateStatusRequest request)
{
return Ok();
}Here:

Join the conversation! Your thoughts help the community grow.