Workforce Planning Model

# Workload-based demand calculation
def calculate_workforce_demand(workload_hours, productivity_rate, utilization_rate=0.85):
    """
    Calculate required FTEs based on workload analysis

    workload_hours: Annual hours of work required
    productivity_rate: Hours of productive work per FTE annually
    utilization_rate: Expected capacity utilization (accounting for meetings, training, etc.)
    """
    effective_hours_per_fte = productivity_rate * utilization_rate
    required_ftes = workload_hours / effective_hours_per_fte

    return {
        'base_demand': required_ftes,
        'buffer_capacity': required_ftes * 0.1,  # 10% buffer for growth/variability
        'total_demand': required_ftes * 1.1
    }

# Example usage for software development team
annual_story_points = 2400
hours_per_story_point = 8
developer_annual_capacity = 1800  # hours

demand = calculate_workforce_demand(
    workload_hours=annual_story_points * hours_per_story_point,
    productivity_rate=developer_annual_capacity
)
print(f"Required developers: {demand['total_demand']:.1f} FTEs")

import pandas as pd
import numpy as np

def ratio_based_forecast(revenue_forecast, historical_ratios, role_type):
    """
    Forecast headcount using revenue-to-headcount ratios
    """
    ratios = {
        'sales': {'revenue_per_fte': 800000, 'growth_adjustment': 0.95},
        'engineering': {'revenue_per_fte': 400000, 'growth_adjustment': 1.1},
        'support': {'revenue_per_fte': 1200000, 'growth_adjustment': 0.9},
        'marketing': {'revenue_per_fte': 2000000, 'growth_adjustment': 1.0}
    }

    base_headcount = revenue_forecast / ratios[role_type]['revenue_per_fte']
    adjusted_headcount = base_headcount * ratios[role_type]['growth_adjustment']

    return adjusted_headcount

# Multi-year forecasting example
years = [2024, 2025, 2026]
revenue_projections = [10000000, 15000000, 22000000]

forecast_df = pd.DataFrame({
    'year': years,
    'revenue': revenue_projections,
    'sales_ftes': [ratio_based_forecast(r, {}, 'sales') for r in revenue_projections],
    'eng_ftes': [ratio_based_forecast(r, {}, 'engineering') for r in revenue_projections]
})

def workforce_gap_analysis(current_inventory, future_demand, attrition_forecast):
    """
    Comprehensive gap analysis including attrition impact
    """
    analysis = {}

    for role in future_demand.keys():
        current_count = current_inventory.get(role, 0)
        projected_demand = future_demand[role]
        expected_attrition = current_count * attrition_forecast.get(role, 0.15)

        net_current = current_count - expected_attrition
        gap = projected_demand - net_current

        analysis[role] = {
            'current_headcount': current_count,
            'projected_demand': projected_demand,
            'expected_attrition': expected_attrition,
            'net_available': net_current,
            'hiring_need': max(0, gap),
            'surplus': max(0, -gap),
            'gap_percentage': (gap / projected_demand) * 100 if projected_demand > 0 else 0
        }

    return analysis

# Example implementation
current_team = {'senior_dev': 12, 'junior_dev': 8, 'product_manager': 3}
future_needs = {'senior_dev': 18, 'junior_dev': 15, 'product_manager': 5}
attrition_rates = {'senior_dev': 0.12, 'junior_dev': 0.20, 'product_manager': 0.10}

gap_results = workforce_gap_analysis(current_team, future_needs, attrition_rates)

import random

def simulate_workforce_scenarios(base_demand, uncertainty_factors, num_simulations=1000):
    """
    Run Monte Carlo simulations for workforce demand under uncertainty
    """
    results = []

    for _ in range(num_simulations):
        scenario_demand = base_demand

        # Apply random variations based on uncertainty factors
        market_factor = random.normalvariate(1.0, uncertainty_factors['market_volatility'])
        product_factor = random.normalvariate(1.0, uncertainty_factors['product_uncertainty'])
        execution_factor = random.normalvariate(1.0, uncertainty_factors['execution_risk'])

        final_demand = scenario_demand * market_factor * product_factor * execution_factor
        results.append(max(0, final_demand))  # Ensure non-negative demand

    return {
        'mean_demand': np.mean(results),
        'p10': np.percentile(results, 10),
        'p50': np.percentile(results, 50),
        'p90': np.percentile(results, 90),
        'std_deviation': np.std(results)
    }

# Risk-adjusted planning
uncertainty = {
    'market_volatility': 0.15,    # 15% standard deviation
    'product_uncertainty': 0.20,  # 20% standard deviation
    'execution_risk': 0.10        # 10% standard deviation
}

scenario_results = simulate_workforce_scenarios(50, uncertainty)
print(f"Planning range: {scenario_results['p10']:.0f} - {scenario_results['p90']:.0f} FTEs")