You’re a Product Manager with a PRD deadline this week. These 25 prompts generate complete product requirements documents, feature specs, and technical briefs you can edit and ship immediately.
These prompts pair well with Jasper AI for Product Management-specific tone control, or Copy.ai for fast iteration.
Core Feature PRDs
You are a Senior Product Manager writing a PRD for a new feature launch.
Feature: {feature_name} Product: {product_name} Target users: {user_segment} Business goal: {primary_business_objective} Success metric: {key_metric_and_target} Technical complexity: {low / medium / high} Launch timeline: {target_quarter_and_year} Stakeholder audience: {engineering / design / leadership / cross_functional}
Write a 800 to 1000 word PRD using this structure: Executive Summary (2 sentences), Problem Statement (user pain point with data), Success Criteria (3 measurable outcomes), User Stories (5 core scenarios), Technical Requirements (backend/frontend split), Dependencies (what must happen first), and Risks (2 technical, 1 business). Use bullet points for requirements. Include acceptance criteria for each user story.
When to use it: When engineering asks for a complete spec before sprint planning and you have 2 days to deliver something comprehensive.
Pro tip: Always include the effort estimate in your technical complexity variable - engineers will challenge scope if they think you’re underestimating the work.
You are a Product Manager documenting an urgent bug fix that needs executive approval.
Bug impact: {user_facing_impact_description} Affected users: {percentage_or_number_affected} Revenue impact: {dollar_amount_or_churn_risk} Root cause: {technical_explanation_in_plain_english} Fix approach: {proposed_solution} Engineering effort: {hours_or_days_estimated} Risk of fix: {low / medium / high} Alternative options: {other_approaches_considered}
Write a 400 to 500 word executive brief structured as: Impact Summary (what users experience), Business Case (why this can’t wait), Proposed Fix (technical approach without jargon), Resource Requirements (engineering time needed), Timeline (when users see relief), and Recommendation (clear ask for approval). Use data-driven language that justifies pulling engineers off planned work.
When to use it: When a critical bug hits production and leadership needs to understand why you’re changing sprint priorities.
Pro tip: Lead with user impact numbers, not technical details - executives care about customer experience first, implementation details second.
You are a Product Manager writing a PRD for an integration with a third-party platform.
Integration partner: {company_name} Our product: {your_product_name} Integration type: {API / webhook / SDK / embed} User workflow: {what_users_accomplish} Data exchanged: {what_information_flows_between_systems} Authentication method: {OAuth / API_key / SSO} Error handling: {how_failures_appear_to_users} Launch dependency: {partner_timeline_or_approval_needed}
Write a 600 to 700 word integration PRD with sections: Integration Overview (what connects to what), User Experience Flow (step-by-step journey), Technical Specifications (API endpoints, data formats, rate limits), Error States (what users see when things break), Security Requirements (authentication, data privacy), Testing Strategy (how to validate before launch), and Go-Live Plan (rollout approach). Focus on user experience, not just technical plumbing.
When to use it: When partnerships team says “we need technical requirements for the integration” and expects a full spec by end of week.
Pro tip: Always specify rate limits and timeout behavior - third-party integrations fail in ways your internal systems don’t, and users need clear feedback when they do.
You are a Product Manager writing requirements for a feature enhancement based on user feedback.
Current feature: {existing_feature_name} User complaints: {top_three_pain_points_from_support_tickets} Usage data: {current_adoption_metrics} Proposed improvements: {specific_changes_requested} User research insights: {key_findings_from_interviews_or_surveys} Competitive gap: {how_competitors_handle_this_better} Engineering estimate: {rough_effort_sizing} Business priority: {high / medium / low}
Write a 500 to 600 word enhancement PRD structured as: Current State Analysis (what’s broken today), User Research Summary (evidence for changes), Proposed Solution (specific improvements), Success Metrics (how you’ll measure improvement), Implementation Approach (phased rollout or big bang), and User Communication Plan (how to announce changes). Ground every recommendation in user data, not internal opinions.
When to use it: When customer success escalates user complaints and asks “when will we fix this” and you need a concrete plan with timeline.
Pro tip: Include before/after user journey maps - engineering needs to understand the user experience impact, not just the feature changes.
You are a Product Manager documenting a major architectural change that affects multiple product areas.
System being changed: {backend_service_or_database} Reason for change: {performance / scalability / security / compliance} Products affected: {list_of_product_areas_impacted} User-facing changes: {what_users_will_notice_differently} Migration approach: {gradual_rollout / feature_flag / big_bang} Rollback plan: {how_to_reverse_if_problems} Timeline: {key_milestones_and_dates} Cross-team dependencies: {what_other_teams_must_deliver}
Write a 700 to 800 word architectural PRD with sections: Business Justification (why this can’t wait), User Impact Assessment (what changes for customers), Technical Approach (high-level implementation), Migration Strategy (how to move from old to new safely), Success Criteria (how to know it worked), Risk Mitigation (what could go wrong and how you’ll handle it), and Communication Plan (keeping stakeholders informed). Translate technical changes into business impact throughout.
When to use it: When engineering proposes a major refactor and you need to communicate the business case to leadership and coordinate across product teams.
Pro tip: Always include rollback criteria and timeline - architectural changes are high-risk and executives want to know you have an escape plan if things go sideways.
API and Technical Specifications
You are a Product Manager writing API requirements for external developers integrating with your platform.
API purpose: {what_external_developers_accomplish} Target developers: {mobile_app / web_app / enterprise / startup} Authentication type: {API_keys / OAuth / JWT} Key endpoints needed: {main_API_functions} Rate limiting: {calls_per_minute_or_hour} Data formats: {JSON / XML / GraphQL} Error handling: {how_failures_return_to_developers} Developer onboarding: {how_they_get_access}
Write a 600 to 650 word API PRD including: Developer Use Cases (what they’re building), API Specification (endpoints, methods, parameters), Authentication Flow (how developers get authorized), Rate Limiting Policy (usage controls), Error Response Format (consistent error handling), Documentation Requirements (what developers need to integrate), and Success Metrics (API adoption goals). Write for engineering teams who will implement this, not just document it.
When to use it: When business development closes a partnership requiring API access and engineering needs detailed requirements before they start building.
Pro tip: Specify exact error codes and messages - inconsistent API error handling creates support tickets that your team will field, not the partner’s developers.
You are a Product Manager documenting mobile app technical requirements for a cross-platform feature.
Feature: {mobile_feature_name} Platforms: {iOS / Android / both} Offline capability: {works_offline / requires_connection / partial_offline} Device permissions: {camera / location / notifications / contacts} Performance requirements: {load_time_expectations} Data storage: {local_cache / cloud_sync / real_time} Push notifications: {notification_triggers} Analytics tracking: {events_to_measure}
Write a 550 to 600 word mobile PRD with sections: Feature Overview (what users do on mobile), Platform Requirements (iOS/Android differences), Performance Standards (load times, battery usage), Offline Behavior (what works without internet), Permission Handling (how to request device access), Data Synchronization (local vs cloud storage), and Analytics Plan (what user actions to track). Include specific technical constraints that mobile introduces.
When to use it: When you’re extending a web feature to mobile and need to specify the technical differences for the mobile development team.
Pro tip: Always address offline scenarios explicitly - mobile users lose connectivity regularly and the app needs defined behavior when they do.
You are a Product Manager writing database and performance requirements for a high-traffic feature.
Feature: {feature_handling_high_volume} Expected traffic: {requests_per_second_or_users_concurrent} Data volume: {records_created_daily_or_storage_growth} Response time requirement: {milliseconds_or_seconds_max} Availability target: {uptime_percentage} Geographic distribution: {single_region / multi_region / global} Compliance needs: {GDPR / HIPAA / SOX / none} Monitoring alerts: {what_metrics_trigger_oncall}
Write a 500 to 550 word performance PRD covering: Traffic Projections (expected load), Database Design (schema considerations), Caching Strategy (what to cache and where), Monitoring Requirements (alerts and dashboards), Scalability Plan (how to handle growth), Data Retention Policy (storage lifecycle), and Incident Response (what to do when performance degrades). Focus on operational requirements, not just functional features.
When to use it: When launching a feature expecting significant user adoption and engineering needs specific performance targets to design against.
Pro tip: Include peak usage scenarios like launch day or holiday traffic - your normal load projections don’t account for viral growth or seasonal spikes.
You are a Product Manager documenting security requirements for a feature handling sensitive user data.
Data type: {personal_info / financial / health / business_confidential} Regulatory compliance: {GDPR / CCPA / HIPAA / PCI_DSS} User permissions: {who_can_access_what_data} Data encryption: {at_rest / in_transit / both} Audit logging: {what_actions_to_log} Data retention: {how_long_to_keep_data} Access controls: {authentication_requirements} Third party sharing: {external_services_receiving_data}
Write a 600 to 650 word security PRD with sections: Data Classification (sensitivity levels), Access Controls (who sees what), Encryption Requirements (technical standards), Audit Trail (what to log), Compliance Obligations (regulatory requirements), Data Lifecycle (retention and deletion), Incident Response (breach procedures), and Vendor Management (third-party data handling). Write for security review approval, not just engineering implementation.
When to use it: When adding a feature that processes regulated data and you need security team sign-off before development starts.
Pro tip: Map every piece of user data to its regulatory classification early - discovering compliance gaps during security review delays launch by weeks.
You are a Product Manager writing integration requirements for a complex enterprise software connection.
Enterprise system: {CRM / ERP / HRIS / custom_database} Integration purpose: {data_sync / single_signon / workflow_automation} Data mapping: {fields_being_synchronized} Sync frequency: {real_time / hourly / daily / on_demand} Error handling: {how_to_handle_sync_failures} User authentication: {SSO / LDAP / SAML} Deployment model: {cloud / on_premise / hybrid} Support model: {who_handles_integration_issues}
Write a 650 to 700 word enterprise integration PRD including: Integration Architecture (how systems connect), Data Flow Mapping (what information moves where), Authentication Design (how users access both systems), Error Recovery (handling sync failures), Deployment Requirements (installation and configuration), Testing Strategy (validation approach), and Support Procedures (who fixes what when things break). Address enterprise IT concerns about security and maintainability.
When to use it: When closing an enterprise deal that requires deep integration with their existing systems and IT teams need detailed technical specifications.
Pro tip: Always specify who owns troubleshooting when the integration breaks - enterprise customers expect clear escalation paths when business-critical data sync fails.
User Experience Documentation
You are a Product Manager writing UX requirements for a complete user onboarding redesign.
User type: {new_signups / trial_users / invited_team_members} Current drop-off rate: {percentage_who_abandon_onboarding} Key actions for activation: {critical_user_behaviors_for_success} Time to first value: {how_long_users_should_take_to_see_benefit} Personalization level: {generic / role_based / fully_customized} Support integration: {chat / help_docs / video_tutorials} Progress tracking: {how_users_see_completion_status} Mobile considerations: {mobile_web / native_app / desktop_only}
Write a 700 to 750 word onboarding UX PRD with sections: Current User Journey (pain points in existing flow), Success Metrics (activation and retention targets), Onboarding Flow Design (step-by-step user experience), Personalization Strategy (tailoring by user type), Progress Indicators (how users track completion), Help and Support (assistance options), Mobile Experience (responsive considerations), and A/B Testing Plan (what variations to test). Focus on user psychology and conversion optimization.
When to use it: When user activation rates are below target and you need to redesign the entire new user experience from signup to first success.
Pro tip: Design onboarding backwards from the “aha moment” - identify what action makes users successful, then create the shortest path to that outcome.
You are a Product Manager documenting accessibility requirements for a customer-facing feature.
Feature: {feature_needing_accessibility_compliance} Accessibility standard: {WCAG_2.1_AA / Section_508 / ADA_compliance} User disabilities addressed: {visual / hearing / motor / cognitive} Assistive technologies: {screen_readers / keyboard_navigation / voice_control} Content types: {forms / media / interactive_elements} Testing approach: {automated_tools / user_testing / expert_review} Compliance deadline: {legal_or_business_requirement_date} Fallback options: {alternative_ways_to_complete_tasks}
Write a 550 to 600 word accessibility PRD covering: Compliance Standards (specific requirements), User Scenarios (how disabled users interact), Technical Implementation (ARIA labels, keyboard shortcuts), Content Guidelines (alt text, captions, clear language), Testing Strategy (validation methods), and Fallback Solutions (alternative interaction methods). Include specific acceptance criteria that QA can test against.
When to use it: When legal or compliance teams require accessibility improvements and you need technical specifications for the development team.
Pro tip: Test with actual assistive technology users, not just automated tools - real users discover usability problems that compliance checkers miss.
You are a Product Manager writing UX requirements for a complex data visualization dashboard.
Dashboard purpose: {analytics / monitoring / reporting / operational} Primary users: {executives / analysts / operators / customers} Key metrics displayed: {top_five_data_points_users_need} Interactivity level: {static_charts / filterable / drill_down / real_time} Data refresh frequency: {real_time / hourly / daily} Export requirements: {PDF / CSV / API / sharing} Mobile usage: {mobile_responsive / tablet_optimized / desktop_only} Customization needs: {personal_dashboards / role_based_views / admin_configured}
Write a 650 to 700 word dashboard UX PRD with sections: User Research Summary (what users need to accomplish), Information Architecture (how data is organized), Interaction Design (filtering, drilling down, customization), Visual Design Requirements (charts, colors, responsive layout), Performance Standards (load times for large datasets), Export and Sharing (how users get data out), and Success Metrics (engagement and task completion). Balance data density with usability.
When to use it: When stakeholders request a “better dashboard” and you need to translate vague requirements into specific user experience design.
Pro tip: Prioritize the top 3 metrics ruthlessly - dashboards with too much information become wallpaper that no one actually uses for decision-making.
You are a Product Manager documenting user experience requirements for a mobile checkout redesign.
Current conversion rate: {percentage_completing_purchase} Cart abandonment rate: {percentage_dropping_off} Payment methods: {credit_card / digital_wallet / buy_now_pay_later} Guest checkout: {required / optional / not_allowed} Form complexity: {shipping_address / billing_different / tax_calculation} Error handling: {payment_failures / inventory_issues / network_problems} Trust signals: {security_badges / reviews / guarantees} Platform: {mobile_web / native_app / both}
Write a 600 to 650 word checkout UX PRD including: Current State Analysis (where users drop off), Conversion Optimization Goals (specific improvement targets), User Flow Design (step-by-step purchase process), Form Design Standards (input validation, error messaging), Payment Integration (method selection, processing), Trust and Security (user confidence building), and Testing Strategy (A/B test variations). Optimize for mobile completion rates above all else.
When to use it: When e-commerce conversion rates are underperforming and you need to redesign the purchase flow to reduce abandonment.
Pro tip: Minimize the number of form fields ruthlessly - every additional input field on mobile checkout reduces conversion rates measurably.
You are a Product Manager writing UX requirements for an in-app notification and messaging system.
Notification types: {system_alerts / promotional / social / transactional} User control level: {granular_preferences / simple_on_off / admin_controlled} Delivery channels: {push / email / in_app / SMS} Personalization: {behavioral_triggers / segment_based / manual_campaigns} Frequency limits: {daily_caps / time_based_rules / user_fatigue_prevention} Urgency levels: {critical / important / informational} Interaction design: {expandable / actionable / dismissible} Analytics tracking: {open_rates / click_through / unsubscribe_reasons}
Write a 650 to 700 word notification UX PRD with sections: Notification Strategy (what deserves user attention), User Control Design (preference management), Message Prioritization (urgency and frequency rules), Cross-Channel Experience (email, push, in-app consistency), Personalization Engine (relevant content delivery), Fatigue Prevention (avoiding notification overload), and Measurement Plan (engagement and retention impact). Balance user engagement with respect for attention.
When to use it: When user engagement is low and you want to implement smart notifications that drive action without creating notification fatigue.
Pro tip: Default to fewer notifications, not more - users who get overwhelmed turn off all notifications, losing your communication channel entirely.
Stakeholder Communication
You are a Product Manager writing a status update for engineering leadership on a delayed project.
Project: {feature_or_initiative_name} Original timeline: {initial_launch_date} Current status: {percentage_complete_or_milestone_reached} Delay reason: {technical_blocker / scope_creep / resource_constraint} New timeline: {revised_launch_estimate} Impact on other projects: {downstream_dependencies_affected} Mitigation steps: {what_you’re_doing_to_recover} Resource needs: {additional_help_required}
Write a 400 to 450 word engineering status update with sections: Project Status Summary (current state vs plan), Root Cause Analysis (why we’re behind), Recovery Plan (specific steps to get back on track), Resource Requirements (what you need from leadership), Impact Assessment (other projects affected), and Revised Timeline (new milestones with confidence levels). Be direct about problems and specific about solutions.
When to use it: When a key project is running behind schedule and engineering leadership needs to understand the situation and approve recovery resources.
Pro tip: Lead with the new timeline and what you need, not a lengthy explanation of what went wrong - engineering leaders want to solve the problem, not assign blame.
You are a Product Manager writing a competitive analysis brief for executive team review.
Competitor: {company_name} Their recent move: {product_launch / feature_update / pricing_change / acquisition} Market impact: {customer_reaction / press_coverage / usage_data} Threat level: {high / medium / low} Our competitive position: {ahead / behind / different_approach} Customer feedback: {what_users_are_saying_about_the_change} Recommended response: {product_changes / marketing_response / no_action} Timeline for response: {immediate / next_quarter / long_term}
Write a 500 to 550 word competitive analysis with sections: Competitor Move Summary (what they did), Market Reception (early customer and press reaction), Threat Assessment (impact on our business), Competitive Position Analysis (how this changes the landscape), Customer Impact (what our users are saying), Strategic Response Options (possible actions we could take), and Recommendation (specific next steps with rationale). Focus on business implications, not feature comparisons.
When to use it: When a major competitor launches something significant and executives need to understand the competitive threat and response options.
Pro tip: Include actual customer quotes and usage data - executives can dismiss feature analysis, but they can’t ignore real customer behavior and feedback.
You are a Product Manager writing a resource request for additional engineering capacity.
Current team size: {number_of_engineers} Workload increase: {new_projects_or_scope_expansion} Skill gap: {frontend / backend / mobile / DevOps / data} Business impact: {revenue_opportunity / risk_mitigation / competitive_response} Timeline pressure: {why_this_can’t_wait} Alternative options: {outsourcing / delaying_other_work / reducing_scope} Hiring timeline: {how_long_to_find_and_onboard} Budget impact: {cost_of_additional_headcount}
Write a 450 to 500 word resource request with sections: Business Case (why we need more capacity), Current Capacity Analysis (what we can’t do with existing team), Skill Requirements (specific expertise needed), Impact of Not Hiring (what business outcomes we miss), Alternative Solutions Considered (other options and why they won’t work), and ROI Projection (how additional capacity pays for itself). Make the business case, not just the technical case.
When to use it: When your engineering team is at capacity and you need additional headcount to deliver on business commitments.
Pro tip: Quantify the opportunity cost of not hiring - show the revenue or strategic value you’re missing, not just the features you can’t build.
You are a Product Manager writing a launch readiness assessment for go-to-market team review.
Feature: {launching_feature_name} Launch date: {target_go_live_date} User testing results: {key_findings_from_beta_or_usability_tests} Technical readiness: {performance_testing / security_review / infrastructure_scaling} Documentation status: {help_docs / API_docs / training_materials} Support preparation: {team_training / known_issues / escalation_procedures} Marketing assets: {landing_pages / email_campaigns / press_materials} Success metrics: {KPIs_you’ll_track_post_launch}
Write a 550 to 600 word launch readiness report including: Feature Summary (what’s launching