How to Write a PRD: Steps, Template and When to Automate It
A step-by-step method for writing a PRD engineers will actually use, a copyable template, a worked example, and an honest split between what to automate and what to keep.
Share
How to write a PRD comes down to order: start with the problem and the evidence for it, then define who it is for, what success looks like, what is in and out of scope, and the requirements engineers will build and test against. A good product requirements document is short, ranked and testable. Write the problem and success metric yourself; let AI draft the boilerplate.
Key takeaways
Poor requirements are expensive: in PMI's 2014 study, 47% of projects that missed their goals did so mainly because of poor requirements management, and 5.1% of every project dollar was wasted (PMI, 2014).
Product people already spend about 18 hours a month articulating and prioritising requirements (Pragmatic Institute, 2019). Most of that time should go into the problem and the trade-offs, not the formatting.
Marty Cagan's rule still holds: rank-order every requirement from 1 to n, and only call something "must-have" if you would not ship without it (SVPG, 2005).
A PRD for a small feature can be one to three pages. Length should follow risk, not habit.
AI drafts structure and edge cases well. It cannot supply the evidence, the decision or the success threshold.
What is a PRD, and what is it not?
A product requirements document (PRD) describes what a product or feature must do, for whom, and why, so a team can build and test it. Cagan's 2005 definition still works: the PRD should "clearly and unambiguously articulate" the product's purpose, features, functionality and behaviour, and it describes one release along the path set by the strategy and roadmap (SVPG, 2005).
A PRD is not a market analysis, a technical design or a roadmap. Mixing them is how PRDs grow until nobody reads them.
Document
Answers
Typical owner
Typical length
Problem statement
Whose problem, in what situation, with what evidence?
If you have not written the problem down yet, start with a product problem statement. The PRD builds on it.
What should a PRD include?
Every useful PRD covers the same core components, whatever the template calls them:
Strategic context. Which company goal or OKR this supports, and why now.
Problem definition. The user friction you are solving, with links to the evidence: interviews, support tickets, usage data.
Target persona. The specific user who has the problem, described narrowly enough that a designer can picture them.
Success metrics. One primary metric with a baseline and a target, plus one or two guardrails that must not get worse.
Scope and out of scope. What this release does and, explicitly, what it does not.
Functional requirements. User-visible behaviour, written as user stories or numbered requirements, each ranked.
Non-functional requirements. Performance, security, privacy, accessibility and latency constraints that are actually known.
Open questions and assumptions. What you do not know yet, who owns finding out, and by when.
Atlassian's own Confluence PRD template uses almost the same set: objective, success metrics, assumptions, a requirements table with user stories and importance, open questions and an out-of-scope list (Atlassian).
Two sections do most of the work: the problem definition decides whether you build the right thing, and the out-of-scope list decides whether the team finishes. Google calls these non-goals: things that could reasonably be goals but are explicitly chosen not to be (Ubl, 2020).
How to write a PRD in 8 steps
This sequence compresses Cagan's ten steps (SVPG, 2005) into eight for a small team shipping one feature.
Write the problem in one paragraph. Who has it, in what situation, what they do today, and what it costs them. No recent, specific instance means you are not ready.
Attach the evidence. Link the interviews, tickets or queries behind each claim. Label anything you believe but have not checked as an assumption.
Set the success metric before the requirements. Name the baseline, the target and the date you will check it. Requirements that do not move the metric are candidates for cutting.
Bring engineering in now, not after. Atlassian's State of Product 2026 survey of more than 1,000 product professionals found 80% of teams still don't involve engineers in ideation, problem definition or roadmap creation (Mind the Product, 2025). A short feasibility conversation here saves a rewrite later.
Draw the scope line. Write the out-of-scope list as carefully as the in-scope list. Shape Up calls these "no-gos" and ties them to an appetite: a fixed time budget such as two weeks or six weeks (Basecamp).
Write the requirements as testable behaviour. Use user stories ("As a…, I want…, so that…") or Given/When/Then acceptance criteria. Cover the empty, loading, error and permission states.
Rank every requirement. Cagan's test: the product should not ship if even one must-have is missing, so the bar for must-have is extremely high. Then rank within each tier from 1 to n so the team knows what to cut when the schedule slips.
Review with the people who will build it, then freeze version 1. Get written sign-off from engineering and design, record open questions with owners, and keep later changes in a visible changelog.
Copyable PRD template
Paste this into Confluence, Google Docs, Notion or Markdown, and delete sections that do not apply. For a downloadable version, use the free PRD template guide.
PRD: [Feature name] Owner: [name] Status: Draft / In review / Approved
Last updated: [date] Reviewers: [eng lead, design lead]
1. EXECUTIVE SUMMARY (5 lines max)
Problem: [one sentence]
Proposal: [one sentence]
Success metric: [metric, baseline -> target, check date]
Appetite: [time budget, e.g. 2 weeks]
2. STRATEGIC CONTEXT
Goal/OKR this supports:
Why now:
3. PROBLEM AND EVIDENCE
Who has the problem (persona + situation):
What they do today (workaround):
Evidence (link each item):
Assumptions we have not checked:
4. USER STORIES (ranked 1..n)
1. As a [persona], I want [action] so that [outcome]. Priority: Must / High-want / Nice
2. ...
5. SCOPE
In scope:
Out of scope (no-gos):
6. REQUIREMENTS AND ACCEPTANCE CRITERIA
R1. Given [state], when [action], then [observable result].
Empty / loading / error / permission states:
7. TECHNICAL CONSTRAINTS AND NON-FUNCTIONAL REQUIREMENTS
Dependencies:
Performance / security / privacy / accessibility:
8. ANALYTICS AND TRACKING
Events to instrument:
Dashboard or query used to check the success metric:
9. OPEN QUESTIONS
| Question | Owner | Due | Answer |
10. CHANGELOG
[date] [what changed and why]
If the feature uses AI, add model behaviour, grounding and evaluation sections from the AI PRD guide. If a coding agent will implement it, use the PRD template for AI coding agents.
What does a good PRD look like? A worked example
This example is illustrative, not a real company. Say a 6-person B2B SaaS team hears that admins struggle to export usage data for their own managers.
Problem: In 5 of the last 12 onboarding calls, admins said they copy figures from three screens into a spreadsheet before their monthly review. Support logged 9 tickets asking for an export in the past 90 days.
Success metric: 40% of active admin accounts use the export at least once within 60 days of launch (baseline: 0%). Guardrail: export-related support tickets do not rise above 3 a month.
Appetite: 2 weeks for one engineer and one designer.
In scope: CSV export of the existing usage table, filtered by date range, for admins only.
Out of scope: Scheduled exports, PDF reports, custom columns, API access.
Must-have requirements (ranked): 1) export the current filtered view as CSV; 2) respect existing role permissions; 3) show a clear error if the export exceeds 50,000 rows.
Open question: Do admins need the export emailed, or is a download enough? Owner: PM, answer due before design review.
That PRD fits on two pages. An engineer can estimate it, and in 60 days the team can check one number and decide whether to invest further.
How long should a PRD be?
As long as the risk demands. A reversible two-week feature needs one to two pages; a change to billing, permissions or data retention needs more detail and more reviewers. Google accepts a 1-3 page mini design doc for incremental work and expects 10-20 pages only for larger systems (Ubl, 2020).
Cagan's critique still applies: typical specs take too long to write, are rarely read and leave the hard questions open (SVPG, 2006). He argued for a clickable prototype as the master spec. Today the practical version is a short PRD plus a prototype link.
Should you write your PRD in Confluence, Google Docs or a dedicated tool?
Write it where engineers already look. Confluence suits teams on Jira, because its PRD template links requirements to issues (Atlassian). Google Docs and Notion suit fast commenting. A Markdown file in the repository suits teams whose engineers or coding agents need it next to the code.
The editor matters less than three habits:
One canonical copy. Link to it from every ticket instead of pasting fragments.
A visible changelog. Record what changed after review, and why.
Evidence links, not summaries. "Customers want this" asks the team to trust you. Links to the 5 calls and 9 tickets let them check.
Which parts of a PRD can you automate with AI?
Drafting is now the cheap part. In Productboard's 2025 survey of 379 product professionals, writing PRDs was a top AI time-saver, at about 4 hours saved per task (Productboard, 2025). The risk: a fluent draft hides decisions nobody made.
PRD part
Safe to automate?
Why
Template structure and formatting
Yes
Pure boilerplate
User stories from an agreed problem
Mostly
Review wording and ranking
Edge cases and error states
Yes, as suggestions
AI is good at listing states you forgot
Acceptance criteria
Draft, then check
Each must be observable and testable
Problem and evidence
No
AI will fill gaps with plausible, unsourced claims
Success metric and target
No
Requires your baseline and your judgement
Scope cuts and priority
No
This is the product decision
Two rules keep automation honest. Give the AI your evidence and ask it to cite it; anything it cannot cite becomes an open question. Then audit the draft before engineering sees it. Our 15-minute claim trace for AI-written specs shows how. For prompts and a step-by-step workflow, read how to write a PRD with AI, or try the free PRD generator for a first draft.
Common PRD mistakes
Most advice on how to write a PRD is about sections. Most PRD failures come from habits:
Starting with the solution. "Build a dashboard" is a feature, not a problem. Rewrite it as the situation that made someone ask for it.
Everything is a must-have. If a dozen items are must-haves, none of them is. Rank them.
No out-of-scope list. Silence on scope invites scope creep, from people and from coding agents.
Metrics without baselines. "Increase engagement" cannot fail, so it cannot teach you anything.
Writing it alone. PMI found 37% of organisations named inaccurate requirements gathering as a primary cause of project failure in 2014, up from 32% the year before (PMI, 2014). Gathering requirements with engineering and design, not for them, is the cheapest fix.
Treating the PRD as finished at sign-off. Record changes and check the success metric after launch, or the document rots.
Where Specky fits
Specky drafts PRDs from the evidence already in your Product Graph: customer calls, feedback, Slack threads and tickets. The PRD Editor keeps inline citations next to each claim, so reviewers can open the source instead of trusting a summary, and drafts wait in the PM Inbox for human review. After launch, it checks the success metric you set. The decisions in this guide stay with you.
Frequently asked questions
What are the main sections of a PRD?
A PRD needs a problem statement with evidence, a target user, success metrics, scope and out-of-scope, ranked functional requirements, non-functional requirements and open questions. Atlassian's Confluence template uses nearly the same list. Add AI behaviour or coding-agent sections only when they apply.
How long does it take to write a PRD?
For a small, well-understood feature, the draft is the quick part once the evidence is gathered; review with engineering and design adds elapsed time. Pragmatic Institute's survey put requirements work at about 18 hours a month. Most delay comes from missing evidence or unresolved decisions, not from typing.
Who should write the PRD?
The product manager or founder owns it, but engineering and design should shape it before it is final. Atlassian's 2026 survey found 80% of teams still bring engineers in after problem definition. Invite your engineering lead to review the problem and scope sections first, when changes are cheap.
What is the difference between a PRD and a technical spec?
A PRD defines what to build and why, from the user's point of view. A technical spec or design doc defines how to build it: architecture, data model, APIs and alternatives considered. Engineers usually write the technical spec after the PRD's problem and scope are agreed. See the technical spec engineers actually read.
Can AI write a PRD for me?
AI can draft the structure, user stories, edge cases and acceptance criteria in minutes. It cannot know your evidence, your baseline or which trade-off you have accepted, and it will often invent plausible reasons. Give it your sources, ask it to cite them, and review every claim before engineering builds from it.
Is a PRD still needed in agile teams?
Yes, in a lighter form. Agile replaced the long upfront spec, not the need to agree on the problem, scope and success metric. Many teams keep a short PRD per epic, link it from every ticket and update it as they learn. Coding agents make a written scope even more useful.
GDPR-aligned. EU workspace data is stored in Frankfurt, Germany. GDPR and EU data Built in Vienna, Austria. A product of influence solutions fm GmbH (FN 675374y). Imprint 14-day trial. Card required, and nothing is charged until day 14. 30-day refund after subscribing. See pricing