A software requirements specification (SRS) is a document that sets out what a piece of software must do and how well it must do it. A good one gives a supplier enough to quote against and gives you enough to test the result. It covers the project’s goals, users, functional requirements, non-functional requirements and constraints, written so each one can be checked as met or not met.
Most SRS guides are written by requirements-tool vendors for in-house engineering teams. This one is for the other side: a UK business commissioning bespoke software from an agency or development partner. It covers what goes in, a template you can copy, how to write requirements that can be tested, and the UK-specific requirements that are most often missed.
What is a software requirements specification for?
An SRS does three jobs on a bespoke project:
- It lets suppliers quote the same thing. If three agencies quote from a one-paragraph brief, they are quoting three different systems. A shared SRS makes the quotes comparable.
- It defines “done”. Acceptance testing at the end of a phase or project checks the software against the SRS. Without it, “done” is a matter of opinion.
- It anchors the contract. Under a fixed-price contract the SRS is the scope, and anything outside it is a change request. Under time and materials it guides priorities rather than fixing them. Our guide to fixed price vs time and materials covers how that plays out.
The underlying international standard is ISO/IEC/IEEE 29148, which covers requirements engineering and replaced the older IEEE 830 recommended practice for SRS documents. You don’t need to follow it clause by clause, but its structure is where most templates, including the one below, come from.
What goes in a software requirements specification?
| Section | What it covers | Typical questions it answers |
|---|---|---|
| 1. Purpose and scope | Why the software is being built and what’s in and out of scope | What problem does it solve? What will it not do? |
| 2. Users and roles | Who uses it and what each role can do | Who are the users? Which roles see which data? |
| 3. Functional requirements | What the system does, feature by feature | What happens when a user does X? |
| 4. Non-functional requirements | How well it must work | How fast, how secure, how available, how accessible? |
| 5. Data and integrations | What data it holds and what it connects to | Where does data come from? Which systems does it talk to? |
| 6. Constraints | Fixed decisions and rules | Which hosting, technology, budget, deadlines or regulations apply? |
| 7. Assumptions and dependencies | Things taken as true, and things outside the project | What are we relying on someone else to provide? |
| 8. Acceptance criteria | How each requirement will be tested | How will we know it works? |
| 9. Glossary | Business terms defined once | What exactly do we mean by “account” or “order”? |
The glossary sounds optional but often prevents the worst misunderstandings. Many disputes on software projects start with two parties reading the same word differently.
How do you write requirements that can be tested?
Each requirement should be specific enough that a tester can say “pass” or “fail” without asking you what you meant. Three habits make the biggest difference.
Number every requirement and use “must”. Give each one an ID (FR-12, NFR-4) so it can be referenced in quotes, tickets and test results. Write “the system must…” for mandatory requirements, and mark nice-to-haves separately rather than hiding them in softer wording.
Replace adjectives with measures.
| Vague | Testable |
|---|---|
| The system should be fast. | Search results must appear within 2 seconds for 95% of searches with up to 50 concurrent users. |
| The app must be secure. | Staff must sign in with multi-factor authentication. Passwords must never be stored in plain text. |
| Reports should be easy to export. | A manager must be able to export any report to CSV and PDF from the report screen. |
| The system must be reliable. | The system must be available 99.5% of the time each calendar month, excluding agreed maintenance windows. |
Write user stories with acceptance criteria. The GOV.UK Service Manual uses the format “As a… I need… So that…”, which captures the user, the need and the reason. Add acceptance criteria underneath, for example in the Given/When/Then style of Gherkin:
FR-12. As a line manager, I need to approve or reject a holiday request, so that my team’s leave is planned.
- Given a pending request from someone in my team, when I approve it, then the employee gets an email and the days are deducted from their balance.
- Given a request from someone outside my team, when I open it, then I can’t approve or reject it.
Then prioritise. The MoSCoW method from the Agile Business Consortium sorts requirements into Must have, Should have, Could have and Won’t have this time. That last group matters: writing down what is out of scope is as useful as writing down what is in.
Which UK requirements do buyers often forget?
These rarely appear in a first draft, and each is cheaper to design in than to add later:
- Data protection. If the software handles personal data, the SRS should say what data is collected, why, how long it is kept, who can see it, and how a person’s data can be found, exported or deleted. UK GDPR expects data protection by design and by default, which in practice means writing these rules into the requirements rather than leaving them to the developers.
- Hosting and data location. State where data must be stored and processed, if that matters to you or your customers, and any requirement for backups and restore times.
- Accessibility. Public sector bodies must meet the WCAG 2.2 AA standard, and many private-sector buyers use the same target. Name the standard and level in the SRS; “accessible” on its own can’t be tested.
- Security baseline. Cyber Essentials is the government-backed minimum standard, and a growing number of organisations require it of suppliers. Say whether your supplier needs it, plus any specific requirements such as multi-factor authentication, audit logs or penetration testing before launch.
- Ownership, handover and support. State who owns the code and where it will live, what documentation you expect, and what support and maintenance looks like after launch.
- Integrations. List every system the software must talk to, who owns each one, and whether an API already exists. Integrations are a frequent source of surprises on bespoke projects.
How detailed should an SRS be?
Detailed enough to quote and test the first release, and no more. Over-specifying screens and workflows you haven’t validated with users locks in guesses. The GOV.UK discovery phase guidance makes the same point from the other direction: learn what users need before committing to a solution.
A practical split:
- Must be firm before quoting: purpose and scope, user roles, the must-have functional requirements, non-functional requirements, integrations and constraints.
- Can stay lighter: detailed screen designs, should-have and could-have features, and anything for later releases.
If your requirements are still uncertain, a short, fixed-price discovery phase to produce the SRS is often a better first step than a guess-based quote for the whole build. Our MVP development guide covers scoping the first release.
A software requirements specification template you can copy
1. Purpose and scope
1.1 Background and business goals
1.2 In scope (first release)
1.3 Out of scope / won't have this time
2. Users and roles
2.1 User types and what each needs
2.2 Permissions by role
3. Functional requirements
FR-1 As a <user>, I need <capability>, so that <reason>.
Acceptance criteria: Given / When / Then
Priority: Must | Should | Could
4. Non-functional requirements
NFR-1 Performance (response times, concurrent users)
NFR-2 Availability (target %, maintenance windows)
NFR-3 Security (authentication, roles, logging, testing)
NFR-4 Accessibility (e.g. WCAG 2.2 AA)
NFR-5 Data protection (data held, retention, export, deletion)
NFR-6 Supported browsers and devices
5. Data and integrations
5.1 Data held, its source and owner
5.2 Systems to integrate with (owner, API, direction)
5.3 Data migration from existing systems
6. Constraints
Hosting and data location, technology, budget, deadlines, regulation
7. Assumptions and dependencies
8. Acceptance and handover
How testing will be done, documentation, code ownership, support
9. Glossary
Getting a specification you can build from
A software requirements specification doesn’t need to be long or formal to be useful. It needs to be specific, testable and agreed by both sides before the quote is signed. If you’re planning a bespoke software project and want help turning a brief into a specification, we can run a short discovery with you. Get in touch to talk it through.
Frequently asked questions
What is the difference between functional and non-functional requirements?
Functional requirements describe what the software does, such as 'a manager can approve a holiday request'. Non-functional requirements describe how well it must do it: speed, security, availability, accessibility, data retention and so on. Both need to be testable, so 'fast' becomes something like 'search results appear within two seconds for 95% of searches'.
How long should a software requirements specification be?
As long as it needs to be for a supplier to quote and for you to test the result, and no longer. For a small internal tool that can be a few pages; for a regulated or multi-team system it is much longer. A short SRS with clear, testable requirements is more useful than a long one full of generic wording.
Do agile projects still need an SRS?
They need the same information, but it is usually kept as a lighter document plus a prioritised backlog of user stories rather than one large signed-off specification. The scope, constraints and non-functional requirements still need writing down before work starts, because user stories rarely capture them.
Should the buyer or the developer write the SRS?
The buyer owns the 'what' and 'why': the business goals, users, rules and constraints. A good supplier then helps turn that into precise, testable requirements, often during a short paid discovery phase. Either way, you should approve the final version, because it becomes the basis of the quote and of acceptance testing.
Is there a standard format for an SRS?
The international standard for requirements engineering is ISO/IEC/IEEE 29148, which replaced the older IEEE 830 SRS guidance. Most teams use a simplified version of its structure, like the template in this guide, rather than following it clause by clause.





