Description

This curriculum spans the breadth of an end-to-end Agile problem-solving cycle, comparable in scope to a multi-team advisory engagement that integrates stakeholder alignment, technical delivery, and organisational learning across program increments.

Module 1: Problem Identification and Stakeholder Alignment

Conducting stakeholder interviews to distinguish between perceived problems and root causes using the 5 Whys technique during project intake.
Mapping conflicting stakeholder priorities using a power-interest grid to determine engagement frequency and communication depth.
Facilitating problem framing workshops with product owners and business leads to align on measurable problem statements, avoiding solution bias.
Documenting assumptions about problem scope in a shared backlog to enable traceability and later validation during sprint reviews.
Deciding whether to escalate organizational impediments to portfolio-level forums when cross-team dependencies block problem definition.
Using problem statements to shape initial user story epics, ensuring backlog items directly address validated business needs.

Module 2: Backlog Refinement and Prioritization

Applying weighted shortest job first (WSJF) to prioritize backlog items when multiple teams compete for shared resources.
Revising story point estimates during refinement based on newly discovered technical constraints from spike outcomes.
Splitting large user stories into vertically sliced deliverables that provide partial business value without over-engineering.
Managing scope creep by rejecting stakeholder requests that fall outside the current program increment (PI) objectives.
Resolving conflicts between business value and technical debt by allocating a fixed percentage of sprint capacity to refactoring.
Using acceptance criteria to define testable conditions, reducing ambiguity during sprint planning and QA validation.

Module 3: Sprint Planning and Capacity Modeling

Adjusting team velocity forecasts based on historical sprint data and anticipated absences during holiday periods.
Allocating non-developmental time (e.g., meetings, support) in capacity planning to avoid overcommitment.
Selecting sprint goals that are specific and time-bound, enabling clear success criteria at sprint end.
Deciding whether to include exploratory spikes in the sprint when requirements are unstable or technical risk is high.
Coordinating sprint start dates across dependent teams to align integration points and reduce delivery bottlenecks.
Documenting sprint commitments in Jira or Azure DevOps with clear ownership and estimated completion dates.

Module 4: Execution and Daily Adaptation

Leading daily stand-ups that focus on blockers and task dependencies rather than status reporting to management.
Updating task boards in real time to reflect work-in-progress limits and prevent team member overload.
Escalating unresolved impediments to Scrum-of-Scrum meetings when cross-team dependencies delay progress.
Adjusting in-sprint scope when critical bugs emerge, balancing quality assurance with delivery commitments.
Logging technical decisions in an architecture decision record (ADR) during implementation to support future audits.
Conducting pair programming sessions to transfer knowledge and maintain code quality under tight deadlines.

Module 5: Continuous Integration and Quality Assurance

Configuring automated build pipelines to fail on test coverage drops below a defined threshold, enforcing quality gates.
Integrating static code analysis tools into CI workflows to detect security vulnerabilities before deployment.
Managing test environment contention by scheduling integration tests during off-peak hours.
Deciding whether to automate edge-case tests based on frequency of occurrence and business impact.
Coordinating with operations teams to ensure deployment scripts are version-controlled and peer-reviewed.
Addressing flaky tests by quarantining them and scheduling dedicated refinement time to stabilize.

Module 6: Review, Feedback, and Iterative Learning

Presenting only completed, tested features during sprint reviews to maintain credibility with stakeholders.
Collecting structured feedback from end users via usability testing sessions, not just stakeholder opinions.
Filtering feedback into actionable backlog items versus out-of-scope requests based on product roadmap alignment.
Using Net Promoter Score (NPS) or feature adoption metrics to quantify user satisfaction after release.
Adjusting PI objectives mid-cycle when market changes invalidate initial assumptions.
Archiving outdated user stories and decisions to reduce backlog clutter and improve searchability.

Module 7: Retrospectives and Process Improvement

Facilitating anonymous retrospective inputs to surface sensitive team dynamics without fear of retribution.
Tracking action items from retrospectives in a visible dashboard to ensure follow-through across sprints.
Choosing retrospective formats (e.g., start-stop-continue, sailboat) based on current team challenges.
Measuring the impact of process changes by comparing cycle time and defect rates before and after implementation.
Deciding when to adopt new tools or practices based on team capacity and potential disruption to delivery.
Aligning team-level improvements with SAFe or LeSS framework expectations in scaled Agile environments.

Module 8: Scaling Problem Solving Across Programs

Coordinating problem-solving efforts across Agile Release Trains (ARTs) during PI planning to avoid duplication.
Using dependency boards to visualize and manage cross-team integration risks during concurrent development.
Standardizing definition of done across teams to ensure consistent quality in integrated increments.
Appointing system architects to resolve conflicting technical decisions between teams working on shared components.
Conducting solution demos at the program level to validate end-to-end functionality across team boundaries.
Managing shared backlog items in a portfolio Kanban system with explicit WIP limits and clear entry/exit criteria.