name: retrospective-facilitation description: Facilitate effective retrospectives to capture lessons learned, celebrate successes, and identify actionable improvements for future iterations.

Retrospective Facilitation

Overview

Retrospectives are critical ceremonies for team learning and continuous improvement. Effective facilitation creates psychological safety, encourages honest feedback, and drives tangible improvements.

When to Use

• End of sprint (regular cadence)
• Major milestone completion
• Project closure
• After significant events or incidents
• Team transitions or staff changes
• Technology implementations
• Process evaluations

Instructions

1. Retrospective Planning

Retrospective Planning:

Event: Sprint 23 Retrospective
Date: Friday, Jan 17, 2025
Duration: 60 minutes
Location: Conference Room B / Zoom

Facilitator: Sarah (Scrum Master)
Participants: 8 team members
Invite: Product Owner (optional)

---

Retrospective Goals:
  1. Celebrate sprint successes
  2. Identify what went well
  3. Identify what could improve
  4. Commit to specific improvements
  5. Build team cohesion

Format: "Went Well / Didn't Go Well / Ideas"
Tool: Miro board for virtual collaboration

Pre-Retrospective Preparation:
  - Send survey: anonymous feedback (24hrs before)
  - Gather sprint metrics (velocity, bugs, etc.)
  - Review sprint goals and outcomes
  - Prepare starter questions
  - Set up physical/virtual space

Success Criteria:
  - 100% team attendance
  - Minimum 3 actionable improvements identified
  - Team feels heard and valued
  - Action items assigned with owners

2. Facilitation Techniques

# Retrospective facilitation framework

class RetrospectiveFacilitator:
    FORMATS = {
        'Start-Stop-Continue': {
            'description': 'What should we start, stop, continue doing?',
            'duration_minutes': 45,
            'best_for': 'Process improvements'
        },
        'Went-Well-Improve': {
            'description': 'What went well? What can we improve?',
            'duration_minutes': 45,
            'best_for': 'General retrospectives'
        },
        'Sailboat': {
            'description': 'Wind (helping), Anchor (hindering), Rocks (risks)',
            'duration_minutes': 60,
            'best_for': 'Identifying blockers and enablers'
        },
        'Timeline': {
            'description': 'Walk through sprint chronologically',
            'duration_minutes': 60,
            'best_for': 'Complex sprints with incidents'
        }
    }

    def __init__(self, team_size, format_type='Went-Well-Improve'):
        self.team_size = team_size
        self.format = format_type
        self.duration = self.FORMATS[format_type]['duration_minutes']
        self.agenda = self.create_agenda()

    def create_agenda(self):
        """Create timed agenda"""
        return {
            'Opening': {
                'duration_minutes': 5,
                'activities': [
                    'Welcome and goals',
                    'Set psychological safety',
                    'Explain format'
                ]
            },
            'Data Gathering': {
                'duration_minutes': 15,
                'activities': [
                    'Individual reflection (5 min)',
                    'Silent brainstorming on board (10 min)'
                ]
            },
            'Discussion': {
                'duration_minutes': 20,
                'activities': [
                    'Group clustering similar items',
                    'Discuss themes and patterns',
                    'Ask clarifying questions'
                ]
            },
            'Improvement Planning': {
                'duration_minutes': 15,
                'activities': [
                    'Vote on priority items',
                    'Create action items',
                    'Assign owners'
                ]
            },
            'Closing': {
                'duration_minutes': 5,
                'activities': [
                    'Summarize decisions',
                    'Commit to improvements',
                    'Appreciate team'
                ]
            }
        }

    def facilitate_discussion(self, feedback_items):
        """Guide productive discussion"""
        return {
            'structure': [
                {
                    'step': 'Clustering',
                    'action': 'Group similar items together',
                    'facilitation_tip': 'Ask "Are these related?"'
                },
                {
                    'step': 'Exploration',
                    'action': 'Understand root causes',
                    'facilitation_tip': 'Ask "Why?" 5 times'
                },
                {
                    'step': 'Solution Generation',
                    'action': 'Brainstorm solutions',
                    'facilitation_tip': 'No criticism, defer judgment'
                },
                {
                    'step': 'Prioritization',
                    'action': 'Vote on what matters most',
                    'facilitation_tip': 'Use dot voting'
                }
            ],
            'facilitation_questions': [
                'Can you help us understand what happened?',
                'Why do you think this happened?',
                'How can we prevent this next time?',
                'What would success look like?'
            ]
        }

    def ensure_psychological_safety(self):
        """Create safe environment for honest feedback"""
        return {
            'opening_statement': '''
            This is a safe space. There's no blame here. We're all
            learning together. Everything shared stays confidential.
            ''',
            'ground_rules': [
                'Assume positive intent',
                'Criticize ideas, not people',
                'Everyone participates',
                'Listen without interrupting',
                'No side conversations'
            ],
            'practices': [
                'Use anonymous input for sensitive topics',
                'Give balanced feedback (positive & improvement)',
                'Acknowledge emotions and concerns',
                'Thank people for vulnerability'
            ]
        }

3. Action Item Tracking

// Converting retrospective insights to action items

class ActionItemManagement {
  createActionItem(feedback, team) {
    return {
      id: `ACTION-${Date.now()}`,
      title: feedback.title,
      description: feedback.description,
      priority: feedback.priority || 'Medium',
      owner: feedback.owner,
      dueDate: this.calculateDueDate(feedback),
      successCriteria: [
        `${feedback.title} completed`,
        'Results verified in next sprint',
        'Team confirms improvement'
      ],
      resources: feedback.estimatedHours || 4,
      dependencies: feedback.dependencies || [],
      status: 'New',
      createdDate: new Date()
    };
  }

  calculateDueDate(item) {
    // High priority: before next sprint starts
    // Medium: during next sprint
    // Low: next 2 sprints
    const daysFromNow = {
      'High': 7,
      'Medium': 14,
      'Low': 21
    };

    const dueDate = new Date();
    dueDate.setDate(dueDate.getDate() + (daysFromNow[item.priority] || 14));
    return dueDate;
  }

  trackActionItems(items) {
    return {
      total: items.length,
      byStatus: {
        new: items.filter(i => i.status === 'New').length,
        inProgress: items.filter(i => i.status === 'In Progress').length,
        completed: items.filter(i => i.status === 'Completed').length,
        blockedPercent: (items.filter(i => i.status === 'Blocked').length / items.length * 100).toFixed(1)
      },
      summary: items.map(item => ({
        id: item.id,
        title: item.title,
        owner: item.owner,
        dueDate: item.dueDate,
        status: item.status,
        completion: item.completion || 0
      }))
    };
  }

  reviewCompletedItems(previousRetro) {
    return {
      totalCommitted: previousRetro.actionItems.length,
      completed: previousRetro.actionItems.filter(i => i.status === 'Completed').length,
      completionRate: `${(previousRetro.actionItems.filter(i => i.status === 'Completed').length / previousRetro.actionItems.length * 100).toFixed(1)}%`,
      celebration: 'Celebrate completed items!',
      carryOver: previousRetro.actionItems.filter(i => i.status !== 'Completed').map(i => ({
        ...i,
        reason: 'Not completed',
        recommendation: 'Revisit in next retrospective'
      }))
    };
  }
}

4. Retrospective Templates

Retrospective Report:

Sprint: Sprint 23 (Jan 7 - Jan 17, 2025)
Facilitator: Sarah
Attendees: 8 engineers, 1 PM
Duration: 60 minutes

---

What Went Well:
  - Shipped feature 3 days early
  - Zero critical bugs in production
  - Great collaboration between frontend/backend
  - Mentoring of new team member
  - Faster code review cycle (2 → 1 day avg)

Celebrated:
  - Front-end team for UI excellence
  - DevOps for infrastructure stability
  - QA for thorough testing

---

What Could Be Improved:
  1. Unclear requirements caused rework (2 developers, 8 hours)
     Root Cause: PO wasn't available early in sprint
     Severity: Medium

  2. Testing infrastructure flaky (3 instances)
     Root Cause: Increased test load, needs optimization
     Severity: High

  3. Documentation gaps in API changes
     Root Cause: Developers focused on feature delivery
     Severity: Low

  4. Long standup meetings (averaging 20 mins)
     Root Cause: Too many status details
     Severity: Medium

---

Action Items Committed:

1. Daily PO availability window (9-10am)
   Owner: Product Manager
   Due: Sprint 24 Start (Jan 21)
   Priority: High

2. Optimize test infrastructure
   Owner: DevOps Lead
   Due: Sprint 24 Mid-point (Jan 28)
   Priority: High
   Estimated Effort: 16 hours

3. Standup time-boxing
   Owner: Scrum Master
   Due: Next Sprint (Jan 21)
   Priority: Medium
   Method: 5-minute timebox, detailed issues in follow-up

4. API documentation template
   Owner: Tech Lead
   Due: Sprint 24 Start (Jan 21)
   Priority: Low

---

Metrics:
  Velocity: 85 story points (vs 80 planned)
  Bugs Found: 2 (both fixed in sprint)
  Code Review Cycle: 23 hours avg (target: 24)
  Team Morale (1-5): 4.2/5

---

Team Feedback:
  "Best sprint in a while!"
  "Would like more focus on code quality"
  "Great support from the team"

Best Practices

✅ DO

• Hold retrospectives regularly (every sprint)
• Create psychological safety upfront
• Use varied formats to maintain engagement
• Include the whole team
• Focus on systems, not individuals
• Convert insights to specific action items
• Assign clear owners and due dates
• Track and celebrate completed actions
• Review previous actions at start
• Thank people for participation and honesty

❌ DON'T

• Blame individuals or teams
• Let dominant voices control discussion
• Create action items without owners
• Have retrospectives without follow-up
• Ignore difficult feedback
• Focus only on what went wrong
• Hold retrospectives when people are tired/stressed
• Skip closing/celebration
• Mix retrospectives with status meetings
• Ignore patterns across multiple retrospectives

Retrospective Tips

• Rotate formats every 3-4 sprints to maintain engagement
• Use anonymous input for sensitive feedback
• Time-box discussion to stay focused
• Focus on 3-5 improvements, not 20 action items
• Review and celebrate progress on previous actions