Skip to content
← All guides

Product requirements

Free Product Requirements Document Template

Use this product requirements document template to turn customer evidence and a clear decision into a reviewable plan. A strong PRD defines who has the problem, what outcome matters, what the team will build, how requirements will be verified, what is out of scope, and what remains uncertain.

For Product managers, technical founders, product engineers, and AI product builders writing a PRD for a real product decisionLast updated 2026-11-1513 min read

What is a PRD supposed to do?

A PRD creates a shared working agreement around a product change. It gives product, design, engineering, QA, support, and stakeholders the same answer to five questions: why now, for whom, what outcome matters, what is in scope, and what remains uncertain.

The best PRD is not the longest one. It is the smallest document that lets the team make a good decision, build without avoidable ambiguity, and revisit the reasoning when new evidence appears.

  • A problem statement grounded in customer or product evidence.
  • A target user or segment and the situation in which the problem occurs.
  • A measurable outcome and a clear definition of success.
  • In-scope behavior, non-goals, constraints, and open questions.
  • A review path that keeps the document current as the team learns.

How do you start a PRD with the problem, not the feature list?

Open with the decision the team is making and the evidence that makes it worth making now. Include representative customer language, observed behavior, a metric, or a delivery constraint. Separate what is directly observed from what the team believes it means.

A feature request is a useful signal, but it is rarely the complete problem. Rewrite it as a situation, user, friction, and consequence so the team can consider more than one solution.

The goal is not to make the roadmap look certain. The goal is to make the next decision easier to inspect, discuss, and change.

What does a free product requirements document template include?

Copy this outline into Docs, Notion, GitHub, or your team's preferred workspace, or download an editable Word or Markdown file. Replace the brackets with evidence and decisions; remove sections that do not affect this change. If something is unknown, label it as an open question instead of filling it with a guess.

Copy the outline into Docs, Notion, or GitHub, or download an editable Word or Markdown file.

# [Feature or product change] — Product requirements document (PRD)

Owner: [name]    Status: [draft / in review / approved]    Updated: [date]

## 1. Problem and evidence
- User and situation: [who is trying to do what, and when?]
- Observed problem and consequence: [what happened, and why does it matter?]
- Evidence (source and date): [interview, support issue, product behavior, or other signal]
- Current workaround: [what do people do today?]
- Facts and assumptions: [separate what is known from what is inferred]

## 2. Desired outcome
- Customer outcome: [what should become easier or better?]
- Success measure and baseline: [metric, current value, and target if justified]
- Review window: [when will the team inspect the result?]

## 3. Scope and constraints
- In scope: [smallest useful end-to-end change]
- Non-goals: [what this change will not solve]
- Constraints and dependencies: [technical, privacy, business, or operational]

## 4. Requirements and acceptance criteria
- R1 — [observable user or system behavior] ([must / should / could])
  Acceptance: Given [context], when [action], then [observable result].
- R2 — [observable behavior]
  Acceptance: Given [context], when [action], then [observable result].

## 5. Risks, edge cases, and safeguards
- Empty, error, and recovery behavior: [what should happen?]
- Privacy, permissions, accessibility, and performance: [relevant constraints]
- Rollout, support, or operational risks: [what needs a guardrail?]

## 6. AI behavior and evaluation (if this change uses a model)
- AI responsibility and approved context: [what may the model do, and which sources may it use?]
- Uncertainty and recovery: [when should it ask, abstain, or hand control back?]
- Evaluation: [representative cases, failure modes, and pass thresholds]
- Human review: [which outputs or actions need approval?]

## 7. Open questions and riskiest assumptions
- Question or assumption: [what could change the decision?]
  Owner: [name]    Evidence needed: [signal]    Decide by: [date]

## 8. Launch and learning
- Rollout: [how and to whom will this ship?]
- Events or checks: [what will be observed?]
- Guardrails: [what must not get worse?]
- After [review window], decide to continue, revise, or stop based on [evidence].

How does a PRD handle a failed CSV import?

This fictional scenario shows how to fill the template; it is not customer evidence or a Specky result. Replace the assumptions with signals from your own users before treating them as a product decision.

  1. 01

    Problem and evidence

    Assumption to verify: when CSV validation fails, admins cannot tell which rows need attention, so they restart the upload or ask for help. Attach the interviews, support tickets, or behavior data that confirm or challenge this.

  2. 02

    Outcome

    Help an admin recover from a failed import without starting over. Record the current recovery rate as the baseline, then set a target only after checking the data.

  3. 03

    Scope and non-goals

    Show the row number, field, and reason for each rejected row while preserving accepted rows. Do not silently rewrite customer data or add unrelated import formats.

  4. 04

    Requirement and acceptance

    Given a CSV with invalid values in rows 4 and 9, when validation finishes, show a specific reason for each row and let the admin download the error list.

  5. 05

    Open question and learning

    Decide whether admins should retry only rejected rows or revalidate the full file. Review recovery completion and support requests after release; confirm valid rows are not lost.

How do you define the user, outcome, scope, and non-goals?

Name the primary user and the moment that matters. If several audiences are affected, identify the primary one and explain what the others need. This keeps the first release from becoming a negotiation between every possible stakeholder.

Then state the desired outcome, the smallest useful scope, and the work the team is explicitly not taking on. Non-goals protect the team from silently expanding the promise while it is building.

  1. 01

    User and situation

    Who is trying to do what, and what must be true for the problem to occur?

  2. 02

    Outcome

    What observable customer or business change should improve, and when will you inspect it?

  3. 03

    Scope

    What is the smallest end-to-end workflow that can create or test that outcome?

  4. 04

    Non-goals

    Which adjacent requests, edge cases, platforms, or future phases are outside this decision?

How do you write requirements as behavior the team can verify?

Describe user-visible behavior and important system conditions without dictating implementation unnecessarily. A requirement should help someone determine whether the workflow works, fails safely, or needs a decision—not merely restate a feature name.

Include meaningful failure states, permissions, data handling, accessibility, analytics, and rollout considerations that could change the design. Keep acceptance criteria observable and link to designs or technical notes when they exist.

  • The user action and the result they should see.
  • Validation, empty, loading, error, and recovery states.
  • Roles, workspace boundaries, privacy, and retention expectations.
  • Events or measures needed to inspect the outcome.
  • Acceptance criteria written as observable checks.

How do you make uncertainty visible and keep the PRD alive?

Add assumptions and questions with an owner and a next step. Mark which unknowns block a decision, which can be tested during implementation, and which are acceptable for the first release. Record trade-offs such as speed over flexibility or a narrower segment over broad coverage.

Review the document with the people who will make and operate the change. After shipping, add the result and remaining uncertainty. A PRD that records what happened becomes product memory; a frozen document becomes another disconnected project file.

How do you hand an approved PRD to an AI coding tool?

A coding agent can implement a clear requirement quickly, but it cannot resolve unstated product decisions. When you use Cursor, Claude Code, or another AI coding tool, give it the approved PRD as the scope for one change. Keep open questions marked as unknowns; do not ask the agent to turn them into silent product decisions.

Ask the agent to restate the user problem, in-scope behavior, non-goals, constraints, acceptance criteria, and its plan before editing code. When requirements are clear, it can proceed after sharing its plan. If a conflict or missing answer could change product behavior, have it stop and ask first. Then review the result against the approved criteria and record anything that was deferred or could not be verified.

Implement one approved, bounded change from this PRD. Do not silently expand the scope.

Before editing, read the repository instructions (AGENTS.md, CLAUDE.md, and any instructions for the files you will touch) and the relevant engineering rules. Summarize the user problem, in-scope behavior, non-goals, constraints, acceptance criteria, and your plan. If requirements are clear, continue without waiting for another approval. If a conflict or missing product decision could change behavior, stop and ask. Do not invent customer evidence, metrics, or requirements.

When working in Specky through its coding-agent integration, retrieve the relevant engineering rules and call validate_agent_plan with your plan before coding.

Implement the smallest end-to-end slice that meets the acceptance criteria.

Follow the repository instructions to run relevant tests, type checks, lint, and any required build checks. Do not claim a check passed unless it ran; report skipped checks and why. Review the diff for authorization, data scope, privacy, migrations, and operational impact. When working in Specky through its coding-agent integration, call validate_agent_change with the changed files, diff summary, and actual verification results before reporting success.

Afterward, report the files changed, how each criterion was checked, check results, deviations, and unresolved questions.

Approved PRD:
[paste the PRD here]
  • Use one user outcome and one bounded change as the agent's task.
  • Keep non-goals and unknowns visible; stop for missing decisions that could change behavior.
  • Read project instructions, run relevant checks, and report what remains unverified.
  • When connected to Specky, use its plan and change validation gates.
  • Review the implementation and its evidence before treating the PRD as complete.

Where Specky fits

Keep the evidence attached to the work.

Specky connects customer signals, research, decisions, specs, tickets, and outcomes in one Product Graph. It drafts and connects the work; your team reviews and decides.

Questions people ask about this topic

What should a product requirements document template include?+

A useful PRD template covers the user problem and evidence, desired outcome, scope and non-goals, verifiable requirements and acceptance criteria, constraints, open questions, rollout, and how the team will review results. Adapt it to the decision instead of filling every section by default.

Can I copy a product requirements document template?+

Yes. Copy the outline into Docs, Notion, GitHub, or another editor, or download an editable Word or Markdown file. Tailor it to the change and mark unknowns clearly; the template is a decision aid, not proof that the problem is understood.

How long should a PRD be?+

Long enough to explain the problem, evidence, outcome, scope, behavior, constraints, and open questions for the decision. A small change may need one page; a risky cross-functional change may need more.

What is the difference between a PRD and a technical specification?+

A PRD defines the customer problem, desired outcome, product behavior, scope, and trade-offs. A technical specification explains how the system will implement it. They can link to each other without becoming one document.

What should an AI PRD include that a normal PRD does not?+

Name the model's responsibility, approved context and data, expected behavior, uncertainty and failure handling, evaluation cases and pass thresholds, and where human review is required.

Can AI write a PRD?+

AI can structure evidence and draft a first PRD. The team still needs to verify sources, make trade-offs, approve scope, and own the outcome.

How do I use a PRD with an AI coding tool?+

Give the tool an approved PRD with one bounded change, observable acceptance criteria, constraints, and non-goals. Ask it to surface missing or conflicting requirements before editing, then review the result against the criteria. Keep product decisions and final approval with the team.

What should not be in a PRD?+

Avoid unsupported customer claims, hidden decisions, unchosen implementation detail, an unbounded feature backlog, and metrics nobody can inspect. Mark those as unknowns or move them to the right linked artifact.

Continue exploring