Software requirements specification: how to write an SRS that works
A software requirements specification, or SRS, is the document that says what a piece of software must do and how well it must do it, written so that the company buying it, the team building it and the people testing it all read the same thing. A good SRS is the cheapest insurance in a software project: it turns vague wishes into checkable statements before anyone writes code. This guide explains what an SRS contains, gives a template outline and examples of good requirements, and lists the mistakes that cause most disputes.
Why a specification pays for itself
Most cost overruns in custom software do not come from bad code. They come from building the wrong thing, or the right thing with a missing rule that surfaces only in testing. A written specification forces the questions early: what exactly happens when an order is cancelled after shipment, who may approve an invoice above a limit, how many users will log in at nine on a Monday. Answering them on paper costs an afternoon. Answering them after launch costs a change request, a new release and a frustrated team.
The SRS is also the basis for comparable quotes. If you ask three suppliers to price a one-page idea, you get three different projects. If you give them the same specification, you can compare scope, method and price line by line. Our guide to choosing a software development partner and our custom software development cost guide show how to use it in a tender.
The standard behind it
The current international standard for requirements is ISO/IEC/IEEE 29148, Systems and software engineering, Life cycle processes, Requirements engineering. IEEE lists it as an active standard, published on 30 November 2018 and superseding the 2011 edition. According to IEEE's description, it defines the construct of a good requirement, provides attributes and characteristics of requirements, and defines the information items for requirements engineering (IEEE Standards Association, IEEE/ISO/IEC 29148-2018, read on 12 November 2026). You do not need to buy the standard to write a good SRS, but its idea of a good requirement is worth borrowing.
What makes a requirement good
A good requirement is:
- Necessary: something the business needs, not a nice extra dressed as a requirement.
- Unambiguous: it can be read only one way.
- Verifiable: a tester can check it with a clear pass or fail.
- Feasible: it can be built within the constraints.
- Singular: one requirement per statement, so it can be tracked and tested on its own.
- Traceable: it has an ID and links back to a business goal and forward to tests.
| Weak requirement | Better requirement |
|---|---|
| The system should be fast. | Search results for up to 50,000 products appear within 2 seconds for 95 % of searches, measured on the production server. |
| Managers approve large invoices. | An invoice above the approval limit set per cost centre requires approval by that cost centre's manager before it is sent to payment. The limit can be changed by a finance administrator. |
| The app works offline. | A technician can open today's jobs, record hours and take photos without a connection. Data syncs within 1 minute after the connection returns, and conflicts are shown to the office for a decision. |
| User-friendly interface. | A new warehouse worker completes a goods receipt without help after a 10-minute introduction, tested with three users before launch. |
A software requirements specification template
- Introduction. Purpose of the software, business goals, scope (what is in and explicitly out), definitions and abbreviations, references.
- Users and context. User groups with their goals and skills, the current process, and the systems around it.
- Functional requirements. Grouped by feature or process, each with an ID, a description, the business rules, and acceptance criteria. User stories with acceptance criteria work well here.
- Data requirements. The main entities and their fields, where data comes from, who may see and change it, how long it is kept and when it is deleted.
- Interfaces. User interface principles and wireframes, and each integration with another system: direction, data, frequency, format and error handling.
- Quality requirements. Performance, availability, security, accessibility, supported devices and browsers, languages, backup and recovery targets.
- Constraints. Laws and standards that apply, hosting location, technology rules from your IT, deadlines.
- Acceptance and delivery. How the software will be tested and accepted, the environments, the documentation and handover, and who owns the code.
- Open questions. A list of what is not decided yet, with an owner and a date, so the gaps are visible rather than hidden.
Requirements you should not forget
Functional requirements get most of the attention. The disputes usually start elsewhere:
- Roles and permissions: who may see, create, change, approve and delete each kind of data.
- Data migration: what moves from the old system, who cleans it, and how it is checked.
- Personal data: what is collected, the legal basis, retention periods and deletion, so the system supports GDPR from the start.
- Accessibility: the level to meet, usually WCAG 2.2 AA, especially for consumer-facing services covered by the European Accessibility Act. See our accessibility audit page.
- Security: authentication, MFA, logging, and how vulnerabilities are handled after launch.
- Operations: who hosts it, monitoring, backups, support hours, and the maintenance scope after launch.
- Ownership: who owns the source code, the data and the accounts. Write it down.
Common mistakes
- Describing the solution instead of the need. "A dropdown with all customers" is a design choice; "the user finds a customer by name, customer number or VAT ID" is the requirement.
- Copying the old system. Writing down what the current system does, including its workarounds, rather than what the business needs now.
- Words that cannot be tested: fast, easy, flexible, modern, as needed, etc.
- No priorities. When everything is a must, nothing is. Mark each requirement as must, should or could, and plan the first release from the musts.
- A document nobody reads. Two hundred pages that the users never reviewed. Keep it short, walk users through it, and get each part approved.
- Frozen too early, or never frozen. Agree a baseline for the first release, then handle changes through a simple change process with impact on time and cost stated.
Many of those mistakes start with a process nobody drew. A process map of the work the software will support, with decisions, data and exceptions, gives the requirements a solid base.
Using the SRS during the project
The specification is not finished when the contract is signed. Each requirement links to the tests that prove it, so the test report shows which requirements are met. Changes go through a short change log: what changed, why, who approved it, and the effect on the plan. At acceptance, the SRS and the test results together are the checklist. After launch, the same document is the starting point for maintenance and for the next phase, and it helps any new team, ours or another, understand why the software works the way it does.
How we help
We run requirements workshops with your users, write the specification with you, and price the work against it. When the scope is unclear, we start with a short discovery phase that ends in a specification, wireframes and a plan you own, whether you then build with us or with another team. See software consulting for the discovery work and custom software development for the build. For how the work runs after the specification, read our guides to software development steps and software development methodologies.
Questions people ask
What is the difference between an SRS and a business requirements document?
A business requirements document says why the project exists and what the business needs to achieve, such as cutting invoice handling time or meeting a new law. The software requirements specification says what the software must do to get there: the functions, data, rules, interfaces and quality levels. In a small project both can live in one document, with the business goals as its first chapter.
Who should write the software requirements specification?
The company that will use the software owns it, because only it knows the work and the rules. In practice a business analyst or the supplier's team writes it with the users, from interviews, workshops and the current documents, and the company reviews and approves each part. A specification written by the supplier alone, without the users' review, tends to describe what is easy to build.
Is an SRS still used in agile projects?
Yes, in a lighter form. Agile teams keep the requirements as a backlog of user stories with acceptance criteria, and keep the parts that do not fit stories, such as data rules, integrations, security and performance targets, in a short living document. What matters is that requirements are written, testable and agreed, not the name of the document.
How detailed should the requirements be?
Detailed enough that two teams would build the same thing and a tester can check it. A good test: can you write the acceptance test for this requirement today? If not, it needs a number, a rule or an example. Screens and visual design can stay at the level of wireframes; business rules, calculations and data need full detail.
Is there a standard for writing an SRS?
ISO/IEC/IEEE 29148, in its 2018 edition listed by IEEE as active, covers requirements engineering for systems and software. It defines the construct of a good requirement, the attributes and characteristics of requirements, and the information items such as requirements specifications.
Sources
- IEEE Standards Association, IEEE/ISO/IEC 29148-2018, Requirements engineering (read 12 November 2026)