PRDs sit in a uniquely important spot in product development. They convert conversation into committed work. Engineering builds from them, design references them, leadership signs off on them, and the team comes back to them six months later to remember what they originally meant. PRDs are also the artifact PMs are most likely to skip or write badly. Writing one from scratch is a two-to-six-hour task. Across a portfolio of four to eight active projects, that’s most of a week. So the PRD either doesn’t exist, exists in a degraded form, or exists for a different version of the project than the team is currently working on. The pattern is familiar. A PM holds a clear customer discovery meeting; the PRD doesn’t get written for two weeks; by then half the specificity has faded. A leadership review sets a strategic direction; the PRD reflects what the PM remembers, not what the exec was actually focused on. Engineering writes its own spec because no PM document existed; the spec is technically excellent and product-poor. This guide is a specific instance of the workflows pattern. It sits between the customer research workflow (which captures the signal) and the meeting-to-tickets workflow (which operationalizes the build). PRDs are the document layer that connects the two.Documentation Index
Fetch the complete documentation index at: https://docs.tryearmark.com/llms.txt
Use this file to discover all available pages before exploring further.
Foundation
Confirm your team’s PRD format
If your team has one, use it — the template should mirror your required sections, not introduce a new structure. If your team doesn’t have one, the working starting point: One-pager: Problem → Proposed solution → Success criteria → Out of scope → Open questions Full PRD: Summary → Background → Problem → Personas → Goals & non-goals → Solution → Scenarios → Functional requirements → Non-functional requirements → Success metrics → Risks → Dependencies → Timeline → Out of scope → Open questions → Alternatives considered Technical spec: Problem & goals → Current state → Proposed approach → Alternatives → Data model → API surface → Migration plan → Rollout → Testing → Risks → Open questions If your team uses Amazon-style six-pagers, FAQ-led PRDs, or an RFC format, substitute the sections. The workflow doesn’t care which structure, only that one is consistent.Which meetings feed PRDs
| Meeting type | Likely output |
|---|---|
| Customer discovery / user research | Problem statement, personas, pain quotes |
| Feature kickoff | One-pager → full PRD |
| Design review (early) | One-pager refinement; alternatives considered |
| Design review (late) | PRD sections on flows, edge cases |
| Architecture review | Technical spec |
| Strategy / roadmap discussion | One-pager for the bet being made |
| Leadership review / sponsor meeting | Updates to existing PRDs |
Audiences and destination
A single PRD usually has three to five audiences — engineering wants requirements and edge cases; design wants scenarios and flows; leadership reads the first page; GTM wants the story; legal scans for specific sections. A good PRD serves all of them without being structured around any one. PRDs live in document tools, not trackers: Notion, Confluence, Coda, Google Docs, or markdown in your code repo. Pick one durable home. Cross-link from the tracker (the tickets that operationalize the PRD link back to it), but the doc itself lives in one place.Ownership
The PM running the meeting owns the PRD. Always. For technical specs, the tech lead or senior engineer owns it — PMs may contribute the problem framing; the technical content is engineering-owned. For cross-functional PRDs, the PM owns the doc; specialists contribute to their sections. Single ownership is non-negotiable — shared ownership produces drift.The four templates
Template A — One-pager / 10-minute PRD
The opening artifact for most product work. Written quickly after a productive meeting, read in five minutes, designed to force a decision.Template B — Full PRD
For projects that have passed the one-pager stage and are real enough to invest in scoping properly.Template C — Technical spec / engineering design doc
For technical design discussions, architecture reviews, and engineering-led work. Different audience than the product PRD.Template D — PRD update
For incorporating a new meeting’s decisions into an existing PRD without rewriting from scratch. This one runs cleanly today: paste the existing PRD into Customize context, run the template on the new meeting.Save them as workspace templates
Start with Template A
For most teams, the one-pager is the most-used template. Save it first. Add B, C, and D as you encounter the cases.
Tune to your team's format
If your team has an existing PRD shape, adapt the template prompt to mirror those exact sections. Don’t introduce a new structure when an existing one is working.
Save with Workspace visibility
PRD creation is a team standard. Workspace visibility means every PM produces docs in the same shape. See Custom templates.
Run it on a single meeting
The flow for a one-pager. PRDs and specs follow the same shape with more curation time.Pre-seed the meeting with Template A
For feature kickoffs and customer discovery, attach the one-pager template by default. See Before a meeting.
State the right things during the meeting
A few habits sharpen the output dramatically:
- Articulate the problem before discussing solutions. “Here’s the problem we’re solving” before “here’s what we should build.”
- Name what’s out of scope out loud. “We’re not going to solve X in this work.” The single most valuable habit in feature kickoffs.
- Articulate alternatives and why they were rejected. Even briefly. “We considered Y instead; we’re not because Z.”
- Define success in outcome terms. “We’ll know this worked when user behavior changes.” Not “when we ship feature X.”
The 20-minute curation pass
For a one-pager. For a full PRD, plan 45–60 minutes.
- Read the problem statement first. Is it specific? Grounded in user reality? If vague, sharpen.
- Check the proposed solution against the problem. Surprisingly often, the solution drifts from the stated problem during the meeting. Catch this here.
- Make the explicit decisions the document requires. Out of scope, non-goals, alternatives rejected. These are PM judgment calls; the model produces drafts but you make the calls.
- Confirm or write success criteria. Outcome-oriented; specific; measurable if possible. If the meeting didn’t discuss them, flag what you add as inferred.
- Sharpen the open questions. What does the document not yet resolve? These are the inputs to the next meeting or iteration.
- Write the ask. What are you asking the reader to do? Approval? Feedback? A decision on a specific question? Be explicit.
Share and route to feedback
Same-day or next-morning share. Common pattern: post in the team’s project channel, tag specific reviewers (eng lead, design lead, sponsor) with explicit asks, set a feedback deadline (typically 48 hours for a one-pager).
Decide the next step
After feedback on the one-pager:
- Approved as-is → graduate to full PRD (Template B)
- Approved with changes → update the one-pager (Template D), then graduate
- Rejected or paused → archive; the one-pager was the decision tool
- Major rework needed → re-discuss; new meeting; new one-pager
The two-phase rhythm
This rhythm distinguishes high-functioning PM teams from struggling ones, and it’s the one most often skipped. Phase one — the one-pager. Written quickly after the source meeting. Not trying to be the final document. Trying to be the decision-forcing function that determines whether full investment is warranted. The one-pager asks “should we do this?” The full PRD asks “how exactly will we do this?” Confusing the two produces either thin PRDs or bloated one-pagers. The feedback window. Forty-eight hours typically. Surfaces the major issues — is the problem framed correctly, is the proposed solution the right shape, did we miss alternatives, did we miss out-of-scope items, are the success criteria the right ones. Feedback at this stage is dramatically cheaper than feedback on a full PRD. Phase two — the full PRD. After the one-pager has been reviewed and direction approved, the PRD gets written. It builds on the one-pager — the problem statement gets longer, the solution expands into scenarios and requirements, metrics get quantified, dependencies and timeline get added. The PRD draws from additional meetings — design reviews, technical scoping, customer follow-ups. See the multi-meeting section below. Teams that skip the one-pager get full PRDs written for projects that shouldn’t happen at all. Teams that skip the PRD work against the one-pager’s level of specificity, which isn’t enough. The two-phase rhythm avoids both failure modes.Multi-meeting synthesis
A full PRD rarely comes from a single meeting. It typically draws from one to three customer discovery meetings, one to two feature kickoffs, one to two design reviews, a technical scoping meeting, and a stakeholder review. The challenge: producing a coherent PRD from a corpus of conversations spread across weeks. Earmark refines artifacts within a single meeting today; cross-meeting generative synthesis is not a one-click action. The workaround:- Tag the source meetings. Either with a project name in their Earmark titles, or in a running list. The synthesis will work against a defined corpus.
- Manual context assembly. Pull the relevant artifacts (or transcript excerpts) from each source meeting into a single Customize-context document. Run Template B against the assembled document. The output draws from all of them with attribution per section.
- Use the command menu (
Cmd+K/Ctrl+K) to surface the right source meetings when assembling the corpus. - Local transcript export if you want to run an external agent across many meetings for the synthesis (local transcript files).
Doc tool conventions and the PRD → tickets bridge
PRDs live in document tools; the work they drive lives in a tracker. The handoff matters. Doc tool conventions. One PRD per page with a consistent URL pattern. Title format that’s searchable (PRD: {Project Name}). Status badge at the top (Draft, In Review, Approved, Building, Shipped, Archived). Link to source meetings in the appendix. Link to the tickets/epic in the tracker once they exist. Link to design files if applicable. These conventions seem mechanical; they’re the difference between a PRD library that compounds and one lost in document chaos.
The PRD → tickets handoff. Once the PRD is approved and engineering is ready to start, the natural next step is ticket creation. This is the handoff to the meeting-to-tickets workflow. The clean pattern:
- Create an epic in the tracker for the project; link to the PRD
- Use the PRD’s Key scenarios and Functional requirements sections as source material for stories
- Each story links back to the PRD section that informs it
- Open questions on the PRD map to spike tickets
- The PRD’s Out of scope section informs which proposed tickets to not create
PRDs are living documents
Don’t treat the PRD as a write-once artifact. As the project moves through design, build, and ship, update it with the decisions made along the way. Use Template D after every meaningful project meeting. The change log captures the project’s evolution. At ship, the PRD should reflect what actually shipped — not the original proposal. This is the artifact future readers will need. Within a month of shipping, run a brief retrospective using the PRD as the substrate: Did we ship what the PRD specified? Where did we drift, and why? Did the success metrics move? Were the risks accurate? What did we learn that should update our future PRDs?Common pitfalls
- Confusing the one-pager with the PRD. Different artifacts with different jobs. The one-pager is a decision tool; the PRD is a build spec. Use both.
- Skipping the one-pager. Going straight to a full PRD means full investment before direction has been validated.
- Writing a PRD that’s actually a meeting recap. PRDs make decisions; recaps describe discussions. If the document doesn’t pick a direction, name what’s out of scope, or define success, it’s not a PRD.
- Skipping out-of-scope and non-goals. The most common omission and the single biggest source of scope creep later. Bake these sections in; never skip them.
- Inventing customer quotes or requirements. The model can fabricate plausible-sounding content. Ground everything in source meetings.
- PRDs that never get updated. A PRD from week one doesn’t match what’s being built by week six. Use Template D after every meaningful meeting.
- No change log on updates. Without it, reviewers can’t tell what changed between versions.
- Shared ownership of the PRD. Drift follows. Single owner per PRD, every time.
- Skipping stakeholder sign-offs. When ambiguity later emerges, the sign-off section is the answer.
- No provenance to source meetings. Future readers will want to know what was actually said. Link the meetings.
- Heavy PRDs for small work. Not every project needs a full PRD. The one-pager is enough for many things; some things only need a ticket.
- Letting the PRD become a vanity artifact. PRDs exist to inform engineering work. Engineering should be the primary audience, not executive review.
- PRDs that don’t connect to tickets. The handoff from PRD to tracker is where many projects lose fidelity. The meeting-to-tickets workflow paired with this one closes the gap.
Where to go next
- Workflows — the general shape this is an instance of
- Customer research workflow — for the discovery meetings that feed PRDs
- Meeting-to-tickets workflow — for the handoff from PRD to tracker
- Meeting-to-prototype workflow — for visual prototyping that often happens between one-pager and PRD
- Structured meeting notes workflow — for the design reviews and scoping meetings that update PRDs
- Custom templates — visibility, sharing, and edit permissions
- Composer — for tuning the prompt before saving as a workspace template
- Before a meeting — pre-seeding the template on kickoffs and discovery

