Requirements
Functional vs Non-Functional Requirements, Explained With Paired Examples
Part of our guide to business analyst skills.
Functional and non-functional requirements in plain English
A functional requirement describes a behaviour: something the system does when a user or another system asks it to. It has a clear trigger and a clear result. 'The customer can download an invoice as a PDF' is functional. You can test it with a simple yes or no: did the invoice download?
A non-functional requirement (often shortened to NFR) describes a quality of that behaviour. It says how fast, how secure, how reliable, how easy to use or how large the system must be. 'The invoice downloads within 3 seconds' is non-functional. The download already exists. The NFR sets the standard it must meet.
A simple memory trick: functional requirements are the verbs of the system (search, pay, export, approve). Non-functional requirements are the adverbs and adjectives (quickly, securely, always, accessibly). Remove a functional requirement and a feature disappears. Remove a non-functional requirement and the feature still exists, but it may be too slow, unsafe or hard to use.
Common NFR categories are performance, availability, reliability, scalability, security, usability, accessibility, maintainability and recovery. The glossary entry on non-functional requirements gives a short definition of each.
Paired examples: one feature, two kinds of requirement
The easiest way to see the difference is to keep the feature the same and change only the question. The functional line answers 'what does it do?'. The non-functional line answers 'how well must it do it?'.
Functional vs non-functional at a glance
| Aspect | Functional requirement | Non-functional requirement |
|---|---|---|
| Question it answers | What must the system do? | How well must the system do it? |
| Typical wording | The user can..., the system sends... | Within N seconds, for N users at once, only role X can... |
| Example: password reset | The user can reset the password using an emailed link | The reset link expires after 15 minutes and works only once |
| Usually raised by | End users, process owners, product owner | Operations, IT security, compliance and support teams |
| How it is tested | Functional test: does the behaviour happen, yes or no? | Measured test: load, security, accessibility or monitoring against a target |
| If it is missing | A feature or process step does not exist | The feature exists but is too slow, unsafe or hard to use |
| Where it lives | BRD feature section, or user stories in the backlog | BRD NFR table, acceptance criteria or Definition of Done |
- Search. Functional: the customer can search products by name or brand. Non-functional (performance): results appear within 2 seconds for 19 of every 20 searches.
- Login. Functional: the user can sign in with a mobile number and a one-time password. Non-functional (security): the account locks for 30 minutes after 5 wrong codes in a row.
- Report export. Functional: a manager can export the monthly sales report as a CSV file. Non-functional (performance): an export of up to 100,000 rows finishes within 1 minute.
- Loan application form. Functional: the applicant can save a draft and return later. Non-functional (accessibility): every field can be reached and completed using only a keyboard, and every field has a visible label.
- Order notifications. Functional: the system sends an SMS when an order is dispatched. Non-functional (scalability): on sale days, each SMS still goes out within 5 minutes of dispatch.
- Customer records. Functional: an agent can update a customer address. Non-functional (auditability): every change is logged with who, when, the old value and the new value.
- Database restore. Functional: an administrator can restore the orders database from a backup. Non-functional (recovery): after a failure, service is back within 4 hours and at most 1 hour of data is lost.
Notice that every non-functional line has a number, a condition or a clear rule that someone can check. That is deliberate, and it is the subject of the next section.
How to make non-functional requirements measurable
Stakeholders rarely hand you a measurable NFR. They say 'it must be fast', 'it must be secure' or 'it must be easy'. Those words describe real needs, but nobody can build or test against them. Your job is to turn the adjective into something a tester can pass or fail.
Give every NFR four parts:
- Metric: what you measure, such as response time, number of users, or steps to finish a task.
- Target: the level that counts as good enough, such as 'at most 2 seconds'.
- Condition: when and under what load the target applies, such as 'during the evening peak with 300 users at once'.
- Verification: how and by whom it will be proven, such as a load test, a usability session or a security review.
TEXT
NFR-ID : NFR-07
Category : Performance
Metric : Time from tapping Search to results shown
Target : At most 2 seconds for 19 of every 20 searches
Condition : Catalogue of 50,000 products, 300 users searching at once
Verified : Load test in the test environment before each release
Owner : Operations lead (target), QA tester (test)If a stakeholder cannot name a target, offer two extremes and ask which one hurts. 'Would 10 seconds be a problem? Would 1 second be worth extra cost?' Honest answers usually appear quickly. Also check whether a target already comes from a contract, a service level agreement or a regulation. In regulated areas such as payments, health or personal data, rules vary, so confirm with your compliance team and the official source.
Vague words and what to write instead
- Fast becomes 'within 2 seconds for 19 of every 20 requests at peak load'.
- Secure becomes specific rules: who can see what, how passwords are stored, when a session ends.
- User-friendly becomes 'a first-time user completes the task in at most 4 steps without help', checked in usability testing.
- Scalable becomes 'handles 3 times today's peak orders with the same response time'.
- Always available becomes an agreed availability target per month, with planned maintenance windows stated.
Where each type lives in a BRD or a backlog
In a BRD or requirements document
In a traditional document, functional requirements sit in their own section, grouped by feature or process step, each with an ID such as FR-01. Non-functional requirements get a separate section, usually a table with columns for ID, category, requirement, measure and verification method. Some teams keep high-level needs in the BRD and move detailed requirements into an FRD or SRS. The BRD vs FRD vs SRS guide explains that split.
In an agile backlog
Functional requirements become user stories or backlog items, usually grouped under an epic. If you are new to this, read how to write user stories. Non-functional requirements go to one of three places, depending on how far they reach:
- Acceptance criteria on a story, when the NFR applies to one feature only, such as search results within 2 seconds. Gherkin acceptance criteria work well for this.
- The Definition of Done, when the NFR applies to every story, such as every new screen passing the agreed accessibility checks.
- A separate NFR item or constraint, when meeting it needs its own work, such as setting up monitoring or building a load test.
Whichever place you choose, link the NFR to the stories it affects and list it in your traceability matrix. That way it gets tested in UAT instead of being forgotten.
How to write functional and non-functional requirements, step by step
Writing both types well is one of the core business analyst skills, and a simple routine makes it easier. Follow these steps for each feature.
- Start with the user goal. Write what the user needs to achieve and the behaviour that supports it. This is your functional requirement.
- Ask the quality questions for that feature. How fast? How many users at once? Who must not see this? What happens if it fails? Who might struggle to use it?
- Name the category of each answer: performance, security, availability, usability, accessibility, scalability or recovery. One category per requirement stops you mixing ideas.
- Turn adjectives into numbers or rules using metric, target, condition and verification.
- Check feasibility with the team. Ask the lead developer and the tester whether the target can be built and measured, and what it costs. Adjust with the stakeholder if needed.
- Place each requirement in the right part of your BRD or backlog and give it an ID.
- Trace and confirm. Link NFRs to the stories they affect, add them to the traceability matrix and get sign-off on the targets.
Worked example: checkout at Saffron Basket
Saffron Basket is a fictional grocery delivery app. The team is redesigning checkout because customers say it feels slow and sometimes fails in the evening. Nadia, the business analyst, and you, the BA learner, meet Sunil, the operations lead, to turn complaints into requirements.
The functional side is quick to agree. Customers must be able to pay by UPI or card (FR-01), and they must get an SMS confirmation after payment succeeds (FR-02). The hard part is Sunil's word 'fast'.
Turning 'fast' into a target
Saffron Basket, a fictional grocery delivery app, is redesigning checkout, and Nadia and you meet Sunil to review the draft requirements.
- Sunil Operations lead
The new checkout must be fast. Customers give up when it hangs, especially in the evening rush.
- Nadia Business analyst
Agreed. Which step feels slow today, and how busy is the evening rush?
- Sunil Operations lead
The wait after payment, before the confirmation page. Between 6 pm and 9 pm we can have around 500 people checking out at the same time.
- You The BA learner
So could we say: the confirmation page loads within 3 seconds for 95% of payments, measured with 500 customers checking out at once?
- Sunil Operations lead
Yes. A few slow payments are acceptable. Most must be quick.
- Nadia Business analyst
Good. I will ask Mei to confirm the test tool can simulate 500 users, and we will add the target as an acceptance criterion on the payment story.
The people and the company in this scene are fictional.
From that conversation the team writes the requirement set below. Each NFR now has a metric, a target, a condition and a way to verify it.
Saffron Basket checkout requirements
Checkout: requirement set v1
FR-01 The customer can pay for an order by UPI or by card.1
FR-02 The system sends an SMS confirmation after payment succeeds.
NFR-01 Performance: the confirmation page loads within 3 seconds for 95% of payments.2
Condition: measured from 6 pm to 9 pm, with 500 customers checking out at once.3
NFR-02 Availability: checkout is available 99.5% of each calendar month.4
NFR-03 Security: full card numbers are never stored in Saffron Basket systems.5
Verified by: load test (NFR-01), uptime monitoring (NFR-02), security review (NFR-03).6
- Functional: a behaviour. FR-01 describes what the system does. A tester checks it with a yes or no: can the customer pay by UPI, and can the customer pay by card?
- Metric and target. The metric is page load time after payment. The target is 3 seconds for 95% of payments, which allows a few slow cases, as Sunil agreed.
- Condition. Without the peak window and the 500-customer load, the target could pass on a quiet morning and still fail every evening.
- Availability target. 99.5% of a 30-day month allows about 3.6 hours of downtime. Higher targets usually cost more, so the sponsor should approve the level.
- Security as a checkable rule. A clear rule replaces the vague word secure. Payment rules vary by provider and regulator, so the team confirms details with the payment provider and compliance.
- Verification. Each NFR names how it will be proven. This line makes the set testable in UAT and traceable after go-live.
Two quick calculations make the targets concrete. Availability of 99.5% over a 30-day month (720 hours) allows about 3.6 hours of downtime, because 0.5% of 720 is 3.6. For performance, in a test of 200 payments, 95% means at least 190 must load within 3 seconds, so at most 10 can be slower.
In the load test, 194 of the 200 payments load within 3 seconds, which is 97%. Only 6 are slower, below the limit of 10, so NFR-01 passes.
Placement follows the rules from earlier. FR-01 and FR-02 become user stories in the Checkout epic. NFR-01 becomes an acceptance criterion on the payment story. NFR-02 goes into the BRD's NFR table, because it covers the whole checkout and is checked by monitoring after go-live. NFR-03 goes into the Definition of Done for every story that touches payment data.
Common mistakes beginners make
- Accepting vague words. 'Fast' and 'easy' feel agreed in a meeting but cause arguments in UAT, because everyone pictured a different number.
- Leaving NFRs until the end. Performance and security can change the design. Discover them during elicitation, not the week before go-live.
- Writing a solution instead of a requirement. 'Use a caching server' is a design choice. The requirement is the response time; let the team choose how to meet it.
- Forgetting the condition. '2 seconds' means little without saying how many users, how much data and at what time of day.
- Calling business rules NFRs. A discount rule or an approval limit describes behaviour, so it is functional or a business rule, not a quality.
- Copying targets from another project. A target needs a reason and an owner in this project, or nobody will defend it when it gets hard.
Writing NFRs: good versus risky habits
Good habit
- State a metric, a target and the load or time window it applies to
- Agree who verifies each NFR and with which test or tool
- Link each NFR to the stories or features it affects
- Ask stakeholders which level of quality is good enough, and why
Risky habit
- Write 'the system should be fast and user-friendly' and move on
- Name a technology instead of the quality you actually need
- Keep NFRs in a document nobody opens during testing
- Promise perfect uptime or zero errors without discussing cost
Quick checklist before you share your requirements
Run through this list for each feature before you review it with developers and testers. If any line fails, fix it now. It is much cheaper than fixing it in UAT.
Requirement quality checklist
- Each feature has at least one functional requirement describing a clear behaviour
- You asked the quality questions: speed, load, security, availability, usability, recovery
- Every NFR has a metric, a target, a condition and a verification method
- No vague words remain, such as fast, secure, easy or always
- Requirements describe needs, not technology choices
- Every requirement has an ID and a home in the BRD or backlog
- NFRs are linked to stories and listed in the traceability matrix
- Stakeholders have agreed the targets and the trade-offs
Frequently asked questions
Is security a functional or a non-functional requirement?
It can be either. 'Users must sign in with a one-time password' is a behaviour, so it is functional. 'Passwords are stored only in hashed form' or 'a session ends after 15 minutes of inactivity' describe a quality or protection rule, so most teams list them as non-functional security requirements. What matters most is that each one is clear and testable.
Are business rules functional or non-functional requirements?
Business rules, such as 'orders above a set value get free delivery', describe what the system does, so teams treat them as functional or record them separately as business rules. They are not NFRs, because they do not describe a quality such as speed, security or availability.
Do non-functional requirements need their own user stories?
Not usually. Most NFRs work better as acceptance criteria on the stories they affect, or as items in the Definition of Done when they apply to every story. Create a separate backlog item only when meeting the NFR needs its own work, such as building a load test or setting up monitoring.
Who decides the target numbers for non-functional requirements?
Business stakeholders decide what level of quality is good enough. Developers, testers and operations advise on what is feasible and what it costs. The business analyst facilitates the conversation and records the agreed targets, and the sponsor approves trade-offs when a higher target needs more time or budget.
What is the difference between a constraint and a non-functional requirement?
A constraint limits how the solution can be built, for example it must use the existing CRM or run on the current cloud platform. A non-functional requirement describes a quality the solution must have, such as response time or availability. Some templates group them in one section, so label each clearly.
This article was written by an AI system and published automatically after automated accuracy, safety and quality checks. All companies, people and numbers in the examples are fictional. BA Mentorship does not issue professional certifications and cannot guarantee any job or interview outcome. Spot an error? Email our support team and we will check and correct it.