workforce-scheduling

name workforce-scheduling description When the user wants to optimize workforce scheduling, create shift plans, or balance labor demand. Also use when the user mentions "staff scheduling," "labor planning," "shift optimization," "crew scheduling," "roster optimization," or "employee scheduling." For task assignment, see task-assignment-problem. For wave planning labor, see wave-planning-optimization. Workforce Scheduling You are an expert in workforce scheduling and labor optimization for warehouses and supply chain operations. Your goal is to help create optimal shift schedules that match labor supply with demand, minimize costs, ensure compliance, and improve employee satisfaction. Initial Assessment Before optimizing workforce scheduling, understand: Labor Demand Daily/weekly order volume patterns? Peak periods and seasonality? Tasks to be performed (picking, packing, receiving)? Required skills and certifications? Service level targets (on-time shipping)? Labor Supply Total workforce size (full-time, part-time, temp)? Employee availability and preferences? Skill levels and cross-training? Shift length preferences (8hr, 10hr, 12hr)? Union rules and labor agreements? Business Constraints Operating hours (24/5, 24/7, day shift only)? Minimum staffing levels? Maximum consecutive days worked? Overtime rules and costs? Break and meal period requirements? Weekend and holiday staffing needs? Current State Current scheduling method (manual, software)? Current labor costs (regular + OT)? Labor utilization rates? Employee satisfaction with schedules? Schedule change frequency? Workforce Scheduling Framework Scheduling Objectives Primary Goals: Match Demand : Ensure sufficient labor for forecasted workload Minimize Cost : Optimize mix of regular hours, overtime, and temps Maximize Utilization : Reduce idle time and overstaffing Employee Satisfaction : Consider preferences, fairness, work-life balance Compliance : Meet labor laws, union rules, company policies Key Metrics: Labor cost per unit ($/order, $/line picked) Labor utilization % (productive time / scheduled time) Schedule efficiency (actual vs. planned labor hours) Employee turnover and absenteeism Overtime % (OT hours / total hours) Shift Design Strategies 1. Fixed Shifts Same schedule every week Pros : Predictable, easy to plan life around Cons : Inflexible, may not match demand Use : Stable demand, union environments 2. Rotating Shifts Employees rotate through different shifts Pros : Fair distribution of undesirable shifts Cons : Disrupts circadian rhythms, harder on employees Use : 24/7 operations, fairness priority 3. Flexible/Variable Shifts Shift start times and lengths vary Pros : Matches demand, reduces costs Cons : Unpredictable for employees, harder to schedule Use : Variable demand, high labor cost sensitivity 4. Compressed Workweeks 4×10hr or 3×12hr instead of 5×8hr Pros : Fewer workdays, employee preference, coverage Cons : Fatigue, may require premium pay Use : Continuous operations, employee retention 5. On-Call/Flex Pool Variable hours based on need Pros : Maximum flexibility, cost-effective Cons : Unpredictable for workers, may increase turnover Use : Peak periods, backup capacity Mathematical Formulation Workforce Scheduling as Optimization Problem Decision Variables: x[i,s,d] = 1 if employee i works shift s on day d, 0 otherwise y[s,d] = number of employees on shift s on day d o[i,d] = overtime hours for employee i on day d Parameters: D[s,d] = labor demand (hours) for shift s on day d C_reg = regular hourly wage C_ot = overtime hourly wage (typically 1.5× regular) C_temp = temporary worker hourly wage A[i,s,d] = availability of employee i for shift s on day d (0 or 1) H[s] = length of shift s (hours) Max_hours[i] = maximum hours per week for employee i Min_rest = minimum hours between shifts Objective Function: Minimize: Total Labor Cost = Regular + Overtime + Temp + Penalties Formally: Σ Σ Σ (C_reg × H[s] × x[i,s,d]) # Regular time + Σ Σ (C_ot × o[i,d]) # Overtime + Σ Σ (C_temp × temp_hours[s,d]) # Temporary workers + α × (Σ schedule_disruption_penalty) # Preference violations + β × (Σ understaffing_penalty) # Demand shortfall Constraints: # 1. Meet demand (with possible understaffing penalty) for s in shifts: for d in days: Σ (H[s] × x[i,s,d]) + temp_hours[s,d] >= D[s,d] # 2. Each employee works at most one shift per day for i in employees: for d in days: Σ x[i,s,d] <= 1 for all s # 3. Respect employee availability for i in employees: for s in shifts: for d in days: x[i,s,d] <= A[i,s,d] # 4. Maximum hours per week for i in employees: for week in weeks: Σ Σ (H[s] × x[i,s,d]) <= Max_hours[i] for d in week, s in shifts # 5. Minimum rest between shifts for i in employees: for d in days[:- 1 ]: if x[i, evening_shift, d] = 1 : x[i, morning_shift, d+ 1 ] = 0 # Example: no evening then morning # 6. Maximum consecutive working days for i in employees: for d in days: Σ x[i,s,d '] <= 6 for d' in [d...d+ 6 ], s in shifts # 7. Minimum employees per shift (coverage) for s in shifts: for d in days: Σ x[i,s,d] >= Min_coverage[s,d] for all i # 8. Skill requirements for s in shifts: for d in days: Σ x[i,s,d] × skill[i,k] >= required_skill[k,s,d] for all i, k in skills Scheduling Algorithms Greedy Demand-Driven Scheduling import pandas as pd import numpy as np from datetime import datetime, timedelta def greedy_workforce_scheduling ( demand, employees, shifts, days ): """ Greedy heuristic for workforce scheduling Algorithm: 1. Sort days by demand (highest first) 2. For each day, assign employees to meet demand 3. Prioritize employees with availability and low weekly hours Parameters: ----------- demand : dict {(shift, day): required_hours} employees : DataFrame Columns: employee_id, max_hours_per_week, availability shifts : list Shift identifiers days : list Day identifiers (e.g., dates) Returns: -------- Schedule assignments """ # Initialize schedule schedule = [] employee_hours = {emp[ 'employee_id' ]: 0 for _, emp in employees.iterrows()} # Sort (shift, day) pairs by demand demand_sorted = sorted (demand.items(), key= lambda x: x[ 1 ], reverse= True ) for (shift, day), required_hours in demand_sorted: assigned_hours = 0 # Get available employees for this shift/day available_employees = employees[ employees[ 'availability' ].apply( lambda x: (shift, day) in x) ].copy() # Sort by current hours worked (assign to those with fewer hours first) available_employees[ 'current_hours' ] = available_employees[ 'employee_id' ]. map (employee_hours) available_employees = available_employees.sort_values( 'current_hours' ) # Assign employees until demand met for idx, emp in available_employees.iterrows(): emp_id = emp[ 'employee_id' ] shift_length = 8 # Assume 8-hour shifts # Check if employee can work (not exceeding max hours) if employee_hours[emp_id] + shift_length <= emp[ 'max_hours_per_week' ]: # Assign employee schedule.append({ 'employee_id' : emp_id, 'shift' : shift, 'day' : day, 'hours' : shift_length }) employee_hours[emp_id] += shift_length assigned_hours += shift_length if assigned_hours >= required_hours: break # Check if demand met if assigned_hours < required_hours: print ( f"Warning: Understaffed on {day} , shift {shift} " f"( {assigned_hours} / {required_hours} hours)" ) return pd.DataFrame(schedule) # Example usage employees = pd.DataFrame({ 'employee_id' : [ f'EMP {i:03d} ' for i in range ( 1 , 21 )], 'max_hours_per_week' : [ 40 ] * 15 + [ 20 ] * 5 , # 15 full-time, 5 part-time 'availability' : [ [(s, d) for s in [ 'morning' , 'afternoon' , 'evening' ] for d in range ( 7 )] # Available all shifts/days for _ in range ( 20 ) ] }) shifts = [ 'morning' , 'afternoon' , 'evening' ] days = list ( range ( 7 )) # Monday=0, Sunday=6 # Demand varies by day and shift demand = { (shift, day): np.random.randint( 40 , 120 ) for shift in shifts for day in days } # Higher demand on weekdays, mornings and afternoons for day in range ( 5 ): # Mon-Fri demand[( 'morning' , day)] *= 1.5 demand[( 'afternoon' , day)] *= 1.3 schedule = greedy_workforce_scheduling(demand, employees, shifts, days) print ( "Workforce Schedule:" ) print ( f"Total Scheduled Hours: {schedule[ 'hours' ]. sum ()} " ) print ( f"Employees Scheduled: {schedule[ 'employee_id' ].nunique()} " ) print ( f"\nSchedule by Shift:" ) print (schedule.groupby( 'shift' )[ 'hours' ]. sum ()) Integer Programming Model from pulp import * def optimize_workforce_schedule ( demand, employees, shifts, days, cost_regular= 20 , cost_overtime= 30 ): """ Optimal workforce scheduling using MIP Parameters: ----------- demand : dict {(shift, day): hours_needed} employees : DataFrame Employee data with availability and constraints shifts : list Available shifts days : list Days to schedule cost_regular : float Regular hourly cost cost_overtime : float Overtime hourly cost Returns: -------- Optimal schedule """ prob = LpProblem( "Workforce_Scheduling" , LpMinimize) # Decision variables # x[emp, shift, day] = 1 if employee works this shift on this day x = LpVariable.dicts( "assign" , [(emp[ 'employee_id' ], shift, day) for _, emp in employees.iterrows() for shift in shifts for day in days], cat= 'Binary' ) # Overtime hours variables overtime = LpVariable.dicts( "overtime" , [(emp[ 'employee_id' ], day) for _, emp in employees.iterrows() for day in days], lowBound= 0 , cat= 'Continuous' ) # Understaffing variables (soft constraint) understaffed = LpVariable.dicts( "understaffed" , [(shift, day) for shift in shifts for day in days], lowBound= 0 , cat= 'Continuous' ) # Objective: minimize cost shift_hours = 8 # Assume 8-hour shifts prob += ( # Regular time cost cost_regular * shift_hours * lpSum([ x[emp[ 'employee_id' ], shift, day] for _, emp in employees.iterrows() for shift in shifts for day in days ]) + # Overtime cost cost_overtime * lpSum([ overtime[emp[ 'employee_id' ], day] for _, emp in employees.iterrows() for day in days ]) + # Understaffing penalty (high cost) 1000 * lpSum([ understaffed[shift, day] for shift in shifts for day in days ]) ), "Total_Cost" # Constraints # 1. Meet demand (with possible understaffing) for shift in shifts: for day in days: prob += ( lpSum([ shift_hours * x[emp[ 'employee_id' ], shift, day] for _, emp in employees.iterrows() ]) + understaffed[shift, day] >= demand.get((shift, day), 0 ) ), f"Demand_ {shift} _ {day} " # 2. Each employee works at most one shift per day for _, emp in employees.iterrows(): for day in days: prob += lpSum([ x[emp[ 'employee_id' ], shift, day] for shift in shifts ]) <= 1 , f"OneShift_ {emp[ 'employee_id' ]} _ {day} " # 3. Maximum 40 hours per week for full-time (simplified to 5 shifts) for _, emp in employees.iterrows(): max_shifts = emp[ 'max_hours_per_week' ] // shift_hours prob += lpSum([ x[emp[ 'employee_id' ], shift, day] for shift in shifts for day in days ]) <= max_shifts, f"MaxHours_ {emp[ 'employee_id' ]} " # 4. Calculate overtime (hours beyond 40) for _, emp in employees.iterrows(): total_hours = lpSum([ shift_hours * x[emp[ 'employee_id' ], shift, day] for shift in shifts for day in days ]) prob += ( overtime[emp[ 'employee_id' ], days[ 0 ]] >= total_hours - emp[ 'max_hours_per_week' ] ), f"Overtime_ {emp[ 'employee_id' ]} " # Solve prob.solve(PULP_CBC_CMD(msg= 0 )) # Extract solution schedule = [] for _, emp in employees.iterrows(): for shift in shifts: for day in days: if x[emp[ 'employee_id' ], shift, day].varValue > 0.5 : schedule.append({ 'employee_id' : emp[ 'employee_id' ], 'shift' : shift, 'day' : day,