
Many system design interviews go wrong before the first architecture box is drawn. A candidate starts naming Kafka, Redis, and microservices before confirming whether the product needs a timeline, a durable payment, a low-latency read, or all three. The result is a complicated design with no clear reason for its components.
Functional requirements describe what the system must do. Non-functional requirements describe how well it must do it and under which constraints. This guide turns that distinction into a practical interview method, with measurable examples and a worked e-commerce flow. It builds on the Backend Interview Mastery guide, the system design interview cheatsheet, and the broader System Design hub.
Table of Contents
Open Table of Contents
- The Fast Difference: What vs How Well
- How to Gather Requirements in an Interview
- Functional Requirements: Define the User-Visible Work
- Non-Functional Requirements: Make Quality Measurable
- Worked Example: An E-Commerce Platform
- Turn Requirements Into Architecture
- Common Trade-Offs and Traps
- Interview Questions
- 1. What is the simplest way to explain the difference?
- 2. Are consistency and availability always non-functional requirements?
- 3. How many requirements should you clarify in an interview?
- 4. How do requirements affect database choice?
- 5. What should you do when the interviewer gives no numbers?
- 6. How do you prioritize conflicting non-functional requirements?
- Conclusion
- References
- YouTube Videos
The Fast Difference: What vs How Well
Functional requirements are user or system actions: search products, add an item to a cart, create an order, or publish a notification. They establish the workflows, entities, and API contracts the design must support.
Non-functional requirements are measurable qualities and constraints: p95 read latency below 200 ms, 99.99% availability, no lost orders, support for ten million users, or a defined consistency model. They shape the architecture, storage choices, replication strategy, and operational controls.
| Requirement type | Example | What it drives |
|---|---|---|
| Functional | A buyer can reserve a product | Reservation API and inventory state |
| Functional | A buyer can view order history | Order query model and pagination |
| Non-functional | p95 browse latency under 200 ms | Cache, CDN, read projection |
| Non-functional | No overselling | Conditional write and reservation ledger |
| Non-functional | 99.99% browse availability | Replicas, failover, graceful degradation |
The categories are related, not competing. “Users can check out” is functional; “checkout never double-charges a retry” is a correctness constraint on that function. A strong candidate states both and then shows which design decision satisfies each one.
How to Gather Requirements in an Interview
Use the first five minutes to turn an ambiguous product sentence into a small, estimable contract.
1. Identify the actors and primary action
Ask who uses the system and what they are trying to accomplish. A “notification system” for one operator is different from a global push service. A “feed” for a small team has different ranking and fan-out requirements than a public social network.
2. Separate must-have scope from useful extras
Ask which workflows are required for the first version and what can be out of scope. This prevents the interview from becoming a product brainstorm and gives you a reason to reject architecture that does not serve the primary path.
3. Quantify the workload
Ask for total users, daily active users, read/write ratio, peak requests per second, object size, retention, and geography. If the interviewer does not provide numbers, state assumptions: “I’ll design for 10 million users, 100,000 peak reads per second, and a ten-times burst.”
4. Ask which quality matters most
Do not list every quality attribute as equally important. Ask whether the product prefers low latency, strong consistency, high availability, durability, or cost. An inventory reservation and a product recommendation can live in the same platform while needing different guarantees.
5. Confirm failure and compliance boundaries
Ask what happens when a dependency is down, whether offline behavior matters, and whether payments, personal data, audit trails, or regional residency are in scope. These answers can change the data model more than the choice between REST and GraphQL.
Functional Requirements: Define the User-Visible Work
Write functional requirements as observable actions, not implementation nouns. “Use Kafka” is not a function. “Publish an order event so fulfillment can begin after confirmation” is a function with a clear reason for messaging.
For an e-commerce platform, the functional list might be:
- A buyer searches and filters products.
- A buyer views a product, price, and availability estimate.
- A buyer adds an SKU and quantity to a cart.
- A buyer submits checkout and receives an order ID.
- The system reserves inventory and records payment status.
- A buyer views order status and shipment updates.
- A merchant updates catalog and inventory data.
Each function should map to a testable contract. For example, POST /v1/orders accepts a cart snapshot and idempotency key, returns one order ID, and never creates a second order when the client retries. That contract is more useful in an interview than a generic statement such as “the order service handles checkout.”
Non-Functional Requirements: Make Quality Measurable
Non-functional requirements become useful when they include a workload, a target, and a measurement boundary.
Latency and throughput
“Fast” is not a requirement. Say “product reads should meet 200 ms at p95” and “the system should sustain 100,000 product reads per second at peak.” Percentiles expose tail behavior that an average hides. Throughput estimates also reveal whether a single database, queue, or partition can handle the workload.
Availability and reliability
Availability describes whether a user can receive a successful response; reliability describes whether the system continues to produce correct outcomes over time. A catalog read may fall back to a stale projection during an outage. An order service should reject an uncertain write rather than return success without a durable record.
Durability and recovery
Durability asks whether committed data survives failures. State a recovery point and recovery time expectation when it matters: “accepted orders lose no committed writes, and a region failover restores reads within 15 minutes.” This drives replication, backups, and replayable events.
Consistency and freshness
Specify where stale data is acceptable. Search results can be five seconds behind a catalog change; inventory commits cannot use a stale count. If you name eventual consistency, explain the user-visible behavior and reconciliation path instead of treating it as a magic scalability switch.
Security and isolation
Requirements may include tenant isolation, encryption, authorization, auditability, rate limits, or data residency. Security is not only an implementation detail: “a seller can edit only its own catalog” changes every catalog API and query predicate.
Worked Example: An E-Commerce Platform
Start with a concise interview answer:
“The platform lets buyers discover products, manage a cart, place an order, and track fulfillment. I’ll assume 5 million daily active users, 100,000 peak browse reads per second, 1,000 checkout attempts per second, p95 browse latency under 200 ms, 99.99% browse availability, and no overselling or duplicate charges.”
Now trace each requirement to the design:
| Requirement | Target or invariant | Architectural consequence |
|---|---|---|
| Search products | 100,000 peak reads/sec | Search index, CDN, cache, cursor pagination |
| Add to cart | Durable buyer intent | Cart store with user-scoped authorization |
| Place order | One result per idempotency key | Order transaction and unique constraint |
| Reserve inventory | Never commit below zero | Conditional reservation transaction |
| Authorize payment | No duplicate provider charge | Payment intent and provider idempotency key |
| Track fulfillment | Eventual status is acceptable | Outbox, event bus, read projection |
| Browse during dependency failure | 99.99% availability | Graceful degradation for recommendations and reviews |
The e-commerce platform design expands this example into a full system. Notice how each component is justified by a requirement rather than added because it is fashionable.
Turn Requirements Into Architecture
Use a requirement-to-decision trace during the interview:
flowchart TD
A[User action] --> B[Functional contract]
B --> C[Invariant or quality target]
C --> D[Capacity estimate]
D --> E[Architecture choice]
E --> F[Failure and recovery plan]
F --> G[Metric or test]
G -. refine assumption .-> A
classDef step fill:#e3f2fd,stroke:#1565c0,stroke-width:2px,color:#000000;
classDef quality fill:#ede7f6,stroke:#4527a0,stroke-width:2px,color:#000000;
classDef verify fill:#e8f5e9,stroke:#1b5e20,stroke-width:2px,color:#000000;
class A,B,D,E step;
class C,F quality;
class G verify;
For example, a functional requirement to send password-reset email becomes a durable command, not a synchronous SMTP call, when the non-functional requirement says the login API must remain under 200 ms and email delivery can take seconds. The queue is justified by latency and retry behavior; the dead-letter queue is justified by recoverability.
Keep the first architecture small
Start with client, API, application service, primary database, and one asynchronous worker. Add a cache when the read target or database capacity requires it. Add a search index when query semantics require ranking and filtering. Add a broker when work can be retried or completed after the response. This progression makes your reasoning easy to follow and avoids premature microservices.
Common Trade-Offs and Traps
Trap 1: Treating every quality as a maximum
“Strong consistency, zero latency, infinite scale, and 100% availability” is not a design. Choose which guarantees matter for each operation and state what you sacrifice. A product page may prefer availability and freshness; an order commit prefers correctness and durability.
Trap 2: Confusing availability with reliability
A service that returns a fast but incorrect order is available in a narrow operational sense and unreliable in the way customers care about. Include correctness checks, reconciliation, and invariant-violation alerts in the reliability discussion.
Trap 3: Giving unmeasured numbers
Round numbers are acceptable assumptions; unexplained numbers are not. Show the calculation: 5 million daily users × 20 requests/day ÷ 86,400 seconds is about 1,160 average requests per second before peak multipliers. Then state how the peak assumption changes capacity.
Trap 4: Hiding scope inside implementation
“Microservices” does not define whether the system supports search, checkout, or order tracking. Keep functional scope explicit, then decide whether separate services are justified by ownership, load, or failure isolation.
Trap 5: Forgetting verification
Every important requirement should have a metric or test: p95 latency dashboards, queue age alerts, a uniqueness constraint for idempotency, a load test for peak traffic, and a recovery exercise for an unavailable dependency.
Interview Questions
1. What is the simplest way to explain the difference?
Functional requirements describe what users or systems can do, such as creating an order or searching a catalog. Non-functional requirements describe the conditions under which those actions must work, such as latency, availability, security, or durability. The first shapes APIs and workflows; the second shapes architecture and operations. Strong answers connect the two instead of reciting separate definitions.
2. Are consistency and availability always non-functional requirements?
They are usually quality constraints on a function, but the important point is their effect on behavior. “Show order status” may allow eventual consistency, while “reserve the last item” needs a stronger invariant. State the operation, the failure scenario, and what the user should see when the system cannot satisfy both goals.
3. How many requirements should you clarify in an interview?
Ask enough to establish the actors, core workflows, scale, latency, availability, consistency, and out-of-scope features. Five to ten focused questions are usually more useful than a long questionnaire. Stop once the answers let you draw a minimal design and explain the most important trade-off.
4. How do requirements affect database choice?
Data shape and correctness requirements come first. A relational database is a strong default when orders, money, and constraints need transactions; a document or key-value store may fit flexible catalog data or high-volume sessions; a search index fits ranking and filtering. Explain the access pattern and failure behavior instead of choosing a database by brand.
5. What should you do when the interviewer gives no numbers?
State explicit assumptions and invite correction: “I’ll assume 10 million users, a 10:1 read/write ratio, 100,000 peak reads per second, and a 10-times burst.” Use those values for capacity math, then show which conclusions change if the interviewer increases them. Assumptions are useful because they make the design falsifiable.
6. How do you prioritize conflicting non-functional requirements?
Tie the priority to business risk. Payment correctness and durability outrank a few milliseconds of latency; recommendations can be stale or unavailable while checkout continues. State the chosen priority, the user-visible fallback, and the operational signal that tells the team when the trade-off is no longer acceptable.
Conclusion
- Functional requirements define user-visible actions and API contracts.
- Non-functional requirements make quality, scale, and failure behavior measurable.
- Clarifying questions should establish actors, scope, workload, guarantees, and failure boundaries.
- Every major component should trace back to a requirement and forward to a metric or test.
- Strong interviews start small, add complexity only when a target requires it, and name trade-offs clearly.
Use this framework before practicing the e-commerce platform system design. For a closely related foundation, review what scalability means and rewrite its definition as measurable interview targets.
References
- Functional Requirements System Design - System Design Handbook - https://www.systemdesignhandbook.com/blog/functional-requirements-system-design/
- Non-Functional Requirements in System Design Interviews - Educative - https://www.educative.io/courses/grokking-the-system-design-interview/non-functional-requirements-for-system-design-interviews
- Google SRE - Service Level Objectives - https://sre.google/sre-book/service-level-objectives/
YouTube Videos
- “Functional vs Non Functional Requirements - System Design Interview” - https://www.youtube.com/watch?v=gerIf2DYQ0I
- “Functional vs Non-Functional Requirements | System Design Basics” - https://www.youtube.com/watch?v=ggjiiGmez04