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.
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.
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.
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.
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.
| Area | You decide | The agency proposes |
|---|---|---|
| Goals and audience | Business objectives, primary users, priority journeys | How the structure and UX support them |
| Scope | Must-have, should-have and out-of-scope lists | Phasing, and what to cut if the budget is tight |
| Business rules | Who can do what, approval steps, pricing and booking rules | How the rules are modelled and enforced |
| Data | Which records exist, who owns them, retention needs | Database design and storage |
| Integrations | Which systems, what data, which system is the source of record | Integration method, sync timing, error handling |
| Quality targets | The thresholds you need (speed, availability, accessibility level) | How they will be met and measured |
| Technology | Hard constraints only (existing platform, hosting region, security policy) | Framework, CMS, hosting and tooling, with reasons |
| Acceptance | What done means for each requirement | The test approach and evidence they will provide |
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.
| Section | What to write | Example |
|---|---|---|
| Business objectives | What the site must achieve, stated explicitly | Generate qualified demo requests from operations managers |
| Audience | Who it is for, what they are trying to do, which devices matter | Mostly mobile visitors comparing providers |
| Pages and sitemap | Every page or template and how they relate | Home, 4 service pages, case-study template, blog, contact |
| Features | Every function beyond content pages, specific enough to estimate | Search across services and articles, filter by industry |
| User roles | Each type of user and what they can see and do | See the permissions matrix below |
| Integrations | Every connected system and the data that flows | See the integration register below |
| CMS and content | Who edits what, how often, and who writes the launch content | Marketing team edits pages and posts weekly; we supply all copy |
| SEO and analytics | Existing URLs to preserve, and the events to track | Redirect all current URLs; track form submits and booking starts |
| Non-functional | Measurable targets for speed, accessibility, security, availability | See the non-functional table below |
| Browsers and devices | The list, based on your own audience data where available | Latest two versions of the main browsers; iOS and Android phones |
| Acceptance criteria | What done means for each major feature | Contact form sends a confirmation email within 30 seconds |
| Out of scope | What is deliberately not included | No multilingual content in phase 1 |
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.
| Role | View | Create | Edit | Approve | Export | Delete |
|---|---|---|---|---|---|---|
| Customer | Own records | Own requests | Own requests until submitted | No | Own invoices (PDF) | No |
| Account manager | Assigned customers | Requests for assigned customers | Assigned customers | Up to a set value | Assigned customers (CSV) | No |
| Operations admin | All | All | All | Any value | All | Draft requests only |
| Finance | Invoices and payments | Credit notes | Invoice status | Refunds | All finance data | No |
| Super admin | All | Users and roles | Users and roles | No | Audit log | Users (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.
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.
| System | Data | Direction | Trigger | Frequency | Source of record | If it fails | Owner |
|---|---|---|---|---|---|---|---|
| CRM | New enquiries, contact details | Site to CRM | Form submitted | Immediately | CRM | Queue and retry; alert sales ops | Sales ops |
| Payment provider | Payments, refunds | Both ways | Checkout; provider webhook | Immediately | Payment provider | Show a pending status; reconcile daily | Finance |
| Accounting | Invoices | App to accounting | Invoice issued | Hourly batch | Accounting system | Retry; daily mismatch report | Finance |
| Email platform | Marketing consent | Site to platform | Consent ticked | Immediately | Email platform | Retry; never send without consent | Marketing |
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.
| Area | Testable format | How it is checked |
|---|---|---|
| Page speed | Key templates meet [target] for Largest Contentful Paint on a mid-range phone | Lab tests before launch; field data after launch |
| Accessibility | Meets WCAG 2.2 Level AA on the sampled pages and journeys | Automated scan plus manual keyboard and screen reader testing |
| Availability | Available [X]% of each month, excluding announced maintenance | Uptime monitoring report |
| Capacity | Handles [N] concurrent users on the booking flow without errors | Load test on a staging copy |
| Security | No open high-severity findings at launch; reviewed against the OWASP Top 10 | Security scan and review report |
| Data recovery | Backups every [period]; restore tested to within [time] | A documented test restore |
| Browsers and devices | Works on the agreed browser and device list | Test log against the list |
| Data retention | Enquiries deleted after [period] unless converted to customers | Scheduled job and spot check |
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.
| Untestable | Testable rewrite |
|---|---|
| The site should be fast | Home and service templates meet the agreed Largest Contentful Paint target on a mid-range phone |
| Easy to update | A 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 account | A customer can change their email, password and billing address; it's done when each change is confirmed by email |
| Admins can see everything | Operations admins can view all bookings, filtered by date, status and location (see permissions matrix) |
| Integrates with our CRM | Each enquiry creates or updates a CRM contact within 5 minutes; failures retry and alert sales ops |
| Mobile friendly | All pages work without horizontal scrolling on the agreed device list |
| Secure | Admin accounts require multi-factor authentication; sessions expire after the agreed idle time |
| Accessible | Meets WCAG 2.2 AA on the sampled pages and journeys, with an audit report |
| Good SEO | Every current URL redirects to its closest new page with a permanent redirect; titles and meta descriptions are editable |
| Reports for management | A monthly CSV of bookings by location and status can be downloaded by finance and super admins |
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.
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.
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.
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.
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.
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.
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.
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.