undefined

undefined

// Example sprint planning agenda and execution

class SprintPlanner {
  constructor(team, sprintLength = 2) {
    this.team = team;
    this.sprintLength = sprintLength; // weeks
    this.userStories = [];
    this.sprintGoal = '';
    this.capacity = 0;
  }

  calculateTeamCapacity() {
    // Capacity = available hours - meetings - buffer
    const workHours = 40; // per person per week
    const meetingHours = 5; // estimated standups, retros, etc.
    const bufferPercent = 0.2; // 20% buffer for interruptions

    const capacityPerPerson = (workHours - meetingHours) * (1 - bufferPercent);
    this.capacity = capacityPerPerson * this.team.length * this.sprintLength;

    return this.capacity;
  }

  conductPlanningMeeting() {
    return {
      part1: {
        duration: '15 minutes',
        activity: 'Product Owner presents sprint goal',
        deliverable: 'Team understands business objective'
      },
      part2: {
        duration: '45-60 minutes',
        activity: 'Team discusses and estimates user stories',
        deliverable: 'Prioritized sprint backlog with story points'
      },
      part3: {
        duration: '15 minutes',
        activity: 'Team commits to sprint goal',
        deliverable: 'Formal sprint backlog committed'
      }
    };
  }

  createSprintBacklog(stories, capacity) {
    let currentCapacity = capacity;
    const sprintBacklog = [];

    for (let story of stories) {
      if (currentCapacity >= story.points) {
        sprintBacklog.push({
          ...story,
          status: 'planned',
          sprint: this.currentSprint
        });
        currentCapacity -= story.points;
      }
    }

    return {
      goal: this.sprintGoal,
      backlog: sprintBacklog,
      remainingCapacity: currentCapacity,
      utilization: ((capacity - currentCapacity) / capacity * 100).toFixed(1) + '%'
    };
  }
}

undefined

@staticmethod
def calculate_story_points(complexity, effort, risk):
    """
    Estimate story points based on multiple factors
    Factors should be rated 1-5
    """
    base_points = (complexity * effort) / 5
    risk_multiplier = 1 + (risk * 0.1)
    estimated_points = base_points * risk_multiplier

    # Round to nearest Fibonacci number
    for estimate in StoryEstimation.ESTIMATE_OPTIONS:
        if estimated_points <= estimate:
            return estimate

    return StoryEstimation.ESTIMATE_OPTIONS[-1]

@staticmethod
def conduct_planning_poker(team_estimates):
    """
    Handle Planning Poker consensus process
    """
    estimates = sorted(team_estimates)
    median = estimates[len(estimates) // 2]

    # If significant disagreement, discuss and re-estimate
    if estimates[-1] - estimates[0] > 5:
        return {
            'consensus': False,
            'median': median,
            'low': estimates[0],
            'high': estimates[-1],
            'action': 'Discuss and re-estimate'
        }

    return {'consensus': True, 'estimate': median}

undefined

Sprint Goal Template:

Sprint: Sprint 23 (Nov 7 - Nov 20)

Goal Statement: |
  Enable users to manage multiple payment methods with a secure,
  intuitive interface that reduces checkout time by 40%

Success Criteria:
  - Payment method management UI implemented
  - 95% test coverage on payment logic
  - Performance: <200ms payment processing
  - Zero critical security issues
  - Feature released to 20% of users for A/B testing

Team Commitment: 89 story points
Expected Velocity: 85-95 points

Key Risks:
  - Payment gateway API changes
  - Security compliance requirements
  - Integration complexity

Acceptance:
  - All criteria met
  - Feature deployed to staging
  - Security review approved
  - Team and PO sign-off

// Daily standup structure and tracking

class DailyStandup {
  constructor(team) {
    this.team = team;
    this.standups = [];
  }

  conductStandup(date) {
    const standup = {
      date,
      startTime: new Date(),
      participants: [],
      timeboxed: true,
      durationMinutes: 15
    };

    for (let member of this.team) {
      standup.participants.push({
        name: member.name,
        yesterday: member.getYesterdayWork(),
        today: member.getPlanForToday(),
        blockers: member.getBlockers(),
        helpNeeded: member.getHelpNeeded()
      });
    }

    return {
      standup,
      followUpActions: this.identifyFollowUps(standup),
      blockerResolutionOwners: this.assignBlockerOwners(standup)
    };
  }

  identifyFollowUps(standup) {
    return standup.participants
      .filter(p => p.blockers.length > 0)
      .map(p => ({
        owner: p.name,
        blockers: p.blockers,
        deadline: new Date(Date.now() + 24 * 60 * 60 * 1000)
      }));
  }
}