PM documents
Every document serves a specific audience and decision. Before writing any document, ask: who reads this, when, and what decision does it enable?
Select a project situation to see which documents the AI PM should produce — and why.
Early Discovery
You have a business problem but no solution yet.
Documents to Produce
PM Actions at This Stage
Write the BRD first — validate the business problem before any solution design. Add a PDD if the problem involves a business process. Commission a Blueprint if the solution will touch multiple systems.
PM Role Reference
| Document | PM Role | Audience |
|---|---|---|
| BRD | Author | Business stakeholders |
| PRD | Author | Product, Engineering, DS |
| Blueprint | Co-author | Cross-functional team |
| PDD | Author | Operations, Change Mgmt |
| User Stories | Author | Dev team, QA |
| FSD | Author (regulated only) | Engineering, QA, UAT |
| Model Spec | Co-author with DS | Data Science, Engineering |
| SOP | Author / Facilitate | Operations, HITL reviewers |
| SDD | Review only | Engineering, DevOps |
Strategic documents validate the problem and design the solution before a single sprint is planned.
BRD
Business Requirements Document
Owner: BA / PM
Audience: Business stakeholders, project sponsors
Captures the business need and context — why the project exists, what problem it solves, who the stakeholders are. Written before product design begins. More business-facing than a PRD.
Contains
- ·Business objectives and problem statement
- ·Stakeholder analysis and sponsor map
- ·Current-state pain with evidence (data/quotes)
- ·Desired future state
- ·Business constraints and regulatory context
- ·ROI / benefit case
- ·High-level scope
- ·Success criteria from a business perspective
AI Note
For AI projects, the BRD should include the business case for using AI specifically — not just "build a feature." Why is AI the right solution? What alternative approaches were rejected and why?
Writing a BRD that describes the solution before the problem is validated. A BRD should be the answer to "why are we doing this?" not "here is what we will build."
PRD
Product Requirements Document
Owner: PM
Audience: Product, engineering, design, data science
The PM's primary artifact. Defines what to build and why — the user problem, proposed solution, success metrics, constraints. Does not specify how to build it — that belongs to engineering.
Contains
- ·Problem statement and user personas
- ·Goals and explicit non-goals
- ·Feature requirements
- ·Success metrics (pre-agreed)
- ·Dependencies and open questions
- ·Out of scope list
- ·For AI: model requirements section with confidence thresholds, input/output schema, fallback design
AI Note
The PRD for an AI feature needs a "Model Behavior" section that most PMs skip: what does the model output? What happens when confidence is low? What is the fallback? Without this, engineering and data science will make these decisions independently.
Writing a PRD without an explicit non-goals list. Everything not listed as out-of-scope will eventually be in-scope — stakeholders use the ambiguity to add features mid-sprint.
Blueprint
Solution Blueprint
Owner: PM / Solution Architect
Audience: Cross-functional team, technical leadership
Bridges business requirements and technical design. Shows how the solution will be structured — key components, data flows, integrations, architecture — without being a full technical spec. Used in enterprise AI engagements.
Contains
- ·Solution overview
- ·Architecture diagram
- ·Key components and their relationships
- ·Integration map
- ·Data flows end-to-end
- ·Technology choices and rationale
- ·Assumptions and constraints
- ·Risk areas identified
AI Note
A Blueprint for an AI product must show where the model sits in the architecture: what feeds into it (data pipeline), what consumes its output (application layer), and how the human review loop connects to the retraining pipeline.
Confusing a Blueprint with a PRD. A Blueprint describes the solution architecture; a PRD describes the user problem and feature requirements. They serve different audiences and decisions.
Delivery documents translate strategy into sprint-level work. User stories are the primary artifact — everything else supports them.
User Story
User Story + Acceptance Criteria
Owner: PM / PO
Audience: Development team, QA
The atomic unit of delivery in Agile. "As a [persona], I want [action], so that [outcome]." Must fit in one sprint with testable AC in Given/When/Then format covering all four scenario types.
Contains
- ·Persona and user need
- ·Business outcome
- ·AC: happy path (Given/When/Then)
- ·AC: edge case with model uncertainty
- ·AC: failure case with graceful error
- ·AC: non-functional (latency, security, fairness)
- ·Story points
- ·Dependencies and DoD reference
AI Note
AI stories must include an edge-case AC for low-confidence predictions. Without it, the behavior at confidence thresholds is undefined — engineering will choose something, and it will probably not match what stakeholders expect.
Writing acceptance criteria that say "model accuracy is acceptable." Acceptable to whom, on what dataset, by what metric? Every AI story AC must name the dataset, metric, and threshold.
FSD
Functional Specification Document
Owner: BA / PM
Audience: Engineering, QA, UAT team
Describes how the system should behave from a functional perspective without specifying technical implementation. Sits between the BRD and the SDD. Used in regulated industries requiring full behavioral specification.
Contains
- ·Functional requirements per use case
- ·System behavior and business rules
- ·UI/UX requirements
- ·Data inputs and outputs
- ·Error handling paths
- ·Validation rules
- ·Reporting requirements
AI Note
For AI features in regulated industries, the FSD must include explicit requirements for explainability — what information does the system show the user about why the AI made its decision?
Writing a FSD that becomes the SDD. The FSD answers "what does the system do?" not "how does the system do it?" The moment you write database schema or API contracts, you have left the FSD.
PDD
Process Design Document
Owner: BA / Operations / PM
Audience: Operations, change management, training
Documents the business process — current state (as-is) and future state (to-be). Identifies where automation or AI can intervene. Critical for enterprise AI products where workflows must be mapped before automation is designed.
Contains
- ·Current-state process map
- ·Pain points and bottlenecks
- ·Future-state process map
- ·Role and responsibility changes
- ·AI automation opportunities
- ·Exception handling
- ·Change impact assessment
AI Note
The PDD is where you discover whether AI can actually help. If the current-state process is inconsistent or exceptions-heavy, the AI will fail on the exceptions. Map the process before committing to the model scope.
Designing the AI feature before completing the PDD. Teams often build automation on top of a broken process — the AI then automates the wrong workflow at scale.
SDD
System Design Document
Owner: Engineering / Architect
Audience: Development team, DevOps, security
The engineering team's artifact — describes how the system will be built technically. PMs review but do not author this. Your role: verify it accurately reflects the functional requirements you specified.
Contains
- ·Technical architecture
- ·Database schema
- ·API contracts
- ·Infrastructure design
- ·Security design
- ·Performance considerations
- ·Deployment approach
AI Note
When reviewing an SDD for an AI feature, check: is the model inference step bounded by a timeout? Is the fallback path described? Is PII handling specified? If these are missing, flag before development starts.
PMs authoring the SDD. You will make technical decisions you are not qualified to make, and engineering will blame you when they need to deviate. Review and approve — do not write.
Two documents that do not exist in traditional software PM — both are essential for AI features that reach production.
Model Spec
AI Model Specification
Owner: PM + Data Scientist (co-authored)
Audience: Data science, engineering, QA
Defines the AI model's requirements — inputs, outputs, quality thresholds, evaluation criteria, fallback behaviour. PM writes the business requirements; data scientist fills in the technical design. Must exist before model development begins.
Contains
- ·Input data schema and quality requirements
- ·Output format and confidence score
- ·Confidence threshold and routing logic
- ·Precision/recall targets on named eval dataset
- ·Evaluation dataset spec (version pinned)
- ·Fallback design for low-confidence predictions
- ·Human review routing logic
- ·Retraining trigger criteria
- ·Drift monitoring requirements
AI Note
The Model Spec is the acceptance criteria for the entire model. If the model does not meet what the Model Spec defines, it does not ship. PMs who do not co-author this lose control of what "done" means for their AI feature.
Letting data science own the Model Spec entirely. The result is a spec written in technical terms (AUROC, confusion matrix) without the business outcome context (what does precision < 90% mean for the user?). The PM must translate between business requirements and model requirements.
SOP
Standard Operating Procedure
Owner: Operations / PM
Audience: Operations team, human reviewers, quality managers
Step-by-step instructions for the human review process in AI products. What do reviewers do when the model routes a case to the review queue? How do they decide? How do they record corrections? Without an SOP, the HITL loop breaks down silently in production.
Contains
- ·Step-by-step review process
- ·Decision criteria for AI outputs
- ·What counts as an error vs. acceptable uncertainty
- ·Escalation paths
- ·How to record corrections (feeds retraining pipeline)
- ·Quality checklist
- ·SLA for review turnaround
- ·Performance and audit trail requirements
AI Note
The SOP is often the difference between an AI feature that improves over time and one that silently degrades. If reviewers do not log corrections in the format the retraining pipeline expects, the human feedback loop is broken from day one.
Shipping an AI feature with a human review queue but no SOP. The reviewers will improvise — inconsistently. The model will receive inconsistent training signal. Within 3 months, model quality will have drifted in unpredictable ways.
The Document Chain for AI Features
What is the difference between a BRD and a PRD?
The BRD captures the business problem — why a project exists, who the stakeholders are, what business outcome is expected. Audience: business stakeholders and sponsors. It answers "why are we doing this?" The PRD defines the product solution — what to build, for which users, with what success metrics. Audience: product, engineering, design, data science. It answers "what are we building and how do we know it succeeded?" For AI products, the PRD also includes a Model Behavior section that does not exist in traditional PRDs: what does the model output, what happens at low confidence, what is the fallback, how is the human review queue triggered? This section is co-authored with data science.
Common Trap
Conflating the two documents into one "requirements doc." The BRD and PRD serve different audiences and different decisions. A combined document inevitably has the wrong level of detail for both — too technical for business stakeholders, too high-level for engineering.
Walk me through the documentation you produce on an AI feature from discovery to production.
Four phases, different documents at each: Discovery: BRD validates the business case. PDD maps the process the AI will change — you cannot design automation without understanding the workflow first. Design: PRD defines the feature. Model Spec (co-authored with data science) defines the model's inputs, outputs, eval criteria, and fallback behavior. Blueprint if the feature spans multiple systems. Delivery: User stories with AI-specific AC — one story per phase (data prep, training, eval, deployment, HITL). FSD if the team is in a regulated industry. Production: SOP for human reviewers. Without this, the HITL loop has no consistent process and the model will receive noisy training signal from inconsistent corrections.
Common Trap
Stopping at the PRD and User Stories. The Model Spec and SOP are the two most AI-specific documents, and they are the ones most often missing. A PM who has not written both has not finished the feature.
How does documentation for an AI feature differ from a traditional software feature?
Three additional documents that do not exist in traditional software PM work: Model Spec: defines what the model must produce — not just what the feature must do. A traditional PRD does not specify precision/recall thresholds, eval datasets, or confidence routing logic. SOP: defines how human reviewers interact with model outputs. Traditional software does not have human-in-the-loop correction cycles that feed back into the system. Monitoring and retraining criteria: traditional software does not degrade silently as user behavior changes. An AI model does. The documentation must define what drift looks like and when to retrain. Additionally, all AI documentation is living — it must be updated each time the model or eval criteria change, which happens frequently.
Common Trap
Treating the PRD as the only document needed for an AI feature and leaving the rest to data science. Data science will fill the gaps with technical defaults that may not match business requirements. The PM must co-author the Model Spec.
How do you ensure documentation stays agile and does not become a waterfall artifact?
Three principles: right-sized, just-in-time, living. Right-sized: match the document to the audience and decision. A sprint team needs user stories with AC — not a 40-page FSD. A board presentation needs a 1-page business case — not a full PRD. Every document should be the minimum size needed to support its audience's decision. Just-in-time: write documents when the decision they support is imminent, not at project start. A Model Spec written in week 1 before data exploration will be wrong. Write it after the data spike confirms feasibility. Living: AI documentation must evolve with the model. When model v2 changes the confidence threshold, the Model Spec updates. When the SOP process changes, the SOP updates. Version-control documentation the same way you version-control code.
Common Trap
Waiting until the end of the project to document decisions. By then, nobody remembers the reasoning, the decisions feel obvious in retrospect, and the documentation has no operational value. Document the "why" at the moment of decision, not six months later.
What are the risks of poor documentation in an AI project?
Four failure modes: Misalignment: teams build different things when requirements are ambiguous. In AI, this shows up as the data science team training for the wrong use case because the model spec was unclear about the prediction target. HITL breakdown: without an SOP, human reviewers improvise. Inconsistent corrections feed inconsistent training signal. The model degrades in ways that are hard to diagnose because the cause is distributed across hundreds of reviewer decisions. Regulatory risk: in regulated industries (healthcare, finance, HR), undocumented AI decision logic creates audit exposure. If you cannot show what the model was supposed to do, you cannot defend what it did. Technical debt accumulation: undocumented model architecture decisions make it impossible to onboard new data scientists or diagnose production issues without the original team.
Common Trap
Treating documentation as a compliance checkbox — something you do at the end to satisfy auditors. Documentation that is created after the fact is always incomplete and often inaccurate. Effective documentation is a decision-making tool, not a record-keeping exercise.