How to Write a PRD: A Practical Guide From Problem to Launch
Not just the template: the process and craft of writing a PRD that engineers, designers and leadership will actually read and use.
A good PRD is short, specific and written to be read. Talk to users, engineers and data first; write the problem in one paragraph; add goals, non-goals and one primary metric with a guardrail; write requirements that are testable, list open questions with owners; review it live and keep it updated after launch.
- First, know who is reading it
- The process, before you open a blank page
- Writing the problem statement
- Goals, non-goals and success metrics
- Writing requirements people can actually build
- Open questions and risks: the section people skip
- Running the review
- Keeping it alive after launch
- Turning requirements into stories, with a full example
- Edge cases worth writing down
- Decide what you will measure before you build
- PRDs for small and large features
- Common mistakes
Most PRDs fail for a boring reason: they are written to be filed, not to be read. Someone fills in a template, shares a link, and everyone nods without really understanding what is being built. A good PRD is the opposite. It is short, it answers the questions people will actually ask, and it lets an engineer make a sensible decision at 4 pm on a Thursday without pinging you.
This guide is about the process and craft of writing one. If you only want the blank structure, use the PRD template and come back here for how to fill it in well.
First, know who is reading it
A PRD has to serve all five, which is why the order matters: the problem first (everyone needs it), the requirements in the middle (engineers and QA live here), and the rollout at the end (support and sales look for it). If you write for only one of these readers, the others will quietly stop reading.
The process, before you open a blank page
Talk first. Spend a few days on three conversations: with users (or their support tickets) to understand the real problem, with an engineer to learn what is hard, and with your data to see how big the problem really is. A PRD written before those conversations is a guess in a nice format.
Frame the problem. Write the problem in one paragraph before anything else. If you cannot do that, you are not ready to write requirements. Then stop and ask someone outside the project to read it. If they cannot tell who is affected and why it matters, rewrite it.
Writing the problem statement
A reliable formula: who has what problem, in which situation, and what evidence shows it is real and how large. Compare:
| Weak | Strong |
|---|---|
| Users need a better search. | Returning job seekers re-enter the same four filters every session; session recordings show 68% of returning users repeat an identical filter set, adding about 40 seconds before their first result. |
| We should add notifications. | Learners who miss two days in a row rarely come back (day-7 retention drops from 41% to 9% in that group). We have no way to bring them back today. |
The strong versions name a person, a situation and a number. They also make it obvious what success would look like, which is the next section. (The numbers here are illustrative.)
Goals, non-goals and success metrics
Goals say what will be better if this works, in outcome terms. Non-goals say what you are deliberately not doing. Do not skip non-goals: they are where scope creep gets stopped, because they give you something written to point at. Success metrics turn the goal into one primary number, one guardrail, a target and a date.
Goal: returning users reach their first result faster.
Non-goal: email alerts for saved searches (separate project, needs notification infrastructure).
Primary metric: share of returning users who create a saved search within 30 days; target 15%.
Guardrail: new-user search completion must not drop.
Writing requirements people can actually build
Requirements are where PRDs go vague. “Should be fast” cannot be built or tested. A good requirement is specific, testable, and describes behaviour, not implementation.
| Vague | Buildable and testable |
|---|---|
| Search should be fast. | Search results appear within 2 seconds for 95% of requests on a 4G connection. |
| Make saving easy. | A “Save this search” button appears after the user applies their first filter and saves in one tap. |
| Handle errors gracefully. | If saving fails, show “Could not save. Try again” and keep the filters applied. |
Write requirements as short user stories with acceptance criteria: “As a returning user, I can save my current filters so that I do not re-enter them next time.” Acceptance criteria then say how you will know it works: the button appears, the search persists after closing the app, it can be deleted. QA and engineering will thank you, and so will you when you check the launch.
Open questions and risks: the section people skip
List what you do not know. “We have not confirmed whether the API supports pagination.” “We do not know how many users have more than ten saved searches.” Each open question should have an owner and a date. This one section builds more trust with engineering than any other, because it shows you know where the risks are instead of pretending there are none.
Running the review
Send the draft to two or three people you trust before the full review, and ask them one question: “what is missing or unclear?” Fix that. Then hold a short review meeting, forty minutes at most, where the group discusses the hard parts (trade-offs, risks, scope) rather than reading the document aloud. Capture decisions in the document itself: “Decision: we will not support editing saved searches in v1.” The point of a review is not approval; it is finding out what you missed while it is still cheap to fix.
Keeping it alive after launch
A PRD that is never updated becomes fiction within a month. Keep a short change log at the top (date, what changed, why). When scope changes, change the document first, then tell people. And after launch add a final section: what actually happened versus the goals. Doing this a few times will make you noticeably better at setting targets.
Turning requirements into stories, with a full example
Here is how the saved-search feature might be written up, in enough detail for engineering and QA to start (illustrative):
| Story | Acceptance criteria |
|---|---|
| As a returning user, I can save my current filters so I do not re-enter them. | A Save button appears after the first filter; tapping it stores the filters with a default name; a confirmation shows for two seconds. |
| As a user, I can open a saved search from my home screen. | Saved searches list appears on home; tapping one applies all filters and shows results within 2 seconds. |
| As a user, I can delete a saved search. | Swipe or tap delete; a confirmation appears; the item is removed and cannot be recovered. |
| As a user with no saved searches, I understand what the feature is. | An empty state explains how to save one and shows an example. |
Notice the fourth row: the empty state. Almost every feature has states that people forget: empty, loading, error, offline, no permission. Listing them in the PRD is one of the cheapest ways to avoid nasty surprises in testing.
Edge cases worth writing down
- What happens on a slow or lost connection?
- What if the user has hit a limit (for example, ten saved searches)?
- What if the underlying data changes (a filter option is removed)?
- What does a brand-new user see?
- Who should not have access to this, and what do they see instead?
- What if two devices change the same item?
You do not need to solve every edge case in the PRD. You need to list them, so that each is either decided or explicitly parked. Anything unlisted is decided by whoever hits it first, usually late.
Decide what you will measure before you build
Add a short analytics section: which events must be tracked so that you can compute the success metric. For saved search: search_saved, saved_search_opened, saved_search_deleted, each with the user and the filters used. If you leave tracking to “later”, you will launch a feature you cannot evaluate. Agreeing the events at PRD time takes ten minutes; retrofitting takes a sprint.
PRDs for small and large features
| Size | What to write | Length |
|---|---|---|
| Small tweak (days) | A ticket with the problem, the change and how to check it | A few lines |
| Feature (weeks) | A full PRD as in this guide | 1 to 2 pages |
| Major initiative (months) | A short strategy note first, then a PRD for each phase | One page plus phase PRDs |
Do not write a heavyweight PRD for a small change; people stop reading them. And do not put a months-long initiative into one PRD; split it into phases that each have their own problem and metric.
Common mistakes
Writing the solution before the problem. Specifying implementation (“use a dropdown”) when you mean behaviour (“the user can choose one option”). Leaving out non-goals. Requirements no one can test. Writing ten pages when two would do. Treating the review as approval theatre. And never updating the document after the plan changes. If you avoid those six, you are already ahead of most PRDs I read.
Next: see the worked, filled-in example in the PRD template, then learn how to choose what to write PRDs for in how to prioritize product features.
Frequently asked questions
What is a PRD in product management?
A product requirements document defines the problem, goals, scope, requirements, success metrics and rollout plan for a feature so that design, engineering, QA and others can build the right thing.
How long should a PRD be?
One to two pages is right for most features. If it runs much longer, the feature is probably too large and should be split, or the document has drifted into implementation details.
Who should write the PRD?
The product manager usually owns and writes it, but the solution and requirements sections should be shaped together with design and engineering, not written alone and handed over.
What is the difference between a PRD and user stories?
A PRD explains the whole picture: problem, goals, non-goals, metrics and rollout. User stories are a way of writing individual requirements inside it, each with acceptance criteria.
Want this sharpened for your specific situation?
I take on a small number of career calls and resume reviews each month.
See how we could work together