product-manager-toolkit

---
name: product-manager-toolkit
description: Use when prioritizing features with RICE, running customer discovery interviews, or drafting a PRD, from initial scoring through roadmap validation and tracking.
category: Product
version: 1.0.0
tools: []
---

# Product Manager Toolkit

Essential frameworks for modern product management, from discovery to delivery: feature prioritization, customer discovery, and PRD development.

## Feature Prioritization: Gather → Score → Analyze → Plan → Validate → Execute

**Gather** requests from customer feedback (support tickets, interviews), sales requests (CRM pipeline blockers), technical debt (engineering input), and strategic initiatives (leadership goals).

**Score with RICE**: `RICE Score = (Reach × Impact × Confidence) ÷ Effort`. Reach = number of people affected in a period; Impact = effect per person (a typical scale is 3=massive, 2=high, 1=medium, 0.5=low, 0.25=minimal); Confidence = a percentage reflecting how sure you are of the estimate; Effort = person-time to build. Higher score = higher priority. Other frameworks worth naming explicitly when they fit better: MoSCoW (must/should/could/won't) for scope negotiation, Kano (basic/performance/delighter) for feature-type tradeoffs, and Jobs-to-be-Done for reframing features around the underlying job.

**Analyze the portfolio** for quick-wins-vs-big-bets balance, effort concentration (avoid loading a roadmap with all XL projects), and strategic-alignment gaps.

**Plan a roadmap**: quarterly capacity allocation, dependency identification, and a stakeholder communication plan.

**Validate before finalizing**: compare top priorities against strategic goals; run a sensitivity check (what if an estimate is off by 2x); review with stakeholders for blind spots; check for missing dependencies; validate effort estimates with engineering.

**Execute and iterate**: share the roadmap, track actual vs. estimated effort, revisit priorities quarterly, and feed learnings back into future RICE inputs.

## Customer Discovery: Plan → Recruit → Interview → Analyze → Synthesize → Validate

**Plan**: define research questions, identify target segments, draft a semi-structured interview script.

**Recruit**: 5–8 interviews per segment, a mix of power users and churned users, appropriately incentivized.

**Interview**: semi-structured format, focused on problems rather than proposed solutions, recorded with permission, minimal note-taking during the conversation itself.

**Analyze** each transcript for: pain points with severity, feature requests with implied priority, jobs-to-be-done patterns, sentiment and key themes, and notable quotes worth keeping verbatim.

**Synthesize**: group similar pain points across interviews, treat 3+ independent mentions as a pattern (not fewer), map patterns to opportunity areas using an Opportunity Solution Tree, and prioritize opportunities by frequency and severity.

**Validate before building**: form solution hypotheses, test them with low-fidelity prototypes, measure actual behavior rather than stated preference, iterate on the feedback, and document what was learned for future research.

## PRD Development: Scope → Draft → Review → Refine → Approve → Track

**Choose a template** by scope: Standard PRD for complex cross-team features (6–8 week timeline), One-Page PRD for simple single-team features (2–4 weeks), Feature Brief for exploration-phase work (1 week), or an Agile Epic for ongoing sprint-based delivery.

**Draft**: lead with the problem statement, define success metrics upfront, explicitly state what's out of scope, and include wireframes or mockups.

**Review cycle**: engineering for feasibility and effort, design for UX gaps, sales for market validation, support for operational impact.

**Refine**: address technical constraints raised in review, adjust scope to fit the timeline, and document any trade-off decisions explicitly rather than letting them go unrecorded.

**Approve and kick off**: get stakeholder sign-off, integrate into sprint planning, and communicate to the broader team.

**Track after launch**: compare actual metrics to targets, run user feedback sessions, document what worked and what didn't, update estimation-accuracy data, and share the learnings with the team.

## Common Pitfalls

| Pitfall | Description | Prevention |
|---------|-------------|------------|
| Solution-First | Jumping to features before understanding problems | Start every PRD with the problem statement |
| Analysis Paralysis | Over-researching without shipping | Time-box research phases |
| Feature Factory | Shipping features without measuring impact | Define success metrics before building |
| Ignoring Tech Debt | No time allocated for platform health | Reserve 20% of capacity for maintenance |
| Stakeholder Surprise | Not communicating early and often | Weekly async updates, monthly demos |
| Metric Theater | Optimizing vanity metrics over real value | Tie metrics to user value delivered |

## Best Practices

**Writing PRDs**: start with the problem, not the solution; state success metrics upfront; explicitly list what's out of scope; use wireframes/flows/diagrams; keep technical detail in an appendix; version-control every change.

**Prioritization**: mix quick wins with strategic bets; weigh the opportunity cost of delay; account for cross-feature dependencies; buffer 20% of capacity for the unexpected; revisit priorities quarterly; communicate decisions with the reasoning attached, not just the ranking.

**Customer discovery**: ask "why" five times to reach the root cause; focus questions on past behavior, not future intentions; avoid leading questions ("Wouldn't you love..."); interview people in their natural environment; watch for emotional reactions (pain = opportunity); validate qualitative findings with quantitative data before betting a roadmap on them.

## Integration Points

Analytics: Amplitude, Mixpanel, Google Analytics. Roadmapping: ProductBoard, Aha!, Roadmunk, Productplan. Design: Figma, Sketch, Miro. Development: Jira, Linear, GitHub, Asana. Research: Dovetail, UserVoice, Pendo, Maze. Communication: Slack, Notion, Confluence.