Working Product Managers need PRDs written fast, not perfect. These 25 prompts generate complete product requirements documents, feature specifications, and technical briefs you can send to engineering teams within minutes.
These prompts pair well with Jasper AI for Product Managers-specific tone control, or Copy.ai for fast iteration.
New Feature PRDs
You are a Product Manager writing a PRD for a new feature going into the next sprint.
Feature name: {feature_name} Target user segment: {user_segment} Core problem being solved: {problem_statement} Success metrics: {key_metrics} Engineering team size: {team_size} Sprint timeline: {timeline_weeks} Integration requirements: {existing_systems} Platform: {web/mobile/both}
Write a 600-800 word PRD using the standard format: Problem Statement, Solution Overview, User Stories (3-5 stories), Acceptance Criteria, Technical Requirements, Success Metrics, and Risks. Write for engineers who need to estimate effort this week.
When to use it: Sprint planning week when you need a complete PRD for a feature that engineering is estimating effort on.
Pro tip: Include the actual API endpoints or database tables the feature will touch in your integration requirements - it helps engineers spot dependencies faster.
You are a Product Manager documenting an API feature for external developers.
API feature: {api_functionality} Target developer persona: {developer_type} Rate limits needed: {rate_limit_requirements} Authentication method: {auth_type} Response time requirement: {latency_requirement} Launch deadline: {deadline_date} Billing impact: {pricing_model} Documentation platform: {docs_location}
Write a 400-500 word PRD focused on developer experience. Include endpoint specifications, error handling requirements, SDK needs, and documentation requirements. Structure for a technical audience who will build this in {timeline_weeks} weeks.
When to use it: When you’re releasing a new API endpoint and need engineering to understand both the technical specs and developer experience requirements.
Pro tip: Always specify error codes and messages in your PRD - developers will ask for them anyway, and defining them upfront prevents back-and-forth during development.
You are a Product Manager writing a mobile-first feature PRD.
Mobile feature: {feature_description} iOS/Android priority: {platform_priority} Offline functionality needed: {offline_requirements} Push notification triggers: {notification_events} Device permissions required: {permission_types} App store compliance: {compliance_requirements} User testing insights: {key_user_feedback} Performance benchmarks: {speed_requirements}
Write a 500-600 word mobile PRD covering native functionality, offline behavior, permissions flow, and app store considerations. Include specific performance requirements and user experience flows for both platforms.
When to use it: Building mobile features that need platform-specific considerations or offline functionality.
Pro tip: Include battery usage expectations in your performance requirements - mobile teams need to know if your feature will drain battery so they can optimize accordingly.
You are a Product Manager creating a PRD for a data-heavy dashboard feature.
Dashboard purpose: {dashboard_goal} Primary user role: {user_job_title} Data sources: {data_systems} Real-time requirements: {refresh_frequency} Export formats needed: {export_types} User permission levels: {access_controls} Visualization types: {chart_requirements} Performance targets: {load_time_goals}
Write a 600-700 word PRD focusing on data architecture, user workflows, and performance requirements. Include specific load time targets, data refresh requirements, and export functionality. Structure for both frontend and backend engineering teams.
When to use it: Building analytics dashboards or reporting features where data performance and user workflows are critical.
Pro tip: Specify exact data refresh frequencies and what happens when data is stale - users get confused by outdated dashboards and engineering needs clear caching rules.
You are a Product Manager writing a PRD for a third-party integration.
Integration partner: {partner_name} Integration type: {api_webhook_file} Data being synced: {data_types} Sync frequency: {sync_schedule} Error handling needs: {failure_scenarios} User setup flow: {configuration_steps} Support implications: {support_complexity} Security requirements: {security_standards}
Write a 500-600 word integration PRD covering technical implementation, user setup experience, error handling, and ongoing maintenance. Include specific failure scenarios and recovery processes for customer support.
When to use it: Launching integrations with external tools where both technical complexity and user setup experience matter.
Pro tip: Document what happens when the third-party API goes down - your support team will need clear escalation procedures and users need helpful error messages.
Feature Enhancement Specs
You are a Product Manager documenting improvements to an existing feature with user complaints.
Current feature: {existing_feature} Main user complaints: {complaint_themes} Usage analytics: {current_metrics} Proposed improvements: {enhancement_list} Engineering effort estimate: {time_estimate} User testing results: {testing_insights} Success criteria: {improvement_goals} Rollout approach: {deployment_strategy}
Write a 400-500 word enhancement spec comparing current vs. improved experience. Include specific user pain points being addressed, proposed solutions, and measurable success criteria. Focus on user impact over technical details.
When to use it: When user feedback or analytics show clear problems with existing features that need systematic improvement.
Pro tip: Include before/after user journey maps in your spec - it helps engineering understand why certain technical changes improve the user experience.
You are a Product Manager creating a performance optimization spec.
Feature being optimized: {feature_name} Current performance issues: {performance_problems} Target improvements: {improvement_targets} User impact of slowness: {business_impact} Technical constraints: {system_limitations} Measurement methods: {tracking_approach} Testing requirements: {qa_needs} Rollback plan: {safety_measures}
Write a 300-400 word performance spec focused on measurable improvements. Include current baseline metrics, specific targets, and testing methodology. Write for engineering teams who need to prioritize optimization work.
When to use it: When features are too slow and you need engineering to prioritize performance improvements with clear success metrics.
Pro tip: Always include the business impact of current performance issues - engineering teams prioritize performance work better when they understand user churn or revenue implications.
You are a Product Manager writing an accessibility enhancement spec.
Feature needing accessibility: {feature_name} Accessibility standards: {compliance_requirements} User segments affected: {disabled_user_groups} Current accessibility gaps: {specific_issues} Assistive technology support: {screen_reader_requirements} Keyboard navigation needs: {navigation_requirements} Testing methodology: {accessibility_testing} Legal compliance: {regulatory_requirements}
Write a 450-550 word accessibility spec covering WCAG compliance, assistive technology support, and testing requirements. Include specific user scenarios and technical implementation guidelines for frontend developers.
When to use it: Making existing features accessible or ensuring new features meet accessibility standards from launch.
Pro tip: Include real user scenarios with specific assistive technologies - developers build better accessible experiences when they understand how screen readers or keyboard navigation actually work.
You are a Product Manager documenting a user interface redesign.
Interface being redesigned: {ui_component} User research findings: {research_insights} Design system requirements: {design_standards} Responsive behavior: {device_requirements} User testing results: {usability_findings} Technical constraints: {implementation_limits} Migration approach: {transition_plan} Success metrics: {ui_success_measures}
Write a 500-600 word UI redesign spec covering user research insights, design requirements, responsive behavior, and technical implementation. Include specific usability improvements and measurement criteria.
When to use it: When user research shows interface problems that require systematic redesign rather than small tweaks.
Pro tip: Specify exact breakpoints and responsive behaviors in your spec - frontend developers need precise guidance to implement designs consistently across devices.
You are a Product Manager creating a security enhancement specification.
Security improvement: {security_feature} Current vulnerabilities: {security_gaps} Compliance requirements: {regulatory_standards} User impact: {user_experience_changes} Authentication changes: {auth_requirements} Data protection needs: {data_security} Implementation timeline: {security_deadline} Risk assessment: {threat_analysis}
Write a 400-500 word security spec balancing security requirements with user experience. Include threat scenarios, compliance needs, and implementation priorities. Focus on both technical security and user workflow impacts.
When to use it: Implementing security improvements that affect user workflows or require significant technical changes.
Pro tip: Always explain the user experience impact of security changes - security implementations fail when they make legitimate user workflows too difficult.
Technical Requirement Documents
You are a Product Manager writing technical requirements for a database migration.
Migration scope: {data_being_migrated} Current system limitations: {existing_problems} Target architecture: {new_system_design} Data volume: {migration_size} Downtime constraints: {availability_requirements} Rollback requirements: {safety_procedures} Testing approach: {validation_methods} Timeline pressure: {deadline_constraints}
Write a 600-700 word technical requirements document covering migration strategy, risk mitigation, testing procedures, and success criteria. Include specific rollback procedures and data validation requirements for engineering and DevOps teams.
When to use it: Planning major technical migrations that affect user-facing features or system reliability.
Pro tip: Include specific data validation queries in your requirements - engineering needs to prove the migration worked correctly and you need to verify user data integrity.
You are a Product Manager documenting API versioning requirements.
API being versioned: {api_endpoints} Breaking changes needed: {incompatible_changes} Client applications affected: {dependent_systems} Deprecation timeline: {sunset_schedule} Migration support: {developer_assistance} Backward compatibility: {compatibility_requirements} Documentation updates: {docs_changes} Communication plan: {developer_outreach}
Write a 450-500 word API versioning spec covering technical implementation, developer migration support, and timeline requirements. Include specific deprecation procedures and developer communication strategies.
When to use it: Making breaking API changes that require careful developer migration and clear technical timelines.
Pro tip: Always include example migration code in your spec - developers adopt new API versions faster when you show exactly how to update their implementations.
You are a Product Manager creating infrastructure scaling requirements.
System being scaled: {infrastructure_component} Current capacity limits: {performance_bottlenecks} Growth projections: {traffic_forecasts} Performance targets: {scalability_goals} Cost constraints: {budget_limitations} Monitoring requirements: {alerting_needs} Auto-scaling triggers: {scaling_conditions} Disaster recovery: {backup_requirements}
Write a 500-600 word infrastructure spec covering capacity planning, performance targets, monitoring, and cost management. Include specific scaling triggers and disaster recovery procedures for DevOps and platform teams.
When to use it: When user growth or feature usage is approaching system limits and you need infrastructure improvements.
Pro tip: Include cost per user calculations in your scaling requirements - infrastructure decisions need both performance and budget considerations to get approved.
You are a Product Manager writing microservices architecture requirements.
Service being created: {microservice_purpose} Service boundaries: {responsibility_scope} Data ownership: {database_requirements} Inter-service communication: {api_protocols} Deployment requirements: {containerization_needs} Monitoring and logging: {observability_requirements} Team ownership: {service_maintainers} Performance expectations: {latency_requirements}
Write a 550-650 word microservice spec covering service design, data architecture, communication protocols, and operational requirements. Include specific ownership models and monitoring strategies for distributed systems teams.
When to use it: Breaking monolithic features into microservices or creating new services that need clear boundaries and ownership.
Pro tip: Define exactly which team owns each service and its dependencies - microservices fail when ownership is unclear and problems bounce between teams.
You are a Product Manager documenting real-time feature requirements.
Real-time functionality: {live_feature} Latency requirements: {response_time_targets} Concurrent user limits: {scalability_needs} Connection handling: {websocket_requirements} Offline behavior: {disconnection_handling} Data consistency: {synchronization_needs} Browser support: {client_requirements} Infrastructure needs: {server_requirements}
Write a 500-600 word real-time feature spec covering latency targets, connection management, offline handling, and infrastructure requirements. Include specific user experience expectations and technical implementation guidelines.
When to use it: Building chat, collaborative editing, live updates, or other features requiring real-time data synchronization.
Pro tip: Specify exact behavior when connections drop - users expect real-time features to handle network issues gracefully, and engineering needs clear reconnection logic.
User Story Documentation
You are a Product Manager writing detailed user stories for a complex checkout flow.
E-commerce context: {business_type} Payment methods: {payment_options} User authentication: {login_requirements} Guest checkout: {anonymous_user_flow} Error scenarios: {failure_cases} Mobile considerations: {mobile_specific_needs} International users: {localization_needs} Conversion goals: {success_metrics}
Write 5-7 detailed user stories covering the complete checkout experience from cart to confirmation. Include acceptance criteria for each story, error handling scenarios, and specific conversion optimization requirements. Format for agile development teams.
When to use it: Building or redesigning checkout flows where user experience directly impacts revenue and multiple edge cases need clear specification.
Pro tip: Include abandonment recovery scenarios in your user stories - specify what happens when users leave mid-checkout and how to bring them back.
You are a Product Manager creating user stories for a content management system.
Content types: {content_formats} User permission levels: {access_roles} Workflow requirements: {approval_processes} Publishing destinations: {output_channels} Collaboration needs: {multi_user_editing} Version control: {revision_requirements} Search functionality: {content_discovery} Performance needs: {content_loading_speed}
Write 6-8 user stories covering content creation, editing, approval, and publishing workflows. Include role-based access control, collaboration scenarios, and performance requirements. Structure for both frontend and backend development work.
When to use it: Building content management features where multiple user types need different permissions and workflows.
Pro tip: Map out content state transitions in your user stories - developers need to understand how content moves from draft to published and who can trigger each transition.
You are a Product Manager writing user stories for a search and filtering interface.
Search domain: {content_being_searched} Search capabilities: {search_features} Filter categories: {filter_types} User personas: {searcher_types} Result display: {results_format} Performance requirements: {search_speed} Analytics needs: {search_tracking} Mobile experience: {mobile_search_needs}
Write 5-6 user stories covering search input, filtering, results display, and result interactions. Include performance expectations, mobile-specific behaviors, and analytics requirements for measuring search success.
When to use it: Building search functionality where users need to find specific content quickly