An application requirements specification is read twice, by readers who are not looking for the same thing. Before the order, those who will estimate and build, a supplier or an in-house team, look in it for what needs to be delivered. At delivery, those who will accept look in it for grounds to say whether the result conforms. A document written for the first reading only leaves the second without support.
We therefore propose describing the need in an order that serves both: context and objectives, users and their journeys, functional and non-functional requirements, constraints, then acceptance criteria. Each part has a named author and a named validator. In an agile approach, the detail of the functions leaves the document for a backlog; the rest is still written down.
Context and objectives, then users and their journeys
The first part says why the application is requested: the problem to solve, what exists today (an application to replace, spreadsheets, duplicate data entry), the objectives worded as states that someone will be able to observe, and what remains out of scope. It names the sponsor and the departments concerned.
The second describes those who will use the application: the types of users, their number, their working conditions (fixed workstation, phone, no network), then their journeys, from trigger to result. Take the job-tracking application of a lift maintenance company. The technician’s journey is written in steps: receive the job, consult the equipment’s history, enter the report offline, collect the customer’s signature.
A journey is described by what the user is trying to do; screens belong to the solution. The workshop that brings out these journeys is described in our article on agile story mapping. If the problem or the users cannot yet be written down, the work to be done is product framing, presented in our custom software development page.
The requirements of an application requirements specification, functional and non-functional
The public glossary of the International Requirements Engineering Board (IREB), consulted on 12 November 2026 on cpre.ireb.org, sorts the requirements concerning a system into three kinds: functional requirements, quality requirements and constraints. It groups the last two under the name of non-functional requirements.
A functional requirement, according to this glossary, concerns a result or behaviour that shall be provided by a function of the system. In the document, it carries an identifier, is stated in one verifiable sentence, cites its source (the person or text requesting it) and receives a priority on an agreed scale. Business rules are attached to it, with worked examples when an amount or a date is involved. This part also covers data, including migration of existing data, and exchanges with other applications.
A quality requirement concerns what the functions do not say: response time, availability, security, accessibility, ease of takeover by another maintainer. It is written with a measure and the way of taking it. “The application must be fast” can be neither accepted nor rejected. “The list of the day’s jobs is displayed in less than two seconds with 300 technicians connected”, figures given here as an assumption, can be. These requirements weigh on the architecture: written after the solution has been chosen, they may force that choice to be reopened.
Constraints and acceptance criteria
A constraint, according to the IREB glossary, is a requirement that limits the solution space beyond what is necessary for meeting the functional and quality requirements. In practice, this covers imposed technologies, hosting rules, the standards of the information system, applicable legislation (the GDPR, Regulation (EU) 2016/679, as soon as the application processes personal data), the timetable and ownership of the code. Each constraint cites who issued it. A constraint whose origin nobody can remember rules out solutions for no known reason.
In a public procurement contract, the form of the documents describing the need is governed by public procurement rules, which this article does not cover.
Acceptance criteria close the document. The same glossary defines them as the criteria that a work product must satisfy to be accepted by the stakeholders. For each journey and each requirement, they say how conformity will be observed: the case to replay, the data, the expected result, the person who observes. They can take the form of scenarios, presented in our behaviour-driven development entry.
Writing them before the tender has two effects. A requirement for which nobody can find a criterion needs to be reworded. And the bidder costs the tests along with the rest: criteria limited to functions leave code quality out of acceptance, a risk noted in our article fixed fee or time and materials. Verifying quality requirements (load, security) falls under the test strategy described in our software quality and testing page.
In an agile approach, parts that are written differently
An agile approach does not do away with the document: it moves part of it. Context, objectives, users, journeys in broad outline, quality requirements and constraints are written before the start, because they commit the budget and the architecture.
The detail of the functional requirements, however, is not settled in advance. It lives in the Product Backlog, which the Scrum Guide (scrumguides.org, November 2020 version, read on 12 November 2026) describes as “an emergent, ordered list” of what is needed to improve the product. In common usage, each item receives its acceptance criteria as its delivery approaches; the order of the list falls to the product owner.
The quality requirements common to all items can find a place, in our reading, in the Definition of Done, which the same guide presents as the formal description of the state of the Increment when it meets the quality measures required for the product.
Who validates each part
The roles of project owner and project contractor show who expresses the need and who delivers. The allocation below is a proposal, which each organisation adjusts: it separates the person who writes from the person who validates, and indicates the scope of each validation.
| Part | Who writes it | Who validates it | Scope of the validation |
|---|---|---|---|
| Context and objectives | The project’s business lead | The sponsor | The objectives in whose name the budget is requested |
| Users and journeys | The business lead, with user representatives | Users of each type and their management | The journeys that acceptance testing will replay |
| Functional requirements | The business lead | The business lead, after a feasibility opinion from those who will deliver | The costed scope |
| Quality requirements | The architect, security and operations, with the business for service levels | The IT department and the business lead | The architecture and the operating cost |
| Constraints | The issuer of each one: IT, procurement, legal, data protection | The same issuer, who confirms its origin | The space left for solutions |
| Acceptance criteria | The business lead and the person in charge of testing | The person who will sign off acceptance | What will be authoritative at delivery |
Validation applies to a dated version; any later modification goes through a tracked request, accepted by the validator of the affected part.
Before signature, a cross-review checks the chain: each objective leads to at least one journey, each journey to requirements, each requirement to an acceptance criterion. A link with nothing after it shows what remains to be written; a requirement with no objective, what can be removed.