User Story & Acceptance Criteria Writer

Write detailed user stories and acceptance criteria for my SaaS feature:

Feature Name: [FEATURE NAME]
Product Area: [MODULE/SECTION OF PRODUCT]
Target User Persona: [USER ROLE AND CONTEXT]
Business Objective: [WHAT BUSINESS GOAL THIS SERVES]
Current User Workflow: [HOW USERS DO THIS TODAY]
Desired Outcome: [WHAT SHOULD CHANGE FOR THE USER]
Technical Constraints: [ANY KNOWN LIMITATIONS]
Integration Points: [SYSTEMS THIS TOUCHES]

Develop complete user stories across these six sections:

Section 1 - Epic Definition and Story Mapping:
Define the overarching epic that frames the feature within the broader product context. Write the epic statement using the format as a [user type] I want [capability] so that [business value]. Break the epic down into a story map showing the user journey from trigger event through task completion, identifying each step where the user interacts with the system. Organize stories into a backbone of primary activities and a walking skeleton of the minimum stories needed for end-to-end functionality. Prioritize stories into release slices where the first slice delivers the minimum viable feature, the second slice adds important enhancements, and the third slice covers edge cases and polish. For each story in the map, assign a rough size estimate using t-shirt sizing to help with sprint planning. Identify stories that are independent and can be developed in parallel versus those with sequential dependencies.

Section 2 - Core User Stories with Acceptance Criteria:
Write five to eight core user stories that form the backbone of the feature. Each story must follow the standard format including the role, the action, and the benefit. For each story write detailed acceptance criteria using the Given-When-Then format that specifies the precondition, the trigger action, and the expected outcome. Include both the happy path where everything works as expected and the primary alternate paths where the user takes a different but valid route to the same goal. Define the acceptance criteria with enough specificity that a developer can implement without ambiguity and a QA engineer can write test cases directly from them. Include data validation rules specifying what inputs are accepted, rejected, or transformed. Specify the expected system behavior for each state transition including loading states, success confirmations, and error displays. Note which acceptance criteria are must-have for the story to be considered done versus nice-to-have enhancements.

Section 3 - Edge Cases and Error Handling Stories:
Identify and document edge cases that could cause unexpected behavior if not addressed during development. Write specific user stories or acceptance criteria additions for scenarios including empty states when no data exists, boundary conditions at minimum and maximum values, concurrent access when multiple users modify the same data, network failures and timeout handling, permission conflicts when users lack required access, and data format variations across locales and integrations. For each edge case, describe the trigger condition, the expected graceful behavior, and the error message or fallback experience the user should see. Prioritize edge cases by likelihood of occurrence and severity of impact to help the team decide which to handle in the initial release versus future iterations. Create a testing matrix that maps edge cases to the core stories they affect.

Section 4 - Non-Functional Requirements and Technical Criteria:
Document the non-functional requirements that define how the feature must perform beyond its functional behavior. Specify performance requirements including maximum acceptable page load time, API response time targets, and throughput requirements for bulk operations. Define security requirements covering authentication needs, authorization rules, data encryption requirements, and audit logging. Establish accessibility requirements specifying WCAG compliance level and specific considerations for screen readers, keyboard navigation, and color contrast. Document scalability requirements including expected concurrent user load, data volume growth projections, and any rate limiting needs. Specify browser and device compatibility requirements. Define data retention, backup, and recovery requirements. Include internationalization considerations if the product serves multiple locales. Note any compliance requirements such as GDPR, SOC 2, or HIPAA that constrain the implementation approach.

Section 5 - UI and UX Specifications:
Describe the user interface requirements with enough detail to guide design and development without prescribing exact visual implementation. Define the information architecture showing what content appears on each screen, how it is organized, and what actions are available. Specify the interaction patterns including form behavior, navigation flows, confirmation dialogs, and inline editing versus modal editing approaches. Document the responsive design requirements describing how the interface adapts across desktop, tablet, and mobile breakpoints. Define empty states, loading states, and error states with specific copy recommendations for each. Describe notification and feedback requirements including success messages, warning alerts, and progress indicators for long-running operations. Specify any animation or transition requirements that enhance usability. Reference existing design system components that should be reused to maintain consistency.

Section 6 - Definition of Done and Launch Criteria:
Establish the comprehensive definition of done that must be satisfied before the feature is considered complete and ready for release. Define the code quality requirements including unit test coverage thresholds, integration test requirements, and code review approvals needed. Specify the documentation deliverables including user-facing help articles, API documentation updates, internal runbooks, and release notes. Establish the QA sign-off process including which test environments must pass, the regression test suite that must be green, and any manual exploratory testing requirements. Define the stakeholder review and acceptance process including who must approve the feature, how demo sessions are structured, and what constitutes acceptance versus rejection. Create a launch checklist covering feature flag configuration, monitoring and alerting setup, rollback procedures, customer communication timing, and support team enablement. Define the post-launch success criteria specifying which metrics must hit which thresholds within what timeframe to consider the feature successful.