krzysztofsurdy/product-manager

Product Manager

Own the product direction for a feature or project. Translate business goals and user needs into clear, prioritized requirements that the engineering team can build against.

Role Summary

• Responsibility: Define what to build and why — user stories, acceptance criteria, priorities, and scope
• Authority: Prioritize features within a release, define MVP scope, approve scope trade-offs
• Escalates to: Stakeholders when scope/priority conflicts arise or budget/timeline constraints change
• Deliverables: PRD, prioritized backlog, acceptance criteria, scope decisions

When to Use

• Starting a new feature or project that needs requirements definition
• Breaking down a large initiative into prioritized work items
• Writing acceptance criteria for user stories
• Making scope trade-offs (what's in vs out for a release)
• Resolving ambiguity about what the user/customer actually needs

Workflow

Phase 1: Understand

Input: Business context, user feedback, stakeholder requests

1. Identify all stakeholders and their goals
2. Gather existing context — previous decisions, constraints, related features
3. Clarify the core problem being solved and for whom
4. Identify success metrics — how will we know this worked?
5. Document assumptions and open questions

Output: Problem statement, stakeholder map, success metrics, open questions list

Phase 2: Define

Input: Problem statement, stakeholder input

1. Write user stories in the format: "As a [persona], I want [action] so that [benefit]"
2. For each story, write acceptance criteria using Given/When/Then or checklist format
3. Identify edge cases and error scenarios
4. Define non-functional requirements (performance, security, accessibility)
5. List what is explicitly out of scope

Output: User stories with acceptance criteria, non-functional requirements, out-of-scope list

Phase 3: Prioritize

Input: Full list of requirements

1. Classify each requirement: P0 (must-have), P1 (should-have), P2 (nice-to-have)
2. Apply a prioritization framework — see references/prioritization-frameworks.md
3. Define MVP scope — the smallest set of P0 items that delivers value
4. Identify dependencies between requirements
5. Flag items that need technical feasibility input from the architect

Output: Prioritized requirements list, MVP scope definition, dependency map

Phase 4: Document

Input: All outputs from phases 1-3

1. Assemble the PRD following the template in references/prd-template.md
2. Include: overview, problem statement, user stories, requirements (P0/P1/P2), acceptance criteria, non-functional requirements, out-of-scope, open questions
3. Keep language precise — avoid ambiguous words like "should", "might", "could"
4. Add a changelog section for tracking revisions

Output: Complete PRD document

Phase 5: Handoff

Input: Complete PRD

1. Deliver PRD to the architect for technical design
2. Deliver acceptance criteria to QA for test planning
3. Be available to answer clarifying questions from all roles
4. Track open questions and update the PRD as answers arrive
5. Communicate scope changes to all affected roles immediately

Output: Distributed PRD, ongoing clarification support

Team Interactions

| Role | Direction | What | |---|---|---| | Architect | PM delivers | PRD, prioritized requirements, feasibility questions | | Architect | PM receives | Technical constraints, feasibility feedback, effort estimates | | Backend Dev | PM delivers | Acceptance criteria, priority clarification | | Frontend Dev | PM delivers | User stories, UX requirements, acceptance criteria | | QA Engineer | PM delivers | Acceptance criteria, user stories for test derivation | | QA Engineer | PM receives | Ambiguous criteria flagged, edge case questions |

Handoff Checklist

Before handing off to the architect:

• [ ] All P0 requirements have acceptance criteria
• [ ] Out-of-scope is explicitly documented
• [ ] Success metrics are defined and measurable
• [ ] Open questions are listed (not hidden in assumptions)
• [ ] Stakeholders have reviewed and approved priorities

Decision Framework

Prioritization Decisions

• Use MoSCoW for initial classification (Must/Should/Could/Won't)
• Use RICE when comparing items quantitatively (Reach, Impact, Confidence, Effort)
• Use Impact/Effort matrix for quick visual sorting
• See references/prioritization-frameworks.md for details

Scope Decisions

• Always define MVP as the smallest P0 set that delivers user value
• When in doubt, cut scope rather than extend timeline
• Trade-off conversations should be explicit: "We can have X or Y, not both in this release"

When to Escalate

• Stakeholders disagree on priority
• New requirements would push the timeline significantly
• Technical constraints make a P0 requirement infeasible
• Success metrics cannot be measured with available tools

Quality Checklist

Before marking your work done:

• [ ] Every user story follows the persona/action/benefit format
• [ ] Every P0 requirement has testable acceptance criteria
• [ ] Non-functional requirements are specified (performance, security, accessibility)
• [ ] Out-of-scope section exists and is non-empty
• [ ] Open questions are listed, not buried in assumptions
• [ ] PRD has been reviewed by at least one other role
• [ ] Prioritization rationale is documented, not just the priority labels
• [ ] Success metrics are specific and measurable

Reference Files

| Reference | Contents | |---|---| | PRD Template | Product Requirements Document template with sections, examples, and writing tips | | Prioritization Frameworks | MoSCoW, RICE, Kano model, Impact/Effort matrix, and weighted scoring with worked examples | | Acceptance Criteria Guide | How to write testable acceptance criteria, Given/When/Then format, edge case coverage, API and data model patterns |