majiayu000 Capacity Planning
Overview
Capacity planning ensures teams have sufficient resources to deliver work at sustainable pace, prevents burnout, and enables accurate commitment to stakeholders.
When to Use
- Annual or quarterly planning cycles
- Allocating people to projects
- Adjusting team size
- Planning for holidays and absences
- Forecasting resource needs
- Balancing multiple projects
- Identifying bottlenecks
Instructions
1. Capacity Assessment
# Team capacity calculation and planning
class CapacityPlanner:
# Standard work hours per week
STANDARD_WEEK_HOURS = 40
# 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
2. Capacity Planning Template
Capacity Plan for Q1 2025:
Team: Platform Engineering (12 people)
Period: January 1 - March 31, 2025
Planned Duration: 13 weeks
---
## Team Composition
Engineers:
- Senior Engineers: 3 (1.2 FTE each)
- Mid-Level Engineers: 6 (0.95 FTE each)
- Junior Engineers: 2 (0.8 FTE each)
- DevOps: 1 (1.0 FTE)
Total Available FTE: 11.1 (accounting for overhead, absences)
Total Available Hours: 11.1 * 40 * 13 = 5,772 hours
---
## Planned Absences
Vacation: 8 weeks across team (estimated)
Sick/Personal: 2 weeks across team
Holiday: 1 week (MLK, Presidents Day)
Total: ~480 hours
---
## Capacity Allocation
Project A: Critical Infrastructure
Allocation: 60% (6,600 hours needed)
Team: 3 senior, 3 mid-level engineers
FTE: 6.6
Status: Committed
Project B: Feature Development
Allocation: 30% (3,300 hours needed)
Team: 2 mid-level, 2 junior engineers
FTE: 3.3
Status: Committed
Infrastructure & Maintenance:
Allocation: 10% (1,100 hours)
Team: DevOps, 1 senior engineer
FTE: 1.1
Status: Operational capacity
Total: 100% allocation, 0% buffer
---
## Risk Assessment
Risks:
1. Zero buffer capacity (100% allocation)
Impact: Any absence/issue creates crisis
Mitigation: Cross-training, automation
2. Junior engineer ramp-up time
Impact: Mid-level engineers pulled for mentoring
Mitigation: Assign 1 mentoring hour/week
3. Infrastructure bottleneck (1 DevOps)
Impact: Scaling limitations
Mitigation: Hire additional DevOps by Feb 1
---
## Recommendations
1. Reduce capacity planning from 100% to 85%
2. Hire 1 additional DevOps engineer
3. Cross-train 2 engineers on critical systems
4. Schedule vacations strategically (not during Phase 2)
5. Build 15% buffer for emergencies
3. Resource Leveling
// 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';
}
}
4. Capacity Forecasting
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
Best Practices
✅ DO
- Plan capacity at 85% utilization (15% buffer)
- Account for meetings, training, and overhead
- Include known absences (vacation, holidays)
- Identify skill bottlenecks early
- Balance workload fairly across team
- Review capacity monthly
- Adjust plans based on actual velocity
- Cross-train on critical skills
- Communicate realistic commitments to stakeholders
- Build contingency for emergencies
❌ DON'T
- Plan at 100% utilization
- Ignore meetings and overhead
- Assign work without checking skills
- Create overload with continuous surprises
- Forget about learning/training time
- Leave capacity planning to last minute
- Overcommit team consistently
- Burn out key people
- Ignore team feedback on workload
- Plan without considering absences
Capacity Planning Tips
- Use velocity data from past sprints
- Track actual vs. planned utilization
- Review capacity weekly in standups
- Maintain 15% buffer for emergencies
- Cross-train on critical functions