Chapter 2 · Requirements
Requirements Engineering: Finding Out What to Build
- Page 5 of 18
- 17 min read
Nadia's first sentence to the team was "I want an app for bookings". That is a starting point, not a requirement. Before anyone designs a screen, the team has to find out who will use ClinicQueue, what they need it to do, what must never go wrong, and what Nadia actually wants to change at her clinic. Get this wrong and a team can build exactly what was asked for and still deliver the wrong thing.
On the previous page, Agile, Scrum and Kanban, you saw that teams work in short cycles and welcome change. Short cycles do not remove the need to understand the problem; they let you understand it piece by piece. This page, the start of chapter 2, shows how a team finds requirements, checks them and controls change.
What you will learn
- What a requirement is, and the four common ways requirements go wrong: unclear, missing, changing and assumed.
- How to find every stakeholder of a project, including people who never touch the software.
- Six elicitation techniques, when each one fits, and how to ask open questions instead of leading ones.
- The other requirements activities: analysis, specification, validation and management (change requests and traceability).
- How to write a short requirements document from a simple outline.
What a requirement is, and why requirements go wrong
A requirement is a statement of something the software must do, or a quality it must have, that the people involved have agreed on. "Patients can book a free slot online" is a requirement. "The booking page is written in Python" is usually not: it is a design decision, and the patient does not care.
Requirements engineering is the work of finding, writing down, checking and managing requirements during the whole life of the software. It is the requirements activity of The Software Development Life Cycle (SDLC), but it does not stop when design starts: requirements keep changing until the software is retired. The international standard for this work is ISO/IEC/IEEE 29148:2018, Life cycle processes — Requirements engineering.
Needs and solutions
Customers often describe a solution ("an app", "a button that sends an SMS") when they have a need ("fewer patients miss their visit"). Write the need first, then discuss solutions: the need stays stable while the solution may change three times. Asking "why?" once or twice leads from one to the other.
Four ways requirements fail
| Failure | What it looks like at ClinicQueue | What it causes | What helps |
|---|---|---|---|
| Unclear | "Reminders should be sent in good time." | Farhan sends them 2 hours before; Nadia meant the day before | Ask for an example and a number; write it down and read it back |
| Missing | Nobody mentioned patients who phone instead of booking online | The online queue and Rina's paper diary disagree on the first morning | Talk to every kind of user; watch the real work |
| Changing | After a month, the clinic adds Saturday opening hours | Slot rules built into the code need rework | Expect change; agree how changes are requested and accepted |
| Assumed | The team assumed every patient reads English | Many reminders are not understood | Write assumptions down and check them with stakeholders |
How an unclear requirement wasted work in the first week:
Invented scenario:
Day 1 Nadia: "Patients should get a reminder."
Day 2 Farhan builds an email reminder, because email is free to send.
Day 4 Demo. Nadia: "Most of our patients never check email. I meant SMS."
Day 4 Rina: "And it must not go out at night. Last year a clinic texted people at 23:00."
Day 5 Farhan removes the email code and starts again with SMS and a sending window.
Lost: about three days. Cause: "reminder" was never written down with channel, timing and receiver.No one was careless: "reminder" meant different things to different people. Most requirement problems are like this, and they are cheapest to fix while they are still words.
Stakeholders: who to ask
A stakeholder is anyone who affects the software or is affected by it. Three groups matter:
- The customer: who pays and decides. For ClinicQueue, Nadia.
- Users: who use the software directly: Rina, the doctors and the patients.
- Others affected: people who never open the app but are affected by it or can stop it, such as family members who book for a parent, the SMS company, and the rules on personal data.
As What Software Engineering Is, and Why Coding Is Not Enough noted, the customer is often not the main user. Nadia knows the goal; Rina knows what happens at 08:15 on a Monday. You need both.
A stakeholder list for ClinicQueue
| Stakeholder | Group | What they care about | Influence | How the team involves them |
|---|---|---|---|---|
| Nadia, clinic manager | Customer | Fewer calls and missed visits, cost, launch date | High: pays and approves | Weekly review of progress and priorities |
| Rina, receptionist | User | A queue that is correct and quick to read; phone bookings | Medium: can make or break adoption | Interview, observation, tries every prototype |
| Dr. Rahman and the second doctor | Users | Knowing who is next; not being double-booked | Medium | Short interview; reviews the queue screen |
| Patients, including elderly patients | Users | Booking that is easy on a cheap phone; a clear reminder | Low each, high together | Questionnaire; five patients test a prototype |
| Family members who book for someone else | Others affected | The reminder reaching the right phone | Low | Patient questionnaire |
| The SMS sending company | Others affected | Its rules on message length, sender name and cost | Medium: its limits are fixed | Document study of its terms |
| Data protection rules where the clinic operates | Others affected | Consent, how long phone numbers are kept, who can see them | High: can stop the launch | Nadia checks with a qualified adviser |
"Influence" is a judgement, not a measurement: people with high influence must never be surprised, and daily users with low influence must still be heard.
Who is missing?
The stakeholders you forget are the ones who cause late surprises. Before you finish the list, ask:
- Who pays and approves? Who uses it daily, and who only once a month?
- Who is affected without using it, such as patients' families?
- Who supplies data or a service it depends on, and who can stop it (laws, a regulator)?
- Who will support and change it after release?
Elicitation: finding out what people need
Elicitation means drawing requirements out of people and documents. Requirements are rarely waiting to be "gathered": people forget to mention what is normal to them, and cannot easily imagine software that does not exist yet. Each technique below catches different things, so teams combine several.
| Technique | Good for | Weak point | ClinicQueue use |
|---|---|---|---|
| Interviews | Goals, problems, details from one person | People describe what they think they do, not always what they do | Lena interviews Nadia, Rina and Dr. Rahman separately |
| Observation | Real work, habits, workarounds nobody mentions | Takes time; people may act differently when watched | Omar watches the front desk for one morning |
| Workshops | Agreement between several stakeholders; resolving conflicts | Loud voices dominate unless someone runs it well | A 90-minute session with Nadia, Rina and both doctors on slot rules |
| Questionnaires | Many people, simple facts and preferences | No follow-up questions; answers can be shallow | A one-page form for patients in the waiting room |
| Document study | Existing rules, forms, contracts, old systems | Documents may be out of date | The paper diary, the opening hours, the SMS company's terms |
| Prototypes | Reactions to something concrete; finding misunderstandings early | People may think a mock-up is nearly finished | Omar's clickable booking screens, tried by five patients |
For a small project like ClinicQueue: interviews to learn the goals, observation to see the real work, then a prototype to check understanding. Add a questionnaire when you need many people's views on a few simple questions, and a workshop when stakeholders disagree.
Good questions and leading questions
A leading question suggests the answer you hope for. People are polite, so they often agree, and you learn nothing. An open question lets them describe their world in their own words. Closed questions (yes or no, a number) are useful later, to confirm a detail.
| Leading (avoid) | Open (better) |
|---|---|
| "You'd like patients to book online, wouldn't you?" | "Walk me through how a booking happens today." |
| "A reminder the day before is fine, right?" | "When would a reminder actually help a patient?" |
| "The queue screen should show the patient's phone number, yes?" | "What do you need to see about a patient when they arrive?" |
| "So the main problem is the busy phone?" | "What makes a morning at the desk go badly?" |
Two habits help: ask for a recent real example ("tell me about last Monday") rather than an opinion, and end by reading back what you understood and asking what you missed.
Template:
Interview plan (30 minutes)
Who / role: ...
Goal of interview: what we must learn by the end
Warm-up: their role and a normal day (5 min)
Open questions: 3-5 questions about the work, problems and goals (15 min)
Recent example: "Tell me about the last time ... went wrong" (5 min)
Read-back: summary in our words; "What did I miss?" (5 min)
After: write notes the same day; list open questions and who can answer themObservation finds what interviews miss
In her interview Rina said "patients book, they come, I tick them off". Then Omar spent a morning at the desk.
Invented scenario:
Omar's observation notes, front desk, Monday 08:00-11:00 (invented)
08:05 Phone rings 6 times before the door opens; 4 calls are bookings.
08:40 A daughter books for her father. Rina writes the daughter's number in the diary.
09:10 Dr. Rahman is 20 minutes late. Rina phones the next two patients to warn them.
09:30 A walk-in patient waits; Rina squeezes him in between two bookings.
10:15 A patient arrives on the wrong day. The diary has his name on Tuesday.
10:50 Rina crosses out a cancelled booking and writes a walk-in in the same line.
Requirements nobody mentioned in interviews:
- bookings made on behalf of someone else (whose phone gets the reminder?)
- walk-in patients must fit into the same queue
- when a doctor runs late, waiting patients need to know
- a cancelled slot should become free again at onceNone of these were secrets; they were so normal to Rina that she did not think of them as "requirements". That is the strength of observation.
From notes to agreed requirements
Four more activities turn a pile of notes into something the team can build from. They are a loop, not a strict sequence: the team goes round again whenever it learns something new.
Example:
+--------------+ +----------+ +---------------+ +------------+
| Elicitation | --> | Analysis | --> | Specification | --> | Validation |
+--------------+ +----------+ +---------------+ +------------+
^ |
| Management: changes, versions, traceability |
+-----------------------------------------------------------+Analysis: sort, connect, find conflicts and gaps
Analysis means making sense of what you heard. The team groups notes by topic (booking, reminders, queue, data), removes duplicates, and looks for two problems in particular.
- Conflicts. Nadia wants reminders two days before the visit, so patients can cancel early and free the slot. Dr. Rahman wants them the day before, because patients forget. Both reasons are good. Lena does not pick a winner herself; she brings the conflict to Nadia, who decides on a reminder the day before plus a link in the SMS for cancelling the booking. The decision and its reason are written down.
- Gaps. What happens when a patient books for a holiday? What if the SMS fails? Going through each step of a booking and asking "what if?" finds gaps before a tester does.
Analysis is also where importance and size are first judged; prioritising is taught on User Stories, Use Cases and Prioritising.
Specification: write it down
Specification means writing the requirements in a form others can read, review and test. Each requirement gets a short ID (for example REQ-07), one clear statement, and its source (who asked for it and why). The next page, Functional and Non-functional Requirements, and Acceptance Criteria, shows how to make each one testable.
Validation: is this what you need?
Validation of requirements means checking with stakeholders that the written requirements describe what they really need. The team reads the list through with Nadia and Rina, and walks Rina through Omar's prototype using a real morning from the observation notes. If stakeholders do not recognise a requirement as their own, it is not validated, however well written.
Management: change requests and traceability
Requirements will change. Requirements management means handling that change on purpose instead of by accident. Two simple tools do most of the work.
A change request records a proposed change, its reason, its effect on the plan, and the decision. Nothing is silently added or dropped.
Template:
Change request CR-03
Requested by: Nadia, 2026-10-12
Change: Add Saturday opening, 09:00-13:00, from next month
Reason: Clinic extends opening hours
Affects: REQ-04 (slot rules), REQ-09 (reminder timing), the queue screen, tests T-11 to T-14
Effort: about 2 days (Farhan), 1 day of testing (Kwame)
Effect: "patient reschedules" moves to the next release
Decision: Accepted by Nadia, 2026-10-13Traceability means following each requirement back to its need and forward to the code and tests that deliver it. The simplest version is a table; when CR-03 arrives, it shows at once which tests must change.
| Need | Requirement | Built in | Tested by |
|---|---|---|---|
| Fewer missed visits | REQ-09 SMS reminder the day before the visit | Reminder module | T-11, T-12 |
| Fewer phone calls | REQ-01 Patient books a free slot online | Booking API and pages | T-01 to T-05 |
| Walk-ins in one queue | REQ-06 Receptionist adds a walk-in to today's queue | Queue screen | T-08 |
A requirement with no test is unchecked; a test with no requirement may check something nobody asked for.
A short requirements document
A software requirements specification (SRS) collects the requirements of a system in one place. For a small project, a few pages people read beat fifty pages nobody opens. The outline below is a common shape, not an official one; adapt it.
Template:
Requirements document: <project name> version 0.3, 2026-10-14
1. Purpose and goals the problem, the need, how success will be judged
2. Stakeholders who they are and what they care about
3. Scope what is in this release, and what is explicitly out
4. Functional requirements REQ-01, REQ-02 ... (what the system does)
5. Non-functional requirements speed, security, ease of use, availability ...
6. Constraints and assumptions fixed limits; things believed true but not yet checked
7. Acceptance how the customer will decide the release is acceptable
8. Open questions what is not decided yet, who decides, by when
9. Change log accepted change requests (CR-01, CR-02 ...)Here is the start of ClinicQueue's version. Notice that "Out of scope" is written down: it prevents arguments later.
Example:
1. Purpose: reduce phone calls at the front desk and missed visits at the clinic.
Success: after three months, fewer booking calls and fewer no-shows than in the paper diary.
3. Scope, release 1: online booking, SMS reminder the day before, today's queue for the desk,
walk-ins added by the receptionist.
Out of scope for release 1: online payment, video visits, AI-drafted reminder text.
8. Open question Q-2: may a family member's phone receive the reminder? Nadia, by 2026-10-20.How much documentation?
Practitioners disagree. Agile teams often keep requirements as a backlog of short user stories plus conversations, because long documents go stale. Regulated projects and fixed contracts need a written, approved specification. As the Agile page showed, valuing working software more than comprehensive documentation does not mean no documentation. A useful test: write down what a newcomer would need if the person who knows it left tomorrow, and what the customer must formally agree to.
Where this shows up at work
- Freelance projects: a short written scope with an "out of scope" list and a change rule protects you and the client.
- Business analysts and product managers do this full time; developers who do it well waste less effort.
- AI features: "draft a reminder" hides questions about tone, language, length and who checks the text.
Common mistakes
- Talking only to the customer. It bites on launch day, when daily users meet a tool that ignores their work. Fix: talk to someone from every user group.
- Asking leading questions. People agree politely and the team "confirms" its own guesses. Fix: open questions and real examples.
- Writing down solutions instead of needs. "A red button" may not be the best way to show a late doctor. Fix: record the need and reason first.
- Accepting changes in the corridor. A quick "yes" silently pushes something else out. Fix: every change gets a short change request and a decision.
- Treating the requirements as finished. New needs appear after every demo. Fix: keep it alive, with a version and a change log.
Try it yourself
- Easy: Mark each interview question as leading or open, and rewrite the leading ones as open questions: (a) "You'd prefer reminders by SMS, wouldn't you?" (b) "What happens at the desk when a doctor is running late?" (c) "The queue should be sorted by arrival time, right?" (d) "Tell me about the last patient who missed an appointment."
- Medium: Side case, invented: a small school wants an app where parents see their child's homework and teachers post it. List at least six stakeholders, put each in a group (customer, user, others affected), and choose two elicitation techniques for the teachers with one reason each.
- Hard: Two weeks before launch, Dr. Rahman asks Farhan in the corridor: "Can the queue screen also show each patient's last diagnosis?" Farhan wants to help. Write what Farhan should say, then fill in a change request for it (use the template above), including at least two stakeholders who must be consulted and why.
Answers
- (a) Leading. Better: "How would patients most like to be reminded?" (b) Open. (c) Leading. Better: "How do you decide who is seen next?" (d) Open, and it asks for a real example, which is the strongest kind of question. A good answer keeps the rewritten questions neutral: they do not contain the answer the team hopes for.
- Model answer: customer: the school or head teacher (pays and approves); users: teachers, parents, students; others affected: office staff, the school's IT helper, data protection rules for children's data, any messaging provider. For teachers: an interview (how homework is set and checked today, with a recent example) and document study of current homework sheets (the real format and workload). A good answer includes students as users, notices the extra rules for children's data, and gives reasons that respect teachers' limited time.
- Model answer: Farhan says "That sounds useful, but I can't add it alone this close to launch. I'll write a change request so Nadia can decide." Change request: requested by Dr. Rahman; change: show last diagnosis on the queue screen; reason: context before each patient; affects the queue screen, the stored data (ClinicQueue holds no diagnoses today) and tests; effort: unknown until the data source is clear; effect: likely delays launch; decision: Nadia's. Consult Nadia (she owns scope and the launch date), Rina (the queue screen is on the front desk where patients can see it, so medical information may be visible to others), and whoever advises the clinic on data protection (diagnoses are sensitive health data). A good answer records the request instead of saying yes or no, names the privacy risk, and leaves the decision with the customer.
Summary
- A requirement is an agreed statement of what the software must do or a quality it must have; write the need first, then discuss solutions.
- Requirements fail by being unclear, missing, changing or assumed; most problems come from words meaning different things to different people.
- List all stakeholders: the customer, every kind of user, and others affected, including people who can stop the project.
- Combine elicitation techniques (interviews, observation, workshops, questionnaires, document study, prototypes) and ask open questions with real examples.
- Analyse, specify, validate and manage requirements in a loop; change requests and a traceability table keep change under control.
- A short requirements document with scope, out-of-scope items and open questions is worth more than a long one nobody reads.
Next: Functional and Non-functional Requirements, and Acceptance Criteria shows how to write each ClinicQueue requirement so that it is clear, measurable and testable.

