undefined

# Activities that reduce available capacity
OVERHEAD_HOURS = {
    'meetings': 5,           # standups, 1-on-1s, planning
    'training': 2,           # learning new tech
    'administrative': 2,     # emails, approvals
    'support': 2,            # helping teammates
    'contingency': 2         # interruptions, emergencies
}

def __init__(self, team_size, sprint_duration_weeks=2):
    self.team_size = team_size
    self.sprint_duration_weeks = sprint_duration_weeks
    self.members = []

def calculate_team_capacity(self):
    """Calculate available capacity hours"""
    # Base capacity
    base_hours = self.team_size * self.STANDARD_WEEK_HOURS * self.sprint_duration_weeks

    # Subtract overhead
    overhead = sum(self.OVERHEAD_HOURS.values()) * self.team_size * self.sprint_duration_weeks

    # Subtract absences
    absence_hours = self.calculate_absences()

    # Available capacity
    available_capacity = base_hours - overhead - absence_hours

    return {
        'base_hours': base_hours,
        'overhead_hours': overhead,
        'absence_hours': absence_hours,
        'available_capacity': available_capacity,
        'utilization_target': '85%',  # Leave 15% buffer
        'target_commitment': available_capacity * 0.85
    }

def calculate_absences(self):
    """Account for vacation, sick, etc."""
    absence_days = 0

    # Standard absences
    vacation_days = 15  # annual
    sick_days = 5       # annual
    holidays = 10       # annual

    # Convert to per-sprint
    absence_days = (vacation_days + sick_days + holidays) / 52 * self.sprint_duration_weeks

    absence_hours = absence_days * 8 * self.team_size
    return absence_hours

def allocate_to_projects(self, projects, team):
    """Allocate capacity across multiple projects"""
    allocation = {}
    total_allocation = 0

    # Allocate by priority
    for project in sorted(projects, key=lambda p: p.priority):
        required_hours = project.effort_hours
        available = self.calculate_team_capacity()['available_capacity'] - total_allocation

        if available >= required_hours:
            allocation[project.id] = {
                'project': project.name,
                'allocated': required_hours,
                'team_members': int(required_hours / (self.STANDARD_WEEK_HOURS * self.sprint_duration_weeks)),
                'allocation_percent': (required_hours / available * 100)
            }
            total_allocation += required_hours
        else:
            allocation[project.id] = {
                'project': project.name,
                'allocated': available,
                'status': 'Insufficient capacity',
                'shortfall': required_hours - available,
                'recommendation': 'Add resources or defer scope'
            }
            total_allocation = available

    return allocation

def identify_bottlenecks(self, skills, projects):
    """Find skill constraints"""
    bottlenecks = []

    for skill in skills:
        people_with_skill = sum(1 for p in self.members if skill in p.skills)
        projects_needing_skill = sum(1 for p in projects if skill in p.required_skills)

        utilization = (projects_needing_skill / people_with_skill * 100) if people_with_skill > 0 else 0

        if utilization > 100:
            bottlenecks.append({
                'skill': skill,
                'people_available': people_with_skill,
                'projects_needing': projects_needing_skill,
                'utilization': utilization,
                'severity': 'Critical',
                'actions': ['Cross-train team', 'Hire specialist', 'Adjust scope']
            })

    return bottlenecks

undefined

Capacity Plan for Q1 2025:

Team: Platform Engineering (12 people)
Period: January 1 - March 31, 2025
Planned Duration: 13 weeks

---

undefined

// Balance workload across team members

class ResourceLeveling {
  levelWorkload(team, tasks) {
    const workloadByPerson = {};

    // Initialize team member workload
    team.forEach(person => {
      workloadByPerson[person.id] = {
        name: person.name,
        skills: person.skills,
        capacity: person.capacity_hours,
        assigned: [],
        utilization: 0
      };
    });

    // Assign tasks to balance workload
    const sortedTasks = tasks.sort((a, b) => b.effort - a.effort); // Largest first

    sortedTasks.forEach(task => {
      const suitable = team.filter(p =>
        this.hasSufficientSkills(p.skills, task.required_skills) &&
        this.hasCapacity(workloadByPerson[p.id].utilization, p.capacity_hours)
      );

      if (suitable.length > 0) {
        const leastUtilized = suitable.reduce((a, b) =>
          workloadByPerson[a.id].utilization < workloadByPerson[b.id].utilization ? a : b
        );

        workloadByPerson[leastUtilized.id].assigned.push(task);
        workloadByPerson[leastUtilized.id].utilization += task.effort;
      }
    });

    return {
      assignments: workloadByPerson,
      balanceMetrics: this.calculateBalance(workloadByPerson),
      unassignedTasks: tasks.filter(t => !Object.values(workloadByPerson).some(p => p.assigned.includes(t)))
    };
  }

  calculateBalance(workloadByPerson) {
    const utilizations = Object.values(workloadByPerson).map(p => p.utilization);
    const average = utilizations.reduce((a, b) => a + b) / utilizations.length;
    const variance = Math.sqrt(
      utilizations.reduce((sum, u) => sum + Math.pow(u - average, 2)) / utilizations.length
    );

    return {
      average_utilization: average.toFixed(1),
      std_deviation: variance.toFixed(1),
      balance_score: this.calculateBalanceScore(variance),
      recommendations: this.getBalancingRecommendations(variance)
    };
  }

  calculateBalanceScore(variance) {
    if (variance < 5) return 'Excellent';
    if (variance < 10) return 'Good';
    if (variance < 15) return 'Fair';
    return 'Poor - needs rebalancing';
  }
}

12-Month Capacity Forecast:

Team Growth Plan:
  Q1 2025: 12 people (current)
  Q2 2025: 13 people (hire 1 DevOps)
  Q3 2025: 15 people (hire 2 engineers)
  Q4 2025: 15 people (stable)

Monthly Capacity (FTE):

January 2025: 10.8 FTE (below normal - ramp-up)
February 2025: 11.1 FTE (normal)
March 2025: 11.0 FTE (1 person on leave)

Q2 Average: 12.5 FTE (new hire contributing)
Q3 Average: 14.2 FTE (2 new hires)
Q4 Average: 15.0 FTE (all at full capacity)

---

Project Commitments vs. Available Capacity:

Q1: Committed 11.0 FTE, Available 11.1 FTE (safe)
Q2: Committed 12.0 FTE, Available 12.5 FTE (buffer 4%)
Q3: Committed 13.0 FTE, Available 14.2 FTE (buffer 9%)
Q4: Committed 14.0 FTE, Available 15.0 FTE (buffer 7%)

---

Risk Alerts:
  - Q1 is tight (98% utilized)
  - Skill gap: Backend expertise in Q2
  - Attrition risk: Plan for 1 departure in Q3