Buyer Guides8 min read

Software Requirements Document Template (And What Makes One Unquotable)

Free software requirements document template with examples. Define scope, features and acceptance criteria before you hire developers. Download it now.

If you have sent one brief to three developers and received three wildly different quotes, the brief is almost certainly the problem. A developer pricing an ambiguous document has three options — pad heavily, quote low and recover through change requests, or guess — and you cannot tell which one you received by looking at the number.

Below is the structure we would want before quoting, and would suggest you give to anyone else. You do not need a technical specification. You need to answer the business questions precisely enough that the technical consequences become determinable.

The nine questions that decide an estimate

Before the structure, the substance. If your document answers these, it is quotable. If it does not, no amount of formatting will help.

  1. How many user roles, and does each see different records? The single largest multiplier in business software, and a data-model decision rather than an interface one.
  2. Which external systems must it connect to, and do they have a usable API? Name them. An integration with a modern documented API is days; one with a nightly file drop is weeks.
  3. Is there existing data to migrate, how much, and what state is it in? Honestly. Understating this does not make it cheaper.
  4. What are the volumes? Ten users or ten thousand. A hundred records or ten million. Architecture follows from this.
  5. What has to be true for this to be finished? In terms someone could check, not "when it works well".
  6. What is deliberately out of scope for version one? The most dispute-preventing section in any brief.
  7. What reports must it produce? Name the questions they answer. "Plus reporting" can be a quarter of the build.
  8. What constraints are real? A fixed date with a reason, a platform you must support, a compliance regime, a technology your team must be able to maintain.
  9. Who decides? The single most useful line in any document is the name of the person who can resolve a question without convening a committee.

The structure

Ten to twenty pages covers most mid-sized projects. Longer than that usually means the prioritisation decisions have not been made, and developers skim rather than read.

1. The problem, in business terms

What happens today, where it goes wrong, what it costs you, and what success would look like as something measurable. Not a feature list. A developer who understands the problem will propose better solutions than one implementing a list — and this section is what lets them tell you your premise is wrong, which is occasionally the most valuable thing they can do.

2. Users and roles

Every role, and for each: what they can see, create, change and delete. Be exact. "Admins and users" is two roles. "Admins; team leads who see their own team's records; users who see only their own; an auditor with read-only access to everything" is four, and costs materially more.

Include whether roles are per-organisation (one user, several client accounts) because that is a tenancy decision, not a permissions one.

3. Core workflows, step by step

Three or four workflows described in the order they actually happen, including who does each step and what happens when something is rejected or returned. Worth more than thirty bullet-point features.

Write them as narratives: "A customer submits X. It arrives in Y's queue. Y checks Z. If Z fails, it goes back to the customer with a reason." That paragraph specifies more than a page of requirements statements.

4. Data and relationships

What things the system tracks and how they relate. You do not need a schema — you need to say that a job has several sites, that a customer can also be a supplier, that an order can be part-shipped. These are the facts that determine the data model, and they are the expensive thing to get wrong.

5. Integrations

One row per system: what it is, what data moves, which direction, how often, whether an API exists, who holds the credentials, and whether there is a sandbox. If you do not know whether an API exists, say so — that is useful information and a developer can check.

6. Reports and outputs

The questions each report answers, who reads it, and how often. Also documents the system must produce — invoices, letters, exports — and whether they need specific formatting or branding.

7. Non-functional requirements

Only the ones that are real. Volumes and concurrency. Availability, if downtime has a cost worth stating. Compliance regimes by name. Data residency, if it is a requirement rather than a preference. Accessibility standards, if you are bound by one. Browser and device support, based on your actual analytics rather than a default.

8. Explicit exclusions

What is not in version one. Mobile apps, a particular integration, multi-currency, that second user type. This section is short, slightly uncomfortable to write, and prevents more arguments than everything above it combined.

9. Priorities

Must-have, should-have, nice-to-have, with a reason for each must. If everything is a must, nothing can be prioritised and your first release is the entire system. Producing this split is usually the first honest internal conversation a project has.

10. Constraints and decisions

Deadlines with their reasons. Technology constraints with their reasons. Existing systems that are staying. Budget range, if you have one — withholding it wastes everyone's time and does not improve your price.

11. Who decides what

Named people for requirements, design and commercial decisions, with an escalation path. Decision latency is the largest hidden cost in software projects.

What makes a brief unquotable

These are the omissions we see most, and each one forces a supplier to either guess or pad.

Solutions instead of requirements. "We need a dashboard with these twelve charts" states a solution. "Our managers cannot tell which jobs are late" states a requirement, and may have a cheaper answer than a dashboard.

Silence on permissions. Who may see what, left unsaid. It is the most expensive thing to retrofit and it cannot be inferred.

No empty or error states. What a new user sees before any data exists, and what happens when something fails. These are real screens and real behaviour, and leaving them out understates the work substantially.

Everything marked essential. See priorities above.

An unexplained deadline. A date with a reason can be scoped to. A date that is merely preferred produces either a padded quote or a disappointed client.

No mention of who maintains it. If your team will own the software afterwards, that constrains the technology choice, and a supplier who does not know will choose for their own convenience.

Volumes omitted. Architecture for ten users and ten thousand differ, and getting it wrong in either direction is costly — over-engineering is as expensive as under-engineering.

Should you use a formal template?

Probably not a heavyweight one. A plain document answering the sections above in your own words beats a filled-in IEEE-style template with empty headings, because the content is what matters and formal templates encourage completing the form rather than answering the question.

What is worth borrowing from formal practice: numbering your requirements so they can be referenced in a contract and in testing, and stating acceptance criteria for anything ambiguous.

When to pay someone to write it

If the business sections are straightforward for you to write but the data model, permissions and integration feasibility are not — which is the usual position — a short paid discovery phase is the efficient answer. It typically costs a small fraction of a build, produces a specification you own outright, and makes every subsequent quote comparable.

It also occasionally concludes that you should buy a product rather than build, or that the business case does not survive a real estimate. Both are successful outcomes, and both are cheaper to discover in week three than in month six.

Common questions

How long should a requirements document be? Long enough to answer the nine questions and no longer. Ten to twenty pages for most mid-sized projects.

Can we write this ourselves? Yes, and many clients write the business sections well. The common gaps are the permission model and the data relationships, which are hard to specify without technical experience and are the most expensive things to get wrong.

What if requirements change during the build? They will, and a good document anticipates that rather than pretending otherwise. The purpose is not to freeze scope — it is to make changes visible as changes, so both sides can price them rather than argue about what was implied.

Should we specify the technology? Only where you have a real constraint: your team must maintain it, you are committed to a cloud provider, or compliance names something. Otherwise leave it open, let suppliers propose, and ask them to justify the choice against your ability to maintain it.

Will a good document get us a cheaper quote? It will get you a more accurate one, which in practice is usually lower — because the padding a supplier adds for unknowns tends to exceed what removing the unknowns costs.


If you would rather have this produced properly, our software discovery phase delivers the specification, data model, architecture and a costed plan as a fixed fee, and you own the document whether or not you build with us. It is written so any competent developer can quote from it, which is the point.

Want this scoped properly?

Tell us what you need and we will come back with scope, timeline and a rate. No obligation to proceed.