A value proposition guides the solution, but it does not by itself describe what the solution must do, how it must behave, or how to verify that it works.

“We want to make reservations easier” is not sufficient direction for commissioning an app. Who creates the reservation? How is it confirmed? What if the connection fails? Who can change it, and how does a customer know the change was saved? Translating the desired outcome into verifiable requirements reduces misunderstandings, but does not automatically create a good experience. The UK Government Digital Service guidance on user stories stresses the relationship between actor, need, goal, and acceptance criteria [R01]. This principle can also be applied to services and processes that do not use Scrum.

1. Do not confuse a need, outcome, requirement, and feature

Concept Question Reservations example
Need What is the person trying to achieve? Avoid losing schedule changes
Value outcome What should improve? Staff and customer receive consistent confirmation
Requirement What condition must the solution satisfy? Record the date, time, and confirmation of a change
Feature What capability is implemented? Modify a reservation from a calendar
Acceptance criterion What evidence demonstrates the behavior? After confirmation, authorized users see the new time
Outcome metric How can improvement be evaluated? Lost changes over a defined period and denominator

A feature can exist without delivering value: a calendar with twenty fields does not help if staff cannot tell who should confirm changes. The Pillar 2 value proposition explains the promise; the task here is to turn that promise into buildable conditions. “Value” is not a synonym for “number of requirements.”

2. Recover actual needs and scenarios

Before writing requirements, collect prioritized needs, journey observations, documented incidents, constraints, and known obligations. Identify users, buyers, approvers, and operators: they may be different people. GOV.UK's user-needs guidance recommends retaining traceability between needs and later user stories [R02].

For each scenario, describe the actor, starting state, action, expected outcome, and likely obstacles. Do not invent perfect workflows. Check them with the people who do the work. A manager may request “automated reservations,” while an employee needs to handle telephone changes and the customer needs to avoid conflicting confirmations.

When conflicting requests appear, use customer-needs prioritization to distinguish the outcomes that truly matter. A feature list is not a substitute for evidence about needs.

3. Classify requirements by their purpose

Functional requirements: observable capabilities and business rules, such as creating, viewing, changing, or canceling reservations. Information and data requirements: what information is necessary, where it comes from, who can access it, and how long it should be kept. Interface and integration requirements: which tools or people need to exchange information.

Nonfunctional requirements or quality attributes: security, accessibility, reliability, performance, maintainability, and compatibility. These are not all captured by a single number; each needs a verifiable condition and context. ISO/IEC 25010:2023 provides a reference model for specifying and evaluating ICT product quality, but does not replace your business requirements or imply that every service needs certification [R03].

Operational requirements: who handles incidents, what happens offline, how a task is recovered, and how staff are trained. Constraints: budget, staffing, materials, regulatory conditions, and physical limitations. Some are mandatory, while others are negotiable preferences.

Avoid squeezing all these concerns into one vague statement. “The app must be fast, secure, and simple” offers neither context nor an acceptance method.

Nonfunctional attributes need criteria proportionate to their risks: the guide to defining and verifying quality develops dimensions, controls, and evidence so words such as “fast” and “secure” are not mistaken for testable requirements.

4. Write clear, testable requirements

A useful requirement has an identifier, condition or behavior, actor/context, rationale, priority, evidence source, and verification method. For example:

  • Weak: “The system should support easy reservations.”
  • Better: “An authorized staff member can change the time of an existing reservation and verify the confirmed time before leaving the flow.”
  • Related nonfunctional requirement: “The change must not expose other customers' reservation information to unauthorized users.”

Avoid “always,” “intuitive,” or “as fast as possible” unless you define the meaning and how to test it. Requirements need not sound like legal contracts to be precise. If a requirement comes from an assumption, label it a hypothesis, not a verified user need.

5. Choose user stories, use cases, or scenarios where appropriate

A user story summarizes actor, action, and purpose: “As a host, I need to change an existing reservation so it reflects a customer-confirmed update.” This helps discuss scope but does not replace detailed behavior.

A use case describes sequences, preconditions, alternatives, and failure paths: a booking exists; the host requests a new time; the system checks availability; it confirms or explains a conflict. A scenario is a concrete situation that can be observed or tested.

Do not force every requirement into user stories. Material-strength requirements, food safety controls, or security conditions may require a technical specification, inspection procedure, or authoritative evidence. Choose documentation that fits the risk.

6. Write acceptance criteria you can test

Acceptance criteria state when a capability satisfies the agreed behavior. You can write observable outcomes or use Given–When–Then, a useful but optional structure:

Given an existing confirmed booking and an authorized host, when the host selects an available time and confirms the change, then the system displays the updated time and retains evidence of the change.

Include failure paths, not just the happy path:

Given that the requested time is taken, when the host tries to confirm it, then the system explains the conflict, does not silently overwrite the previous time, and lets the host choose another option.

For a physical inspection, the equivalent is to specify dimensions, tolerances, instruments, samples, and consequences of deviations. For services, it could be confirming that acknowledgment follows a procedure and that recovery steps exist. Real thresholds must be set according to context, risk, and evidence; do not copy them from invented examples.

7. Define mandatory minimums without degrading the solution

Separate essential to produce value, mandatory for safety or compliance, necessary to operate and recover, and optional improvements. An “MVP” label does not justify dropping essential safeguards or advertising nonexistent capabilities.

Strategic prioritization of needs belongs to Pillar 2, and the MoSCoW scope matrix belongs to Pillar 4. Here we decide which requirements this version must meet to be built and tested, explicitly noting what is out of scope. If automated notifications are excluded, explain what manual mechanism will still confirm bookings and who owns it.

Once minimum obligations are identified, define an MVP with enough scope for learning. Reducing features does not justify removing essential safety, compliance, or core-value conditions.

8. Build a traceability matrix

Traceability connects the problem to an outcome, requirement, criterion, and evidence. Creating hundreds of IDs is useless unless those connections help decisions.

ID Need Requirement Planned acceptance Evidence
REQ-01 Avoid lost changes Host edits a reservation Updated time with confirmation Flow test and log
REQ-02 Avoid double booking Detect conflict before saving Original reservation unchanged on conflict Negative test
REQ-03 Protect information Role-based access Unauthorized role cannot see unrelated data Permission check
REQ-04 Recover from failure Resume after an error Known final state, no duplicate Interruption test

This is an instructional example, not a production-ready specification. Each actual criterion needs sufficient detail about roles, conditions, and outcomes. Four grounded requirements are better than fifty no one can verify.

9. Manage contradictions and changes

Stakeholders may make incompatible requests: a customer wants to edit until the last minute while a kitchen must stop accepting changes before preparation. Do not hide the conflict inside separate requirements. Record alternatives, impacts, decision owner, and conditions. A new need may require revising a previous rule, but the history and affected test cases must remain visible.

The Pillar 5 versioning article will explain how to attach changes to an actual release. Here, retain the reason a requirement exists, not merely its most recent wording.

Worked example: criteria satisfied, experience still difficult

A team builds a reservation screen supporting creation and editing. Its technical criteria require a date, a customer name, and a recorded update. All pass in a review. Yet three fictional participants in an illustrative test mistake a “Close” button for confirmation, exit without saving, and must repeat their task.

Technical acceptance does not demonstrate a satisfying experience. The team records the finding and separates three actions: redesign the confirmation mechanism, add a criterion requiring unmistakable saved-state feedback, and observe the task again with representative participants. The number “three” is illustrative, not a population statistic. It shows how new evidence can reveal gaps in the initial criteria.

Instead of writing “UX improved,” the team defines observable behavior, test conditions, and next steps if confusion remains. The finding remains evidence; the previous test is not rewritten to pretend it already measured this concern.

Common mistakes and limitations

Mistaking features for needs; using “easy” as an acceptance criterion; ignoring failures, recovery, and access roles; creating twenty stories for the same problem; omitting evidence sources; inventing performance thresholds without a measurement method; mistaking assumptions for legal requirements; specifying only the happy path; treating feature acceptance as proof of market success.

Documentation is a means, not the goal. If maintaining a matrix takes more effort than resolving meaningful disagreements, simplify the format without losing critical connections.

What you should have when finished

A minimum solution specification containing needs and outcomes, identified requirements, positive and negative acceptance criteria, mandatory conditions, sources, planned tests, and traceability. It should support building and accepting a version without claiming that compliance automatically proves value.

References