Chapter 2 · Requirements
Functional and Non-functional Requirements, and Acceptance Criteria
- Page 6 of 18
- 16 min read
After a week of interviews and observation, the ClinicQueue team has a long list of notes. Some say what the app must do: "patients book a slot", "the desk adds a walk-in". Others say how well it must do it: "fast", "easy for elderly patients", "safe with phone numbers". Both kinds matter, and both are useless to a tester until they are written so that someone can check them.
On the previous page, Requirements Engineering: Finding Out What to Build, you found the stakeholders and collected their needs. This page turns those needs into requirements that are clear, measurable and testable, and into acceptance criteria that Nadia and Kwame can both use to decide whether a feature is done.
What you will learn
- The difference between functional and non-functional requirements, with ClinicQueue examples.
- How to use the nine quality characteristics of ISO/IEC 25010:2023 as a checklist for non-functional needs.
- How to turn vague words such as "fast" into measurable, testable requirements in the "shall" style.
- How to write acceptance criteria, including the Given/When/Then format.
- How to record constraints and assumptions, and a checklist for finding ambiguity.
Functional and non-functional requirements
A functional requirement describes something the system does: a behaviour, a calculation, a response to an input. A non-functional requirement describes a quality of the system: how fast, how secure, how easy to use, how reliable. A short way to remember: functional is what it does, non-functional is how well it does it.
| Functional (what it does) | Non-functional (how well) |
|---|---|
| A patient can see the free slots for the next 14 days. | The free-slots page loads within 3 seconds on a slow mobile connection. |
| The system sends an SMS reminder the day before each visit. | Reminders are sent between 18:00 and 19:00 clinic time, even when 300 are due. |
| The receptionist can add a walk-in patient to today's queue. | Rina can add a walk-in in under 30 seconds after a 10-minute introduction. |
| Only signed-in staff can see patients' phone numbers. | Phone numbers are stored encrypted; staff sessions end after 15 minutes idle. |
| A patient can cancel a booking. | The booking service is available 07:00-21:00 every day, except a planned weekly maintenance hour. |
All numbers here are invented for ClinicQueue; your project needs its own, agreed with its stakeholders.
Why non-functional requirements get forgotten
Customers talk about features, because features are what they can picture. Nobody says "and it must still work when 300 reminders go out at once" until it fails. Non-functional requirements also tend to cut across many features: speed or security is not one screen. That is why teams use a checklist rather than waiting for people to mention them.
Some requirements sit on the border. "Only staff can see phone numbers" is a behaviour (functional) and also a security quality (non-functional). Teams label such cases differently, and that is fine. What matters is that the requirement is written down and tested, not which column it sits in.
A quality checklist: ISO/IEC 25010:2023
ISO/IEC 25010 is the international standard that defines a product quality model: a list of the characteristics that make up software quality. The current edition is ISO/IEC 25010:2023, published in November 2023, and it has nine characteristics. You can walk through them one by one and ask "what does this mean for our product?"
| Characteristic | Plain meaning | ClinicQueue example |
|---|---|---|
| Functional suitability | It does the right things, completely and correctly | A booked slot is never offered to a second patient |
| Performance efficiency | Speed and use of resources under load | The queue screen updates within 5 seconds of a new booking |
| Compatibility | Works with other systems and alongside them | Exchanges data correctly with the clinic's SMS company, and runs alongside the other software on the desk computer |
| Interaction capability | People can learn and use it, including people with different abilities | An elderly patient can book without help; text is readable on a small screen |
| Reliability | Keeps working, and recovers from faults | If an SMS fails, it is retried and the desk is told |
| Security | Protects data and allows only the right access | Patients' phone numbers are visible only to signed-in staff |
| Maintainability | Easy to understand, change and test | A new opening day can be added without changing code |
| Flexibility | Can be adapted to new environments or uses | Can be set up for a second clinic with different hours |
| Safety | Does not lead to harm to people or the environment | An AI-drafted reminder never goes out without a person checking it |
Older books and courses use the 2011 edition, which had eight characteristics and used the names usability and portability where 2023 says interaction capability and flexibility; safety was added in 2023. If you meet the old names, you now know what they map to.
Using the checklist
The checklist is a prompt for questions, not a form to fill in. For each characteristic, the team decides one of three things: "we need a requirement", "not important for this release", or "we must ask someone". For ClinicQueue release 1, Lena's team writes requirements for performance, interaction capability, reliability and security, notes that flexibility (a second clinic) is out of scope for now, and asks Nadia about safety when the AI reminder feature arrives. Recording "not important" is itself useful: it shows the question was asked.
Writing testable requirements
A requirement is testable when someone can design a check with a clear pass or fail. Words like "fast", "easy" and "secure" are not testable: everyone agrees with them, and everyone means something different. The fix is to name a measure, a target and the conditions.
| Vague | Testable |
|---|---|
| The booking page shall be fast. | The free-slots page shall load within 3 seconds for 95% of requests on a 3G-class mobile connection. |
| Booking shall be easy. | In a test with 5 patients aged over 60 who have never seen the app, at least 4 shall book a slot without help within 3 minutes. |
| Reminders shall be sent in good time. | The system shall send each SMS reminder between 18:00 and 19:00 clinic time on the day before the visit. |
| The system shall be reliable. | If sending an SMS fails, the system shall retry once after 10 minutes and then list the failure on the desk screen. |
| Patient data shall be secure. | Phone numbers shall be visible only to signed-in staff; a patient shall see only their own bookings. |
One of the answers on What Software Engineering Is, and Why Coding Is Not Enough used "the queue screen updates within 5 seconds of a new booking" as an example of quantifiable. Now you can see why that matters: Kwame can book a slot, start a timer, and get a clear yes or no.
The "shall" style
Many requirement documents follow a simple convention. It is good practice rather than a rule from one standard, and teams that use "must" instead are fine as long as they are consistent.
- shall = mandatory; should = wanted but negotiable; may = allowed, optional.
- One requirement per statement. "The system shall send reminders and log failures" is two requirements; split it so each can pass or fail alone.
- Name the actor. "The receptionist shall be able to…" or "The system shall…", not "Walk-ins shall be added" (by whom?).
- State what, not how. "Shall store phone numbers encrypted" is a requirement; "shall use library X" is usually a design decision, unless it is a real constraint.
Template:
ID: REQ-nn
Statement: The <actor or system> shall <behaviour or quality> <measure and conditions>.
Type: functional | non-functional (ISO/IEC 25010 characteristic)
Rationale: why it is needed (the stakeholder need behind it)
Source: who asked, and where it was agreed
Priority: (decided with the backlog, see User Stories, Use Cases and Prioritising)
Check: how it will be tested or demonstratedExample:
ID: REQ-09
Statement: The system shall send an SMS reminder to the booking's phone number between
18:00 and 19:00 clinic time on the day before the visit.
Type: functional (the time window is a business rule agreed with Rina and Nadia)
Rationale: fewer missed visits; no messages late in the evening (Rina, Nadia)
Source: interview with Nadia; workshop on reminders, 2026-10-09
Check: test T-11: book for tomorrow, set the test clock to 18:00, confirm one SMS
with the right date, time and doctor; test T-12: no SMS for a cancelled bookingAcceptance criteria and Given/When/Then
Acceptance criteria are the conditions one specific feature or story must meet for the customer to accept it. They are agreed before the work starts, so the developer knows what to build and the tester knows what to check. They are different from a Definition of Done, which you met on Agile, Scrum and Kanban as the commitment of the Increment: the Definition of Done applies to every piece of work ("reviewed, tested, deployed to the test server"), while acceptance criteria belong to one item.
A popular format comes from Dan North's article "Introducing BDD" (2006): "Given some initial context (the givens), When an event occurs, Then ensure some outcomes." Each scenario describes one situation with concrete data.
Example:
Feature: Patient books a slot
Scenario: Booking a free slot
Given Dr. Rahman has a free slot on 2026-11-02 at 10:00
When a patient books that slot with the test phone number 000-111-2222
Then the slot is shown as taken
And the patient sees a confirmation with the date, time and doctor
Scenario: Slot taken a moment earlier
Given the 10:00 slot on 2026-11-02 was booked by another patient a second ago
When a second patient tries to book the same slot
Then the booking is refused with the message "This time was just taken"
And the patient is shown the next three free slots
Scenario: Date in the past
Given today is 2026-11-02
When a patient tries to book 2026-11-01 at 10:00
Then the booking is refused and no slot changesThe second scenario is the one Kwame cares about most: a double booking is exactly the problem the paper diary had. Writing it down before coding means Farhan designs for it instead of discovering it in testing.
What good acceptance criteria look like
- Concrete: real-looking dates, times and data, not "some slot".
- One behaviour per scenario, so a failure points to one cause.
- Unhappy paths too: taken slots, past dates, failed SMS, not only the case where everything works.
- Agreed with the customer: Nadia reads them and says "yes, that is what I mean".
- About behaviour, not screens: "the patient sees a confirmation", not "a green box appears top right", unless the design really matters.
Constraints, assumptions and ambiguity
A constraint is a fixed limit the team cannot change: a budget, a deadline, a law, a system it must work with. An assumption is something the team believes is true but has not checked. Constraints limit your choices; assumptions are risks in disguise, because if one is wrong, work built on it may be wasted.
| Type | ClinicQueue item | Owner and check |
|---|---|---|
| Constraint | Must use the SMS company chosen in the feasibility check | Fixed by Nadia's contract |
| Constraint | Must run in the browser on the desk's existing computer | Omar checks the browser version |
| Constraint | Patient data must follow the data protection rules where the clinic operates | Nadia, with a qualified adviser |
| Assumption | Almost all patients have a phone that receives SMS | Patient questionnaire, by 2026-10-20 |
| Assumption | The clinic's internet works from 07:00 every day | Rina notes outages for two weeks |
| Assumption | Patients can read the reminder in Bangla or English | Nadia asks five patients |
Give every assumption an owner and a date by which it will be checked. An assumption that is never checked quietly becomes a requirement nobody agreed to.
An ambiguity checklist
Before a requirement is accepted, read it and look for these warning signs.
| Warning sign | Example | Ask |
|---|---|---|
| Vague quality words | fast, easy, user-friendly, modern, secure | Measured how? What target? |
| Vague amounts and times | several, many, soon, in good time, usually | What number? Which time? |
| "and/or", or two actions joined | "send and log reminders" | Is this one requirement or two? |
| Missing actor (passive voice) | "Walk-ins are added to the queue" | By whom: Rina or the system? |
| Unclear words like "it", "they", "this" | "When the doctor updates the queue, it is sent" | What is sent: the queue or a message? |
| "All", "every", "never" with no limit | "Support all phones" | Which phones, in practice? |
| Open ends | "etc.", "and so on", "to be decided" | What exactly is in the list, and who decides by when? |
Example:
Before: The system should quickly notify patients etc. when the doctor is late.
Problems: "should" (mandatory or not?), "quickly" (how fast?), "etc." (who else?),
"late" (how late?), "notify" (how: SMS, screen?).
After: REQ-14 When a doctor marks a delay of 15 minutes or more, the system shall send
an SMS within 2 minutes to every patient booked with that doctor in the next
2 hours, giving the new expected time.Where this shows up at work
- Contracts and tenders often list non-functional requirements (availability, response time, data protection) that decide whether a delivery is accepted and paid.
- Testers write test cases directly from acceptance criteria; Given/When/Then scenarios can also be automated as tests.
- Performance and security problems found after launch are often missing non-functional requirements, not coding mistakes.
- AI features need quality requirements too: what the output must never contain, and who checks it before use.
Common mistakes
- Only functional requirements. The app does everything and is still unusable because it is slow or confusing. Fix: walk through the 25010 checklist for every release.
- Unmeasurable words. "Fast" leads to an argument at acceptance time. Fix: a measure, a target and the conditions.
- Numbers invented by the team alone. A target of "1 second" may cost a lot and help nobody. Fix: agree numbers with stakeholders and base them on real use.
- Acceptance criteria only for the happy path. Double bookings and failed SMS are found by patients. Fix: write at least one unhappy scenario per feature.
- Unchecked assumptions. They turn into surprises after launch. Fix: owner and check date for each one.
Try it yourself
- Easy: Is each statement functional or non-functional? For non-functional ones, name the ISO/IEC 25010:2023 characteristic. (a) The receptionist can mark a patient as arrived. (b) The booking pages work with a screen reader. (c) After a server restart, no bookings are lost. (d) A patient can choose Bangla or English for reminders. (e) Adding a new doctor takes a settings change, not a code change.
- Medium: Rewrite each vague requirement as a testable "shall" requirement (invent sensible numbers and say so): (a) "The queue screen should be easy to read." (b) "Cancellation must be quick." (c) "The system must handle busy days."
- Hard: Write acceptance criteria in Given/When/Then for the feature "Patient cancels a booking", using this rule from Nadia: cancellation online is allowed up to 2 hours before the visit; after that, the patient must phone the desk. Write at least three scenarios, including one unhappy path, and list one constraint and one assumption that affect the feature.
Answers
- (a) Functional. (b) Non-functional: interaction capability (in 2011 terms, usability; it covers inclusivity). (c) Non-functional: reliability. (d) Functional: it is a behaviour the patient uses (its purpose supports interaction capability). (e) Non-functional: maintainability (or flexibility, if the aim is to set up other clinics). A good answer accepts that (d) and (e) can be argued both ways, as long as the reason is clear.
- Model answers with invented numbers: (a) "Names and times on the queue screen shall be readable from 3 metres by staff with normal or corrected vision, and the next patient shall be shown at the top." (b) "A signed-in patient shall be able to cancel a booking in no more than 3 taps from the confirmation SMS link, and the slot shall show as free within 5 seconds." (c) "The system shall accept 200 bookings and send 300 reminders in one day with page loads still within 3 seconds for 95% of requests." A good answer names a measure, a target and the conditions, uses one requirement per statement, and says the numbers must be agreed with Nadia.
- Model answer:
Constraint: the cancellation link in the SMS must fit the SMS company's message length. Assumption: patients' phones can open a web link (check with the questionnaire). A good answer uses concrete times, includes the boundary at exactly 2 hours (here "up to" is read as including it, and Nadia must confirm that reading), has an unhappy path, and checks that the freed slot becomes bookable.
Scenario: Cancel well before the visit Given a patient has a booking on 2026-11-02 at 10:00 And the time now is 2026-11-01 at 17:00 When the patient cancels the booking Then the booking is marked cancelled and the 10:00 slot is free for others And no reminder is sent for it Scenario: Too late to cancel online Given a patient has a booking on 2026-11-02 at 10:00 And the time now is 2026-11-02 at 08:30 When the patient tries to cancel online Then the cancellation is refused with the message "Please phone the clinic to cancel" And the booking stays in today's queue Scenario: Exactly two hours before Given a patient has a booking on 2026-11-02 at 10:00 And the time now is 2026-11-02 at 08:00 When the patient cancels the booking Then the cancellation is accepted
Summary
- Functional requirements say what the system does; non-functional requirements say how well it does it. Both must be written and tested.
- ISO/IEC 25010:2023 lists nine quality characteristics (functional suitability, performance efficiency, compatibility, interaction capability, reliability, security, maintainability, flexibility, safety); use them as a checklist. The 2011 names usability and portability are out of date.
- A testable requirement has a measure, a target and conditions; the "shall" style, one requirement per statement and a named actor make it clearer.
- Acceptance criteria belong to one item and are agreed before work starts; Given/When/Then scenarios with concrete data cover happy and unhappy paths.
- Record constraints and assumptions with an owner and a check date, and read every requirement against an ambiguity checklist.
Next: User Stories, Use Cases and Prioritising turns these requirements into user stories and use cases, and builds a prioritised product backlog for ClinicQueue.

