Description

This curriculum spans the equivalent of a multi-workshop organizational intervention, addressing the technical, procedural, and human dynamics involved in embedding agile coaching within application management, particularly across legacy systems, cross-functional silos, and regulated change environments.

Module 1: Establishing Agile Coaching Foundations in Application Management

Define the scope of coaching engagement by negotiating access to application teams, release calendars, and incident response workflows.
Select coaching entry points based on application criticality, support burden, and team delivery pain points.
Map existing application support models (e.g., tiered support, war rooms) to identify handoff bottlenecks suitable for agile intervention.
Determine whether coaching will target feature delivery, incident reduction, or technical debt remediation as primary success indicators.
Negotiate reporting lines for the coach to ensure organizational independence while maintaining alignment with service delivery leadership.
Establish baseline metrics for application stability, deployment frequency, and mean time to restore (MTTR) before initiating coaching activities.

Module 2: Diagnosing Team and System Dynamics in Legacy Environments

Conduct value stream mapping across application change requests to expose delays in CAB approvals, testing, and deployment windows.
Identify shadow workflows where teams bypass formal processes to maintain system availability, and assess risks and benefits.
Interview on-call engineers to document recurring incidents and evaluate root cause analysis rigor in post-mortems.
Assess team psychological safety by observing how incidents are discussed in retrospectives and incident reviews.
Review documentation practices for runbooks and configuration management to determine knowledge concentration risks.
Classify technical debt items by operational impact (e.g., outage frequency, deployment failure rate) to prioritize coaching focus.

Module 3: Facilitating Effective Retrospectives in High-Pressure Support Contexts

Design retrospective formats that accommodate on-call rotations by scheduling sessions outside incident peaks and shift changes.
Introduce safety protocols such as anonymized input tools when discussing high-visibility outages or vendor dependencies.
Anchor discussions in incident data rather than perceptions by using outage timelines and alert logs as retrospective inputs.
Coach facilitators to manage dominant voices during post-mortems, especially when senior engineers or vendor representatives are present.
Convert retrospective action items into tracked work within the team’s backlog, ensuring linkage to application improvement goals.
Rotate facilitation responsibility among team members while providing structured templates to maintain consistency.

Module 4: Integrating Agile Practices with ITIL and Change Management

Redesign change advisory board (CAB) meetings to include agile teams as active participants rather than passive requestors.
Introduce peer review and automated checks as substitutes for low-risk change approvals, reducing CAB backlog.
Align sprint planning cycles with change freeze periods and maintenance windows to avoid scheduling conflicts.
Embed service transition checklists into definition of done for application releases involving infrastructure changes.
Negotiate emergency change protocols that allow teams to act during outages while ensuring audit trail completeness.
Map incident, problem, and change records to product backlog items to create visibility into operational work.

Module 5: Coaching Teams on Sustainable Incident Response

Implement blameless post-mortem practices by standardizing templates that focus on system conditions, not individual actions.
Introduce incident simulation (game days) for critical applications to test runbooks and team coordination under stress.
Coach teams to categorize incidents by root cause type (e.g., configuration drift, deployment failure) to guide backlog prioritization.
Establish on-call feedback loops where responders contribute directly to backlog refinement for reliability improvements.
Balance feature delivery and incident reduction goals in sprint objectives to prevent burnout from operational overload.
Integrate monitoring alert thresholds into team dashboards to make alert fatigue a visible metric for improvement.

Module 6: Enabling Cross-Functional Collaboration in Application Support

Facilitate joint backlog refinement sessions between application developers and operations engineers to align on technical debt.
Design shared metrics (e.g., deployment success rate, rollback frequency) to create mutual accountability across silos.
Introduce embedded roles, such as a developer attending operations handovers, to improve knowledge transfer.
Coach teams to document handoff rituals between development and support, reducing tribal knowledge dependencies.
Address conflict points in escalation paths by mapping decision rights for production issues across vendor and internal teams.
Structure cross-team refinement workshops to prioritize shared dependencies like logging standards or monitoring tools.

Module 7: Measuring and Communicating Coaching Impact

Select outcome-based metrics such as reduction in repeat incidents or increase in self-resolved tickets to demonstrate coaching value.
Attribute changes in deployment frequency to specific coaching interventions, controlling for external factors like tooling upgrades.
Present data to stakeholders using application-specific dashboards that link team practices to service KPIs.
Conduct periodic coaching health checks using team feedback on psychological safety, process clarity, and support responsiveness.
Negotiate access to financial data such as cost per incident to quantify the business impact of reliability improvements.
Document coaching adaptations made for different application contexts (e.g., mainframe vs. cloud-native) to inform scaling decisions.

Module 8: Scaling Agile Coaching Across Application Portfolios

Develop a tiered coaching model where high-criticality applications receive dedicated coaching and others use train-the-trainer approaches.
Create standardized intake assessments to evaluate application team readiness for agile coaching interventions.
Coordinate coaching calendars to avoid overloading shared resources like DBAs or network engineers across multiple teams.
Establish a community of practice for internal coaches to share challenges specific to legacy application constraints.
Align coaching roadmaps with enterprise application modernization initiatives to ensure strategic coherence.
Manage coach turnover by documenting coaching plans and progress for each application team in a shared knowledge repository.