A manager says: “We need a dashboard for the sales team.” A developer builds a beautiful dashboard in six weeks. The sales team never opens it, because what they actually needed was a daily email listing customers who have not been called in 30 days.
The code was perfect. The requirement was wrong. And nobody finds out until the money is spent.
Building software right is a skill. Building the right software is a different skill, and it starts before any code exists. This article is about that second skill: asking better questions, writing things down so they cannot be misread, and handing over to developers with confidence instead of hope.
In this article you will learn:
- how to find the right people and ask the questions that reveal the real need,
- the main ways to gather requirements, and when to use each,
- what to document, and a template that works,
- how to hand over to a development team without losing meaning,
- what unclear requirements really cost, and the risks that cause surprises,
- a checklist you can use on your next project.
Reading time: about 12 minutes.
The process at a glance
A requirement is a statement of something the system must do, or a quality it must have, so that the business gets a result. Two kinds matter:
- Functional: what the system does (“send an email when an order ships”).
- Non-functional (NFR): how well it does it (“the page loads in under 3 seconds”, “data is encrypted”, “works on a phone”).
Teams usually forget the second kind, and it causes many late surprises.
Step 1: Identify the right stakeholders
A stakeholder is anyone affected by the system or able to affect it. Asking only the person who requested the project is the most common mistake.
| Group | Example | What they know |
|---|---|---|
| Sponsor | Head of Sales | Goal, budget, deadline |
| End users | Sales reps, support agents | How the work really happens |
| Operations | IT support, DevOps | Hosting, monitoring, incidents |
| Compliance and legal | Security, finance, data protection | Rules you must not break |
| Integrators | Teams owning other systems | APIs, data formats, limits |
| Customers | People who use the outcome | What they actually value |
A quick test: “Who will be angry if this goes wrong?” Each name on that list should be consulted.
Step 2: Gather, using more than one method
No single method finds everything. Mix them.
| Method | Best for | Watch out for |
|---|---|---|
| Interviews | Deep detail from one person | People describe what they think they do, not what they do |
| Workshops | Resolving conflicts between groups | Loud voices dominate; use a facilitator |
| Observation (shadowing) | Finding hidden steps and workarounds | Takes time; people act differently when watched |
| Document analysis | Existing forms, reports, spreadsheets | Documents may be out of date |
| Prototypes / wireframes | “I’ll know it when I see it” users | A pretty mockup can hide hard logic |
| Surveys / data analysis | Many users, measurable behaviour | Shallow answers; needs good questions |
Three questions that surface real needs:
- “Walk me through the last time you did this.” Real events beat opinions.
- “What happens when something goes wrong?” This finds the exceptions.
- “If we could only deliver one thing, what would it be?” This forces priorities.
Avoid leading questions such as “You want a dashboard, right?” Ask “What decision do you need to make each morning?”
Real failures: when requirements go wrong
FBI Virtual Case File (2000s). The FBI spent years and roughly $170 million on a case-management system that was scrapped in 2005. Public reviews pointed to unclear requirements that kept changing, weak oversight, and a lack of agreed scope. The lesson: without a stable, agreed definition of “done,” a project cannot converge.
NHS National Programme for IT (UK). A very large, centrally planned health IT programme was largely dismantled around 2011 after years of delay and cost growth. Reviews cited a top-down approach that did not match what local hospitals and clinicians needed. The lesson: users must shape requirements, not just receive them.
The wrong dashboard (the opening story). No famous headline, but the most common failure of all: the team built what was said, not what was needed.
Both public cases tell the same story. The cost of unclear requirements is not a few bugs. It can be the whole project.
Step 3: Document so that others can build from it
Your goal is simple: a developer who was not in the meeting should reach the same understanding as you. A useful document set is small:
- Problem and goal. One sentence, one measurable target.
- Scope. What is in, and equally important, what is out.
- User stories with acceptance criteria. The core.
- Business rules. Calculations, limits, approvals.
- Non-functional requirements. Speed, security, availability, compliance.
- Assumptions and dependencies. What you believe is true but have not proven.
- Glossary. Business words and their exact meaning.
- Open questions. With an owner and a due date.
A user story with acceptance criteria
ID: REQ-014
Story: As a sales rep, I want a daily list of customers I have not
contacted in 30 days, so that I can call the ones at risk of leaving.
Priority: Must have
Source: Interview with J. Perera (Sales), 2026-10-02
Rules: "Contacted" = a logged call or email by the account owner.
Customers marked "Do not contact" are excluded.
Acceptance criteria
Given a customer last contacted 31 days ago
When the daily job runs at 07:00
Then the customer appears in the owner's email list
Given a customer marked "Do not contact"
Then the customer never appears in the list
NFR: Email delivered by 07:15 for up to 5,000 customers.
Out of scope: Automatic calling, SMS.
Status: Approved by Head of Sales, 2026-10-09
Notice the ID and the Source. They give you traceability: you can later answer “why did we build this, and who asked for it?”
Good versus bad wording
| Vague (bad) | Testable (good) |
|---|---|
| “The system should be fast.” | “Search results appear in under 2 seconds for 95% of requests.” |
| “Easy to use.” | “A new rep completes a first order in under 5 minutes without training.” |
| “Secure.” | “Passwords are hashed, and all traffic uses HTTPS.” |
| “Support many users.” | “Handles 500 concurrent users with under 1% errors.” |
If a requirement cannot be tested, it cannot be proven finished, and it will be argued about later.
A small wording trap that costs months
Here is how one innocent phrase goes wrong. The requirement says: “Show customers not contacted in 30 days.”
- The business means “30 days or more.” A customer last called exactly 30 days ago should appear.
- The developer reads “more than 30 days.” That customer is silently left out.
Nobody notices for months, because the list still looks right. Customers on day 30 simply never get their call.
The fix costs one minute before handover: add a concrete example to the requirement. “A customer last contacted exactly 30 days ago does appear in the list.” Examples remove the guesswork that adjectives and numbers alone leave behind.
Step 4: Validate and prioritise before handover
Do not hand over a first draft. Run three checks:
- Read-back review. Walk each stakeholder through the document in plain words. Ask them to find what is wrong, not to approve.
- Quality check on each requirement. Is it clear, testable, necessary, feasible and not contradicting another?
- Prioritise with MoSCoW: Must have, Should have, Could have, Won’t have (this time). If everything is “Must,” nothing is prioritised.
Then get written sign-off from the sponsor. It is not about blame. It is about a shared, dated version of the truth that you can compare changes against.
Step 5: Hand over without losing meaning
A handover is a conversation supported by a document, not a document thrown over a wall.
Definition of Ready. Only move a requirement to development when:
- It has an ID, an owner and a priority.
- Acceptance criteria are written as examples.
- NFRs and dependencies are noted.
- Open questions are answered, or clearly marked with an owner.
- A developer and a tester have read it and said “I can build and test this.”
Walkthrough. Hold a short session where the person who gathered the requirements explains the why behind them to the developers and testers. Record the decisions that were made and rejected.
Keep the line open. Name one contact (often a product owner or business analyst) whom developers can ask during the build. Unanswered questions get answered by guessing.
Control changes. Requirements will change. That is normal. What matters is that each change has a reason, an owner and a visible impact on time and cost.
Cost: why getting it right early pays for itself
The idea that mistakes get more expensive the later you find them goes back to Barry Boehm’s research in the 1980s, which is where figures like “10x to 100x” come from. Modern agile teams can shrink the curve with fast releases, and the exact ratios are debated. The principle still holds: fixing a sentence is cheaper than fixing code, and fixing code is cheaper than fixing a live system with real customers.
Where the money goes when requirements are poor:
| Cost | What it looks like |
|---|---|
| Rework | Features rebuilt after demos or launch |
| Wasted features | Built, shipped, never used (the dashboard story) |
| Delay | Waiting on answers that were never asked |
| Scope creep | “Small” additions with no review of impact |
| Support and workarounds | Staff covering gaps manually, forever |
| Reputation and trust | Business stops believing IT estimates |
Spending a few days on discovery, workshops and review is a small, planned cost. Skipping it turns that cost into an unplanned and larger one.
Risk: how to avoid the surprises
| Risk | Typical sign | How to reduce it |
|---|---|---|
| Missing stakeholder | A late surprise: “Legal never saw this” | Build a stakeholder map; ask “who else?” in every interview |
| Vague wording | Words like fast, user-friendly, etc. | Replace with measurable examples |
| Hidden assumptions | “Obviously the data is clean” | Record assumptions and verify them early |
| Scope creep | Requests added with no trade-off | Change log; every addition has a cost and a decision |
| Conflicting requirements | Sales and Finance disagree | Resolve in a workshop; sponsor decides, in writing |
| Forgotten NFRs | Slow, insecure, down at peak time | Add a standard NFR checklist to every project |
| Knowledge in one head | Only the analyst understands it | Walkthroughs, glossary, recorded decisions |
| Gold plating | Developers add extras nobody asked for | Link each feature to a requirement ID |
A small risk register (a table like this with an owner, likelihood and next action) reviewed every week costs minutes and prevents most of these.
Best practices checklist
- Start from the problem and a measurable goal, not from a requested solution.
- Interview users and observe real work, not only managers.
- Use at least two gathering methods.
- Write what is out of scope as clearly as what is in.
- Replace adjectives with numbers and examples.
- Give every requirement an ID, a source, an owner and a priority.
- Do not forget non-functional requirements and compliance rules.
- Keep a glossary so everyone uses the same words for the same things.
- Record assumptions and open questions with owners.
- Validate with stakeholders by reading it back to them.
- Get written sign-off, then manage changes through a log.
- Hand over with a walkthrough and a named contact, not just a file.
- Keep requirements living: update them when decisions change.
Key takeaways
- Building the right thing beats building the thing right. A wrong requirement is the costliest bug because the team builds it perfectly.
- Talk to everyone affected, not only the person who asked for the project.
- Combine methods: interviews, observation, workshops and prototypes find different things.
- Write testable requirements with IDs, sources, examples and acceptance criteria. Every requirement should be checkable by someone other than its author.
- Handover is a conversation. Use a Definition of Ready, a walkthrough and one named contact.
- Early clarity is cheap, late change is not. The exact multiplier varies, but the direction does not.
- Track risks and changes openly, so the business always knows what is decided and what it costs.
This week, pick one current ticket and run the Definition of Ready on it. Count how many questions you cannot answer. That number is the risk you were about to hand to your developers.