Skip to content
Resources · Blog

Software Requirements Document Template for Buyers 

A buyer's requirements template has nine sections, from goals and user roles to acceptance criteria and out of scope. Eight to 15 pages gets a fixed quote.

November 21, 2026 7 min read
ProcurementBuyer's GuideCost Estimation

A software requirements document template for a buyer has nine sections: goals, user roles, key flows, business rules, integrations, data, non-functional requirements, acceptance criteria, and what is out of scope. Fill each one in plain language, at the level of screens, rules and named systems, and three vendors can quote the same project instead of three different guesses. That is the document we ask for before quoting at RNDSOL, and it usually runs 8 to 15 pages, not 60. It does not need to be written by a technical person. It needs to be written by someone who knows how the business works today and what has to change, with an engineer from your side or from the shortlist reviewing it for gaps. Below is the template section by section, the level of detail that supports an accurate fixed quote, why the long formal specification most templates copy tends to go unread, and a check to run before the document goes to vendors. If you are earlier in the process, our custom software development page explains how discovery turns a document like this into a fixed price.

What Should a Software Requirements Document Include?

  • Goals: two or three business outcomes with a number attached, such as cutting order entry from 15 minutes to 3, or letting customers pay online without calling the office
  • User roles: every type of person who logs in, what each one can see and change, and roughly how many of each, for example 4 admins, 30 branch staff and 2,000 customers
  • Key flows: the 5 to 15 journeys that matter, written as numbered steps from the user's side, such as a customer places an order, a manager approves a refund, or finance closes the month
  • Business rules: the logic a developer cannot guess, including pricing, discounts, approval limits, tax treatment, status changes, and what happens when a payment fails halfway
  • Integrations: each external system by name and version, what data moves, in which direction, how often, and whether documentation and a sandbox exist
  • Data: the main records and their fields, the volume today and in three years, what must be migrated from the old system, and how long records must be kept
  • Non-functional requirements: concurrent users, acceptable page load time, uptime target, languages and right-to-left support, browsers and devices, hosting region, and any compliance regime the system must meet
  • Acceptance criteria: for each flow, the test you will run to accept it, written as given, when, then, or as a plain sentence a tester can check
  • Out of scope: the features you discussed and decided against for this phase, listed by name, so nobody prices them and nobody argues about them later

How Much Detail Gets an Accurate Fixed Quote?

Enough that two vendors reading it would list the same screens and the same rules. A useful test is whether an engineer could estimate each flow to within a few days without phoning you. 'Users can manage orders' fails that test; it could mean a list and a status field, or a two-month module with partial shipments, returns and credit notes. 'A branch user creates an order for an existing customer, picks items from the catalog with live stock, applies a discount up to 10 percent on their own and above it with a manager's approval, and the order reaches the warehouse queue' passes. You do not need wireframes for every screen, database schemas or a technology choice; vendors should propose those, and you learn something from how they do it. You do need numbers wherever a number changes the build: how many users, how many records, how many languages, which payment gateway. On the builds we see, the gap between the lowest and highest quote narrows once flows and business rules are written down, because the vendors stop pricing different readings of the same sentence. A vague document does not produce cheaper quotes. It produces padded fixed prices, because each vendor adds contingency for what it cannot see, or low quotes that grow through change requests. Our post on fixed price vs time and materials explains how that contingency is priced.

Why Does a 60-Page IEEE-Style SRS Go Unread?

The formal software requirements specification, modeled on the old IEEE 830 standard and its successor ISO/IEC/IEEE 29148, was designed for large engineering programs with contracts, auditors and long approval cycles. Copied into a small or mid-sized business project, it produces 60 pages of numbered 'the system shall' statements, a glossary, assumption tables and a traceability matrix. Vendors skim it for the parts that drive cost, which are usually buried somewhere in section 3, and the stakeholders who were meant to approve it sign the cover page without reading the middle. The size also hides what matters. When every requirement looks equally formal, a rule that will take three weeks to build sits next to a line about button colors, and nobody can tell which is which. The template above keeps the parts of that tradition that earn their place (acceptance criteria and explicit scope boundaries) and drops the rest. If your organization or a regulator requires the formal format, write the short version first, agree it with the business, and then expand it. The short version is what people will argue about, and that argument is the point of the exercise.

What Does a Good Requirement Look Like?

Take refunds in a retail back office. A weak version reads: 'The system should handle refunds.' A typical formal version reads: 'The system shall provide refund functionality in accordance with company policy,' which says the same thing in more words. A useful version reads: 'A store manager can refund a paid order in full or by line item within 30 days of purchase. Refunds up to $200 are approved by the manager; above $200 they wait for finance approval. Card refunds go back through the payment gateway's refund API; cash orders are refunded as store credit. Stock returns to the branch that made the refund. Accepted when a tester can refund one line of a card order and see the gateway refund, the stock movement and the audit entry.' That paragraph is about 80 words. An engineer can estimate it, a tester can check it, and it names the integration (the gateway's refund API) that a vendor needs to look at before quoting. Most business requirements documents need 20 to 40 paragraphs like it, one per flow or rule set, which is where the 8 to 15 pages come from.

Who Should Write the Requirements, and How Long Does It Take?

The person who owns the business outcome should write the first draft, with input from the people who will use the system daily, because they know the exceptions that never appear in a process diagram. Expect three to five working days of that person's time spread over two or three weeks, plus a few hours each from finance, operations and IT to review the rules and integrations that touch them. Then have an engineer review it for gaps before it goes out: missing error cases, an integration with no documentation, a data volume that changes the architecture. If nobody on your side has the time, buy the document instead. A paid discovery phase of one to two weeks, priced separately, has a vendor's analyst and architect interview your team and produce the requirements, a proposed architecture, a clickable prototype and a fixed quote; ours works that way, and you keep every deliverable even if you build elsewhere. Either route ends in the same place. The software procurement playbook covers what comes next: shortlisting, sending the document out, and comparing quotes line by line.

Checklist Before the Document Goes to Vendors

  • Every goal has a number and a date attached
  • Every user role has a head count and a list of what it can see and change
  • Every key flow is written as steps, with its exceptions, such as a failed payment or a rejected approval
  • Every business rule involving money, approvals or status changes is written out, not described as current practice
  • Every integration names the system, the direction of data, the frequency, and whether a sandbox exists
  • Data volumes and the migration source are stated, with the number of records to move
  • Non-functional requirements give figures: users, response times, uptime, languages, hosting region
  • Each flow has at least one acceptance test a non-engineer could run
  • The out-of-scope list names at least five things you discussed and deferred
  • The whole document fits in 15 pages, and someone outside the project can read it in an hour

Have a project that needs this kind of thinking applied to it?