←
BACK_TO_BLOG

How to Write a PRD as a Non-Technical Founder

Share
X_/_TwitterLinkedInCopy_Link
TL;DR
  • A PRD tells a developer what to build and how it should behave, in plain sentences. You own the problem, the users and the rules; the developer owns the screens and the technology.
  • A useful founder PRD has eight sections, from the problem to the open questions. Most of the value sits in two of them: the rules and the edge cases.
  • Write behavior, such as who can do what and what happens when it goes wrong. A sentence like "only the office can cancel a booking" settles a decision a mockup would leave open.
  • Cut the scope before you hand it over. List what the first version will not do, and keep each PRD to one feature.
A loose stack of handwritten notes being clipped into a neat document beside a blue screen.

Knowing how to write a PRD comes down to describing the problem, the users, their steps and the rules in plain sentences, and leaving screens and technology to the developer. You usually need one sooner than you expect: you have an idea, a developer or agency is ready to quote, and they ask for the product requirements document. A PRD is where your idea turns into decisions a builder can act on, and a non-technical founder is the right person to write most of it. This guide covers what a PRD is, the eight sections a developer needs, how to write rules and edge cases in plain English, and a one-page example you can copy.

What a PRD Is For

A PRD, or product requirements document, describes what a product or feature should do and how it should behave, so a team can build and test it. It is written before the build and kept up to date during it.

Martin Cagan of Silicon Valley Product Group put the purpose plainly in his guide How to Write a Good PRD (2005): the PRD should "clearly and unambiguously articulate the product's purpose, features, functionality, and behavior." The same guide notes that the format matters far less than the content. A shared doc works fine.

For a non-technical founder, three things sit outside the PRD:

  • Screen designs. A designer or developer draws these from your PRD.
  • Technology choices. Languages, databases and hosting belong to the builder.
  • Your roadmap. The PRD covers one release or one feature, never the next two years.

Leaving those out means the document asks you only for what you already know: your customers, your workflow and your rules.

The Eight Sections a Founder's PRD Needs

A founder's PRD can be short. These eight sections cover what a developer needs to estimate and build.

SectionWhat goes inWho writes it
ProblemWhat is broken today, for whom, and what it costsFounder
UsersEach type of person who will use it, and what they need to get doneFounder
User flowsThe steps each user takes, start to finish, in plain sentencesFounder
RulesWho can do what, limits, prices, approvals, notificationsFounder
Edge casesWhat happens when something goes wrong or is unusualFounder, then developer
Out of scopeWhat the first version will not doFounder
Success measureThe one number that tells you it workedFounder
Open questionsDecisions not made yet, each with an ownerBoth

The developer will add more later, such as data and integrations. Your job is to get these eight clear enough that two developers reading them would build roughly the same thing.

Start With the Problem

A PRD starts with the problem, because every later decision gets checked against it. If a feature doesn't help with the problem, it waits for a later version.

Skipping this step is expensive. CB Insights analyzed 431 VC-backed startups that shut down since 2023 (published 5 March 2026). Of the 385 where a reason could be identified, 43% cited poor product-market fit. A clear problem statement is the cheapest check against building something nobody needs.

Write the problem in three or four sentences, using what you have seen yourself:

  • Who has the problem. "Our two office staff and eight technicians."
  • What happens today. "Bookings arrive by phone and WhatsApp and go into a paper diary."
  • What it costs. "About one booking a week is double-booked or lost, and each one is a refund."
  • What good looks like. "Every booking is in one place, and a technician sees tomorrow's jobs the night before."

Use your own numbers, even rough ones. A developer can design around "one lost booking a week". "Improve efficiency" gives them nothing to design around.

How to Write Rules and Edge Cases in a PRD

The core of a founder's PRD is behavior: what each person can do, which rules apply, and what happens when something goes wrong. Write it as plain sentences, one rule per line.

Screens are tempting to describe, because they are easy to picture. But a screen sketch hides the decisions that cause rework, such as who can cancel, what happens to a deposit, or which job wins when two people book the same slot.

Have the idea but not the rules?

  • PROBLEM??
  • USERS??
  • FLOWS??
  • RULES??
  • EDGE CASES??
  • OUT OF SCOPE??

Talk us through how the work runs today. We'll turn it into the rules and edge cases a developer can quote from.

TALK_IT_THROUGH→
A paper rulebook with one torn-out page, next to a blank blue screen waiting to be filled

Good rules are specific enough to test:

  • "A customer can book any open slot up to 14 days ahead."
  • "Only the office can cancel a booking once a technician is assigned."
  • "If a booking is cancelled less than 24 hours before, the deposit is kept."

Edge cases are rules for unusual moments. Ask "what if" for each step: what if the customer doesn't answer, the technician is sick, or the payment fails? Write down the answer you would give on the phone today. That answer is usually the right rule.

Cut the Scope Before You Hand It Over

A founder's first PRD almost always asks for too much. Every extra feature adds cost and time, and many of them never get used.

Pendo measured this across 615 customer subscriptions on its platform. Its 2019 Feature Adoption Report found that 80% of features in the average software product are rarely or never used, and that on average 12% of features generate 80% of daily usage volume.

Three ways to cut before you send the PRD:

  • One PRD per feature. "Booking" is one PRD; "invoicing" is another. Each can be quoted, built and tested on its own.
  • Write an out of scope list. "Version one will not take card payments" is a decision, and writing it down stops it creeping back in during the build.
  • Keep the manual workaround. If something happens once a month, the office can handle it by hand until the tool proves itself.

A One-Page PRD Example

Example. Here is a shortened PRD for a booking feature at a pest control company with two office staff and eight technicians. The business is hypothetical; the shape is the one we use.

  • Problem: bookings arrive by phone and WhatsApp into a paper diary; about one a week is double-booked or lost.
  • Users: customers (book online), office staff (manage the diary), technicians (see their jobs).
  • User flow: customer picks a service and a slot, pays a deposit, gets a confirmation; office assigns a technician; technician sees the job the evening before.
  • Rules: slots open 14 days ahead; one job per technician per slot; only the office cancels after assignment; deposit kept inside 24 hours.
  • Edge cases: technician sick (office reassigns, customer gets a message); payment fails (slot released after 15 minutes).
  • Out of scope: card payments for the full job, route planning, a customer app.
  • Success measure: zero lost or double-booked jobs in the first month.
  • Open questions: does the office approve every online booking? (Owner: founder, by Friday.)

Copy the eight bold labels and it works as a PRD template for your own feature.

Steps to Write Your First PRD

Each step takes an hour or two, and together they produce a PRD a developer can quote from.

Step 1: Write the Problem in Your Own Numbers

Fill in the four problem lines from above, and put a real number in the cost line, even a rough one.

Step 2: List Your Users and What Each Needs to Get Done

One line per type of user. Include the people inside your business, since staff are users too.

Step 3: Walk Through the Flow Out Loud

Describe each user's steps from start to finish, as if training a new hire. Record yourself if writing is slow, then tidy the transcript.

Step 4: Turn Every Decision Into a Rule

Go through the flow and write each decision as a one-line rule. Then ask "what if" at every step and write the edge cases.

Step 5: Cut, Then Write the Out of Scope List

Move everything that is not needed for the first version into a short list headed "not in version one".

Step 6: Review It With the Person Who Will Build It

Walk a developer through the PRD and let them question every rule. Their questions become your open questions, each with an owner and a date.

How Founder's Agentcy Writes PRDs

At Founder's Agentcy, a PRD documents one feature's behavior. Writing PRDs is part of our core work, and we write them with the founder in the room, because the rules live in their head.

We also get something clickable in front of the people who will use it early, because their questions sharpen the rules faster than another week of editing. That prototype is a tool for the PRD, and our post on vibe coding internal tools covers why it never becomes the product as-is.

My take: a founder who can write ten clear rules about their business has done the hard part of a PRD. Our breakdown of job costing software shows how much of a real tool comes down to rules like those.

What's the first rule you'd write down for the tool you have in mind?

FAQs

// QUESTIONS //
Q.

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

A PRD describes what the product should do and how it should behave for users. A technical specification describes how the developers will build it, such as the database design and the systems involved.

Q.

How long should a PRD be?

Long enough that a developer can estimate and build without guessing. For one feature from a non-technical founder, that is often one to three pages.

Q.

Can AI write my PRD for me?

AI tools can format a PRD and suggest edge cases you missed. The problem, the users and the rules have to come from you, because an AI tool has never run your business.

Q.

What is the difference between a PRD and user stories?

A PRD is the whole description of a feature, including its problem, rules and scope. User stories are smaller pieces, often written from it, that a team builds and tests one at a time.

Q.

Do I need a PRD for an MVP?

Yes, a short one. An MVP has less scope, which makes the out of scope list and the rules even more important, since they are what keep it small.

2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//

Got the idea? [We'll help you write it down.]

START_PROJECT
→