Skip to content
Web Development13 min read

Website and Web App Requirements Document: What to Include (With Template)

What a website or web app requirements document should include: a permissions matrix, integration register, testable requirements and a copyable template.

01

What should a website requirements document include?

A good requirements document states what the site or app must achieve, for whom, and how you will know each part is done. For a website, that means objectives, audience, a page list, features, forms, integrations, content and CMS needs, analytics events, non-functional requirements (performance, accessibility, security, browsers) and acceptance criteria. A web app adds a roles and permissions matrix, data records, an integration register with direction and timing, notifications, admin tools, data migration, audit logging and environments. Every requirement should be testable, and the document should say what is out of scope.

This guide is for founders and managers briefing agencies or freelancers before asking for quotes. It updates our earlier checklist with a permissions matrix, an integration register, measurable non-functional requirements, an untestable-to-testable rewrite table and a copyable two-tier template.

02

Key takeaways

  • Agencies can only give comparable quotes if they price the same written scope.
  • Decide the business rules yourself; let the agency propose the technology.
  • Write each requirement so a tester could prove it passed or failed.
  • Web apps need a permissions matrix and an integration register; brochure sites rarely do.
  • Say what is out of scope. Unlisted items are where most change requests come from.
03

Which document is this, and which do you need?

This is the pre-vendor scope brief: the document you send to agencies so they can estimate and so you can accept the finished work. It is not a feature-level product spec. Once you have a team, individual features are usually specified in more depth; see how to write a product requirements document for that later stage, and technical discovery for the work an agency does to firm up estimates.

If you are not sure whether you are building a website or a web application, settle that first. Logins, stored customer data, roles and multi-step workflows change the size of the document and of the project; this comparison of custom websites and web applications explains the difference.

04

What you decide and what the agency proposes

Founders often over-specify the technology and under-specify the business rules. The split below keeps you in charge of the decisions only you can make, and leaves agencies room to compete on how they solve them.

AreaYou decideThe agency proposes
Goals and audienceBusiness objectives, primary users, priority journeysHow the structure and UX support them
ScopeMust-have, should-have and out-of-scope listsPhasing, and what to cut if the budget is tight
Business rulesWho can do what, approval steps, pricing and booking rulesHow the rules are modelled and enforced
DataWhich records exist, who owns them, retention needsDatabase design and storage
IntegrationsWhich systems, what data, which system is the source of recordIntegration method, sync timing, error handling
Quality targetsThe thresholds you need (speed, availability, accessibility level)How they will be met and measured
TechnologyHard constraints only (existing platform, hosting region, security policy)Framework, CMS, hosting and tooling, with reasons
AcceptanceWhat done means for each requirementThe test approach and evidence they will provide
05

The core sections, with what to write

These are the sections from our original checklist, each with the level of detail that makes it quotable. For a five-page site, a sentence or two per section is enough; for a web app, most will grow into lists.

SectionWhat to writeExample
Business objectivesWhat the site must achieve, stated explicitlyGenerate qualified demo requests from operations managers
AudienceWho it is for, what they are trying to do, which devices matterMostly mobile visitors comparing providers
Pages and sitemapEvery page or template and how they relateHome, 4 service pages, case-study template, blog, contact
FeaturesEvery function beyond content pages, specific enough to estimateSearch across services and articles, filter by industry
User rolesEach type of user and what they can see and doSee the permissions matrix below
IntegrationsEvery connected system and the data that flowsSee the integration register below
CMS and contentWho edits what, how often, and who writes the launch contentMarketing team edits pages and posts weekly; we supply all copy
SEO and analyticsExisting URLs to preserve, and the events to trackRedirect all current URLs; track form submits and booking starts
Non-functionalMeasurable targets for speed, accessibility, security, availabilitySee the non-functional table below
Browsers and devicesThe list, based on your own audience data where availableLatest two versions of the main browsers; iOS and Android phones
Acceptance criteriaWhat done means for each major featureContact form sends a confirmation email within 30 seconds
Out of scopeWhat is deliberately not includedNo multilingual content in phase 1
06

Roles and permissions matrix

If anyone logs in, write a matrix. List roles down the side and actions across the top, and say which records each permission applies to. "Own" and "team" matter as much as yes or no, because they decide how data is filtered and are a common source of security bugs. The example below is for a hypothetical client portal.

RoleViewCreateEditApproveExportDelete
CustomerOwn recordsOwn requestsOwn requests until submittedNoOwn invoices (PDF)No
Account managerAssigned customersRequests for assigned customersAssigned customersUp to a set valueAssigned customers (CSV)No
Operations adminAllAllAllAny valueAllDraft requests only
FinanceInvoices and paymentsCredit notesInvoice statusRefundsAll finance dataNo
Super adminAllUsers and rolesUsers and rolesNoAudit logUsers (deactivate, not delete)

Pro tip

Add a row for what happens when someone leaves: who reassigns their records, and whether accounts are deactivated rather than deleted so the history stays intact.

07

Integration register

"Integrates with our CRM" can mean a one-off export or a two-way live sync with conflict rules, and the effort differs widely. A register forces the questions that drive the estimate. Fill in one row per connection; if you do not know an answer, write "unknown" so the agency can flag it rather than assume. For how these factors affect effort, see how to estimate API integration cost, and for the technical basics, how website API integrations work.

SystemDataDirectionTriggerFrequencySource of recordIf it failsOwner
CRMNew enquiries, contact detailsSite to CRMForm submittedImmediatelyCRMQueue and retry; alert sales opsSales ops
Payment providerPayments, refundsBoth waysCheckout; provider webhookImmediatelyPayment providerShow a pending status; reconcile dailyFinance
AccountingInvoicesApp to accountingInvoice issuedHourly batchAccounting systemRetry; daily mismatch reportFinance
Email platformMarketing consentSite to platformConsent tickedImmediatelyEmail platformRetry; never send without consentMarketing
08

Non-functional requirements you can measure

Non-functional requirements describe how well the system works rather than what it does. "Fast", "secure" and "scalable" cannot be tested. Write each one as a measurable statement with a method of checking it. The numbers below are placeholders: choose them from your own traffic, audience and risk, or ask the agency to propose them with reasons.

AreaTestable formatHow it is checked
Page speedKey templates meet [target] for Largest Contentful Paint on a mid-range phoneLab tests before launch; field data after launch
AccessibilityMeets WCAG 2.2 Level AA on the sampled pages and journeysAutomated scan plus manual keyboard and screen reader testing
AvailabilityAvailable [X]% of each month, excluding announced maintenanceUptime monitoring report
CapacityHandles [N] concurrent users on the booking flow without errorsLoad test on a staging copy
SecurityNo open high-severity findings at launch; reviewed against the OWASP Top 10Security scan and review report
Data recoveryBackups every [period]; restore tested to within [time]A documented test restore
Browsers and devicesWorks on the agreed browser and device listTest log against the list
Data retentionEnquiries deleted after [period] unless converted to customersScheduled job and spot check
09

Rewriting untestable requirements

ISO/IEC/IEEE 29148 is the international standard for requirements engineering processes and the documents they produce. Published summaries of it describe the qualities a well-formed requirement should have; among them, each requirement should be unambiguous, singular (one thing per statement), feasible and verifiable. The GOV.UK Service Manual makes the same point in plainer language: acceptance criteria are often written as a list beginning "it's done when…", and user stories name who the user is, what they need and why.

Run your draft through this table. If a requirement could not fail a test, rewrite it.

UntestableTestable rewrite
The site should be fastHome and service templates meet the agreed Largest Contentful Paint target on a mid-range phone
Easy to updateA marketing user can publish a new case study, with images, without developer help; it's done when one is published during acceptance
Users can manage their accountA customer can change their email, password and billing address; it's done when each change is confirmed by email
Admins can see everythingOperations admins can view all bookings, filtered by date, status and location (see permissions matrix)
Integrates with our CRMEach enquiry creates or updates a CRM contact within 5 minutes; failures retry and alert sales ops
Mobile friendlyAll pages work without horizontal scrolling on the agreed device list
SecureAdmin accounts require multi-factor authentication; sessions expire after the agreed idle time
AccessibleMeets WCAG 2.2 AA on the sampled pages and journeys, with an audit report
Good SEOEvery current URL redirects to its closest new page with a permanent redirect; titles and meta descriptions are editable
Reports for managementA monthly CSV of bookings by location and status can be downloaded by finance and super admins
10

Copyable template: website, plus web app extras

Copy the sections that apply. Tier 1 covers a marketing or content website. Tier 2 adds the sections a web app with logins, records and workflows needs. Number every requirement (for example R-12) so quotes, test notes and change requests can refer to it.

Tier 1: website

  • Document control: version, date, author, approver.
  • Background: the business, the problem, why now.
  • Objectives: two to five measurable business goals.
  • Audience: primary users, their main tasks, key devices.
  • Pages and templates: full list with a sitemap.
  • Features: numbered, each with acceptance criteria ("it's done when…").
  • Forms: fields, validation, where submissions go, confirmation messages.
  • Content: who writes, supplies and migrates it; CMS editing needs.
  • Integrations: the register table.
  • SEO and analytics: URLs to preserve, redirect needs, events to track.
  • Non-functional requirements: the measurable table.
  • Browsers and devices: the supported list.
  • Out of scope, assumptions and open questions.
  • Priorities: must, should, could, won't.
  • Acceptance and handover: how sign-off works; accounts, code and documentation you will receive.
11

Tier 2: extra sections for a web app

Add these to Tier 1 when people log in, data is stored or work moves through steps. Agencies tend to price these sections very differently, so they matter most for comparable quotes.

  • Roles and permissions matrix, including what happens when a user leaves.
  • Data records: the main entities (customer, booking, invoice), key fields, who owns each, retention.
  • Workflows and statuses: each step, who moves an item on, and what triggers notifications.
  • Notifications: email, SMS or in-app; the trigger, recipient and content for each.
  • Admin and back-office tools: what staff manage without a developer.
  • Reporting and exports: who needs which figures, how often, in what format.
  • Audit log: which actions are recorded, with who and when.
  • Data migration: what comes from the old system, how much, and who cleans it.
  • Environments: development, staging and production; who can deploy.
  • Privacy and legal: personal data collected, consent, where data is hosted, deletion requests.
  • Support after launch: response expectations and who owns hosting and monitoring.
12

Hypothetical example: two quotes that finally match

Hypothetical example: a training company sends a one-page brief asking for "a website with a booking system and CRM integration". One agency quotes for a booking form that emails staff; another quotes for a booking app with payments, waitlists and a two-way CRM sync. Neither is wrong, and the quotes cannot be compared.

The company rewrites the brief using the template. The permissions matrix shows three roles (learner, trainer, admin). The integration register shows that bookings go one way to the CRM within minutes and payments come from the payment provider's webhooks. Waitlists move to "could have". Re-quoted against the same document, the two agencies now differ mainly on approach and team, which is the comparison the company wanted to make.

13

Common mistakes

  • Describing solutions ("use a headless CMS") instead of needs ("marketing publishes daily without developers").
  • Leaving out admin, reporting and back-office needs, which are often a large share of a web app.
  • Writing "integrates with X" without direction, timing or source of record.
  • No out-of-scope list, so every assumption becomes a dispute.
  • Adjectives as requirements: fast, secure, intuitive, scalable.
  • Forgetting content: who writes it and who loads it.
  • Not versioning the document, so nobody knows which draft was quoted.
  • Once the build starts, the baseline only helps if changes go through a process; see how to control scope creep during delivery.
14

When a long document is the wrong tool

A detailed specification is not always the best path. If the product is new and the main risk is whether anyone wants it, a short brief plus a paid discovery phase or prototype may teach you more than pages of requirements written in advance; see how to prioritise an MVP. Detail also goes stale: in an agile build, keep the scope brief stable and let feature detail evolve in the backlog, with acceptance criteria written just before each item is built.

The document also cannot fix an unclear decision. If two stakeholders disagree about who can approve refunds, writing both versions down is useful, but someone still has to decide before the agency can estimate.

15

Sources

GOV.UK Service Manual: writing user stories (last updated 23 May 2016); GOV.UK Service Manual: learning about users and their needs; ISO/IEC/IEEE 29148:2018, Requirements engineering (catalogue page; the standard's text is paid, so it is described here only at a high level from published summaries); W3C: Web Content Accessibility Guidelines (WCAG) 2.2; OWASP Top 10:2025.

Accessed 14 October 2026.

16

Conclusion

A requirements document is the cheapest point in a project to find disagreements. Decide the goals, rules and priorities yourself, write each requirement so it can be tested, add a permissions matrix and an integration register if anyone logs in, and list what is out of scope. Then send the same version to every agency and compare their quotes against it. When you are ready for the next step, the website project planning guide covers sequencing, and our website and web app development page explains how we work.

Get a scope reviewed

ZSpace Labs is a remote-first technology studio that works with clients globally on websites and web applications. If useful, send us your draft requirements and we can talk through the gaps and open questions before you go to agencies.

Start a Project
FAQ

Common questions.

A structured document defining a website project's business objectives, audience, pages, features, user roles, integrations, content needs, non-functional requirements and acceptance criteria. It is the shared reference that both the client and the development team work from, and the document agencies quote against.

Ideally both sides. The business provides goals, audience, content direction, rules and priorities; the development team translates that into technical requirements and identifies gaps or open questions. The founder should own the final version.

Yes, even a lightweight version. Two or three pages covering goals, a page list, forms and integrations, and how you will accept the work still prevents the most common source of scope disputes: misaligned expectations.

Scope tends to drift, quotes cannot be compared, feedback cycles get longer, and disagreements about what was agreed become more likely. It is one of the most common and most avoidable causes of project delay and cost overrun.

It can include high-level direction, such as brand guidelines and examples of sites you admire, but detailed visual design usually comes later, informed by the requirements rather than specified within them.

Specific enough that both sides can objectively agree whether a feature is done. "The site should work well" invites disputes; "the contact form sends a confirmation email within 30 seconds" does not.

Yes, if scope genuinely changes. Changes should be deliberate, agreed and recorded with a version number, not quietly absorbed without updating the reference both sides are working from.

No. It defines what is being built; the project planning guide and timeline guide cover how and when it gets built.

Only if you have a genuine constraint, such as an existing platform your team already runs, a security policy or a hosting region you must use. Otherwise state the outcome you need and ask each agency to propose and justify its technology. Naming a stack too early can rule out better options or commit you to one you do not need.

A table with user roles down one side and actions across the top (view, create, edit, approve, export, delete), with each cell saying whether that role can do it, and on which records. It turns a vague line such as "admins can manage everything" into something a developer can build and a tester can check.

Get in touch

Have a project in mind?

Whether you're building a new digital product, improving an existing website, or looking to automate part of your business — let's talk.