Product
How to Write a PRD for a Working Demo
Quick Answer
A PRD for a working demo should do more than list features. Beyond problem, goals, users and out-of-scope items, it needs four durability sections covering the data model, the permission matrix, a map of screen states and the logging and proof requirements, with every requirement written so it can be tested. Naming what version one will not build, and structuring the document so a person or an AI coding tool can follow it, turns a prototype into a product.
Knowing how to write a PRD matters more once a working demo exists. A PRD, or product requirements document, is a short decision-forcing document that says what you are building, for whom, why it matters, and how you will know it worked. In 2026, it has a second job, which is to be the instruction set an AI coding tool or an engineering team builds from. That makes the PRD the place where the parts that turn software from fragile to durable get decided.
If you already have a working demo, the question is not how to write a feature list. The AI already gave you features. The real question is how to write a PRD that produces a product, something that survives a second user, a refund, a role change, a lost password, partial data, and an audit. In this guide we cover the four sections most PRDs skip, then give you a copyable template.
What the PRD Is Actually For When Your Prototype Works
Tools like Lovable, Bolt, Replit, Cursor, and Claude Code are good at producing the visible part of software. They can create screens, flows, and happy-path interactions quickly. What they do not decide for you are the business rules beneath the demo.
That means we want your PRD to cover the five things the prototype silently assumed:
- the data model
- who can see and do what
- what happens when things are empty, invalid, or broken
- what must be logged and provable
- what happens when the product is used by a second person, team, or edge case
A demo is a promise. A product is a system. The difference is usually not more features; it is fewer surprises.
The Durable PRD With Four Sections That Decide the Outcome
Most guides already teach the basics, including problem statement, goals, users, user stories, functional requirements, and out-of-scope items. We keep those. But if you want something buildable from a working prototype, add four sections that almost nobody writes well.
1. The Data Model
Write down the nouns in your business, not the pages in your app. If you cannot describe the things your product stores, relates, and protects, you do not yet have a specification.
2. The Permission Matrix
Define who can see, create, edit, approve, delete, export, and administer each object. Permissions are a product decision, not an implementation detail.
3. The State Map
Every screen should declare what happens when it is empty, loading, partial, failed, offline, or access-restricted. This is where most demos break in real use.
4. The Log and Proof Requirements
Specify what changes need an audit trail, what events need timestamps, and what must be recoverable or explainable later. If money, access, or sensitive records are involved, this is not optional.
Those four sections are also how we start work, with data model and architecture first, then senior review, then test coverage, CI/CD, and observability from day one. The codebase is the customer’s, so the specification has to protect it. For a related view of the gap between a demo and a product, see a working demo and a product you can scale are different jobs.
How to Write the Data Model Section Without Reading Code
You do not need to write database syntax in your PRD. You need to write business nouns clearly enough that an engineer can model them correctly.
We use this five-question test for every noun:
- What is it called?
- What uniquely identifies it?
- What does it belong to or connect with?
- What states can it be in?
- What happens when it is deleted, archived, or replaced?
Here is a plain-English example:
- Customer is the person or company buying the service. It has name, email, billing status, and account owner.
- Subscription belongs to one customer. It has plan, renewal date, status, and payment method.
- Invoice belongs to one customer and one billing period. It has amount, currency, due date, paid status, and receipt link.
- Note belongs to a customer record. It has author, timestamp, and visibility level.
This section saves rewrites because it forces the questions that otherwise get answered later by accident. A working demo can hide bad data choices. Real users cannot.
Who Can See and Do What in the Permission Matrix
We write permissions as a table with roles down the side and actions across the top. Keep it blunt. If the answer is “maybe,” the answer is no until clarified. Our reference for the principle is the OWASP Authorization Cheat Sheet, which recommends enforcing least privilege.
Example structure:
- Roles include owner, admin, member, viewer, and support.
- Actions include view customer data, edit billing, invite users, delete records, export data, change access, and view logs.
Three questions catch most access bugs before they exist:
- Can one customer ever see another customer’s data?
- Can a role grant itself more access?
- What happens to access when someone leaves the company or is deactivated?
Founders often assume permissions are a later engineering concern. They are not. If you want a product that can be sold, supported, or audited, access rules belong in the PRD.
Every State a Screen Can Be In
Most demo specs describe the happy path. Real products need the unhappy path, so for every key screen or flow we write out the six standard states in the PRD:
- empty
- loading
- partial
- error
- offline or unavailable
- permission denied
For example, a payments page is not complete until you say what happens if there are no transactions yet, if a request times out, if a payment fails halfway through, or if the user does not have billing access.
Specifying failure is the cheapest quality work you will ever buy. It is also the difference between “it worked in the demo” and “it worked for the first ten customers.”
What Must Be Logged and What Must Be Provable
Analytics tell you what users did in aggregate. Audit logs tell you who changed what, when, and from where. They are not the same thing.
At minimum, we would expect most serious products to record events for:
- money changed
- access changed
- sensitive data viewed or exported
- records created, edited, deleted, or restored
This becomes mandatory fast if you are anywhere near finance, health, regulated workflows, or enterprise procurement. Even if you are not, logging is how you debug, support, and trust the system later, so it belongs in the PRD.
What Makes a Requirement Testable
Good PRDs are not poetic. We want them testable. If someone cannot build a test from your sentence, the sentence is too vague.
Turn “make onboarding easy” into something like this:
- When a new user signs up, they must reach the dashboard in under three steps.
- If required information is missing, the system must show a field-level error and prevent submission.
- After submission, the user receives confirmation by email and sees a success state in the app.
A simple way to write testable requirements is the Given-When-Then pattern, even if you never use the label:
- Given a user with viewer access...
- When they open the billing page...
- Then they can see invoices but cannot edit payment details.
Three questions keep your PRD honest. Can two people read this the same way, can someone build a test for it, and would you know tomorrow if it was met?
Non-Functional Requirements a Non-Technical Founder Should Include
Do not leave these basics out of your PRD just because they are not glamorous. We write down the system expectations that matter to the business:
- how fast it needs to feel
- how many users or records it must handle
- how much downtime you can tolerate
- what data must be backed up
- how quickly it must be recoverable
One common mistake is assuming non-functional requirements are “engineering detail.” They are not. If your product loses data, cannot recover, or becomes unusable under normal load, it is not a product.
What to Cut From Version One in Writing
A PRD should also say what you are not building. That is not pessimism; it is discipline. We cover the scoping side in how to decide what to cut from your MVP scope.
We use a simple not-building-in-v1 list:
- not supporting multi-currency
- not allowing self-serve role creation
- not building a mobile app
- not supporting bulk imports in v1
- not adding custom reporting until after pilot feedback
This matters because a clear no protects the yes. It keeps the first version narrow enough to ship and broad enough to learn from. If you are planning MVP development around this list, The Founder’s Playbook covers the wider decisions.
How to Write a PRD That an AI Coding Tool Will Follow
If you are using Claude Code, Cursor, or another code-generating workflow, the PRD should be structured for predictable parsing by a human and a machine. We structure it this way, which means we:
- use clear headings
- keep requirements atomic
- state constraints as constraints, not preferences
- avoid mixing business goals with solution details
- put source-of-truth artifacts in the same repo or linked workspace
One thing still does not change. AI can produce code quickly, but it still needs a senior human reviewer to protect the data model, the architecture, the test surface, and the release boundaries. The workflow is not “write a prompt and hope.” It is “specify the system, then review what the system becomes.”
How Long a PRD Should Be and When It Is Done
Long enough to remove ambiguity, short enough to be read. For a stage-0 founder with a working demo, we think that is often one to three pages plus artifacts, namely a data table, a permissions matrix, a state checklist, and a not-building list.
The completeness test is simple. Could someone build a test plan from this PRD without asking you ten follow-up questions? If yes, it is probably done enough for the next build cycle.
Write it where the code lives, version it, and update it when the product changes. A PRD is a living document, but it should still be precise enough to serve as a contract for the current version.
A Copyable One-Page Durable PRD Template
1. Problem
What user problem are we solving, and why now?
2. Goal for version one
What must this release do, in one sentence?
3. Users and main journey
Who uses it, and what is the primary flow?
4. Functional requirements
What must the product do?
5. Data model
List the core nouns, what they belong to, and their key fields.
6. Permissions
Who can view, create, edit, delete, export, or approve each object?
7. States
For each important screen, what happens when empty, loading, partial, failed, offline, or denied?
8. Logging and proof
What actions must be logged, audited, or recoverable?
9. Non-functional requirements
What does it need to support for speed, scale, uptime, and recovery?
10. Out of scope
What are we explicitly not building in v1?
11. Open questions
What still needs a decision before build starts?
What Happens After the PRD Is Written
After the PRD, the job is to build the smallest version that can survive real users, then learn from real usage. The point is not to preserve the demo. The point is to turn the demo into a system, which is why we care about how to write a PRD that a build team can test against.
A working demo is not a working product, and the codebase is the customer’s. The fastest route to something durable is deciding the data model, permissions, states, and proof requirements before the next line of code is written.
If you want a second opinion on a PRD you already drafted, a quiet 30-minute no-pitch call can be useful. To see how we work with founders on this, start with Better Software.
Frequently Asked Questions
What Should Be Included in a PRD?
We include the problem, goal, users, success metrics, functional requirements, the four durability sections, non-functional requirements, and out-of-scope items. The four durability sections cover the data model, permissions, states, and logging, and they are the part most PRDs leave out when a working demo already exists.
What Is the Format of a PRD?
We keep the format simple and scannable, with a summary, problem, goals, users, requirements, data model, permissions, state coverage, logging, non-functional requirements, out-of-scope items, and open questions. We use bullets where possible so that a reader or an AI coding tool can follow each requirement.
What Are Common PRD Mistakes?
The biggest mistake we see is writing only features. Others include skipping permissions, ignoring failure states, leaving out logging, making the scope too broad, and writing a document no one can test against. We treat a PRD that cannot be tested against as unfinished.
How Do You Write User Stories in a PRD?
We write them as outcomes, not wishes, such as “As an admin, I want to deactivate a user so that access is removed immediately.” Then we tie the story to the exact requirement and state behavior, so the story and the test describe the same thing.
What Is the Difference Between a PRD and an MVP Scope?
An MVP scope is a list of what you hope to build first. A PRD is the document that makes that scope buildable, testable, and durable. We think of the MVP as the menu and the PRD as the recipe and the food safety rules.
About the author
Better Software Team
Product and engineering team
Better Software Team is the product and engineering team at Better Software. We build new software products and improve existing applications and systems, with deeper experience in healthcare, finance and energy.