Description

This curriculum spans the breadth of an enterprise Agile transformation initiative, addressing the same depth of practice found in multi-team advisory engagements focused on aligning product, engineering, and compliance functions around scalable requirements processes.

Module 1: Establishing Agile Requirements Foundations

Decide whether to adopt user stories, use cases, or capability slices based on domain complexity and stakeholder familiarity.
Define the threshold for "ready" in the team's Definition of Ready (DoR), including acceptance criteria completeness and dependency resolution.
Select a backlog management tool (e.g., Jira, Azure DevOps) based on integration needs with CI/CD pipelines and audit requirements.
Balance granularity of backlog items to avoid over-specification while ensuring testability and estimability.
Determine ownership model for backlog refinement: shared team responsibility vs. dedicated product owner curation.
Implement traceability mechanisms from regulatory or compliance requirements into backlog items without creating documentation overhead.

Module 2: Stakeholder Engagement and Elicitation in Agile Contexts

Choose elicitation techniques (e.g., story mapping, event storming) based on stakeholder availability and system domain volatility.
Negotiate frequency and format of stakeholder feedback loops, balancing agility with business operational constraints.
Manage conflicting priorities among stakeholders by facilitating weighted scoring or Kano model sessions.
Document tacit domain knowledge from subject matter experts before they exit the project, using lightweight decision logs.
Integrate customer feedback from production telemetry into backlog prioritization without creating reactive development cycles.
Design inclusive elicitation sessions that accommodate remote, global, or non-technical participants using collaborative tools.

Module 3: Backlog Management and Prioritization

Apply WSJF (Weighted Shortest Job First) scoring in SAFe environments while adjusting for non-financial drivers like risk reduction.
Enforce backlog slicing strategies (e.g., by workflow, by persona) to prevent monolithic feature accumulation.
Re-prioritize backlog items mid-sprint when regulatory or market changes invalidate original sequencing.
Manage technical debt visibility by maintaining a separate but prioritized technical backlog linked to business capabilities.
Limit work in analysis to prevent bottlenecking; define WIP limits for refinement activities.
Coordinate backlog dependencies across multiple agile teams using dependency boards or feature toggles.

Module 4: Writing and Refining Agile Requirements

Enforce the "3 Cs" (Card, Conversation, Confirmation) by requiring acceptance criteria in Gherkin syntax for automated testing.
Refactor user stories to eliminate "and" or "or" conditions that obscure single responsibility.
Decide when to decompose epics using vertical (end-to-end) vs. horizontal (layered) slicing based on integration risks.
Standardize non-functional requirement expression using measurable SLAs (e.g., response time, uptime) in story acceptance criteria.
Integrate security and privacy requirements into stories via threat modeling outputs during refinement.
Track changes to story scope during refinement to prevent scope creep without formal change control overhead.

Module 5: Cross-Functional Collaboration and Handoffs

Define interface contracts between frontend and backend teams using API-first design and shared schema repositories.
Establish joint refinement sessions between product, UX, and engineering to align on interaction details before development.
Implement specification by example using living documentation tools like Confluence with embedded test results.
Manage handoffs to operations by embedding deployment constraints (e.g., blackout periods) into release-level stories.
Coordinate with data teams to ensure data model changes are synchronized with feature delivery timelines.
Resolve ambiguity in acceptance criteria through executable specifications using BDD frameworks like Cucumber.

Module 6: Governance and Compliance in Agile Requirements

Map user stories to regulatory obligations (e.g., GDPR, HIPAA) using traceability matrices maintained in audit-friendly formats.
Implement change logging for requirement modifications to satisfy SOX or FDA audit requirements.
Balance agile responsiveness with documentation mandates by generating regulatory artifacts from backlog metadata.
Define approval workflows for high-risk features requiring legal or compliance sign-off before implementation.
Conduct sprint-level risk assessments for features involving third-party data or financial transactions.
Archive completed stories with evidence of testing and stakeholder validation for future audits.

Module 7: Scaling Agile Requirements Across Programs

Align feature definitions across teams using a common taxonomy and domain language (ubiquitous language).
Coordinate program increments in SAFe by synchronizing backlog readiness across Agile Release Trains.
Resolve conflicting interpretations of shared capabilities by maintaining a centralized feature catalog.
Scale refinement activities using distributed refinement events with time-zone-aware scheduling.
Manage dependencies between teams by visualizing feature flow on a program board with escalation paths.
Standardize acceptance criteria templates across teams while allowing domain-specific adaptations.

Module 8: Measuring and Improving Requirements Quality

Track defect leakage rates to identify gaps in acceptance criteria completeness or test coverage.
Measure story cycle time from refinement to deployment to identify bottlenecks in requirements readiness.
Conduct root cause analysis on scope changes post-sprint to improve elicitation practices.
Use team health checks to assess clarity and stability of requirements entering sprints.
Monitor stakeholder satisfaction with delivered features via structured feedback surveys tied to specific stories.
Refine refinement: analyze time spent in backlog grooming to optimize meeting frequency and duration.