Sales & Operations Planning (S&OP)

You are an expert in Sales & Operations Planning (S&OP) and Integrated Business Planning (IBP). Your goal is to help organizations implement effective S&OP processes that align demand, supply, finance, and strategy to drive better business decisions.

Initial Assessment

Before implementing or improving S&OP, understand:

Current State
- Existing planning process? (informal, Excel-based, system-driven)
- Planning cycle and frequency? (monthly, weekly)
- Who participates? (Sales, Ops, Finance, Exec team)
- Current pain points and issues?
Organization Context
- Company size and complexity?
- Number of product families/SKUs?
- Geographic scope? (single site, regional, global)
- Industry characteristics? (seasonal, promotional, project-based)
Planning Maturity
- Forecast accuracy levels?
- Cross-functional collaboration quality?
- Data systems and integration?
- Performance measurement?
Business Objectives
- Strategic goals? (growth, margin, service, inventory)
- Key metrics and targets?
- Decision-making authority and governance?
- Stakeholder expectations?

S&OP Framework

S&OP Definition

Sales & Operations Planning (S&OP) is a monthly integrated business management process that brings together all plans for the business (customers, sales, marketing, operations, engineering, finance, product management) into one integrated set of plans.

Key Principles:

Cross-Functional Integration: Break down silos
Forward-Looking: 18-24 month rolling horizon
Executive-Owned: Leadership accountability
Single Version of Truth: One consensus plan
Decision-Focused: Drive actions, not just reports

S&OP vs. IBP (Integrated Business Planning)

Aspect	S&OP	IBP
Scope	Demand-Supply balance	Strategic + Financial integration
Horizon	12-18 months	24-36+ months
Frequency	Monthly	Monthly + quarterly reviews
Focus	Operational alignment	Strategic + operational
Participants	Cross-functional	Includes Finance, Strategy
Outputs	Volume plans	Volume + Financial plans

S&OP Process Steps

Monthly S&OP Cycle

Five-Step Process:

Week 1: Data Gathering & Demand Review
Week 2: Supply/Capacity Review
Week 3: Pre-S&OP Meeting
Week 4: Executive S&OP Meeting
Week 5: Implementation & Monitoring

Step 1: Data Gathering & Forecasting

Objectives:

Collect actual performance data
Generate statistical baseline forecasts
Identify exceptions and anomalies

Activities:

Update actual sales, production, inventory
Run forecasting models
Calculate forecast accuracy
Flag exceptions (large changes, new products)

Outputs:

Statistical forecast by product family
Forecast accuracy metrics (MAPE, bias)
Exception reports
Data quality issues log

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class SopDataGathering:
    """Data gathering and baseline forecasting for S&OP"""

    def __init__(self, historical_data):
        """
        Parameters:
        - historical_data: DataFrame with 'date', 'product_family', 'actual_sales'
        """
        self.data = historical_data

    def calculate_forecast_accuracy(self, forecast_col='forecast',
                                    actual_col='actual_sales'):
        """Calculate forecast accuracy metrics"""

        df = self.data.copy()

        # MAPE (Mean Absolute Percentage Error)
        df['ape'] = np.abs((df[actual_col] - df[forecast_col]) / df[actual_col]) * 100
        mape = df['ape'].mean()

        # Bias (average error)
        df['error'] = df[forecast_col] - df[actual_col]
        bias = df['error'].mean()
        bias_pct = (bias / df[actual_col].mean()) * 100

        # MAD (Mean Absolute Deviation)
        mad = np.abs(df['error']).mean()

        # Tracking signal
        cumulative_error = df['error'].sum()
        tracking_signal = cumulative_error / mad if mad > 0 else 0

        return {
            'mape': mape,
            'bias': bias,
            'bias_pct': bias_pct,
            'mad': mad,
            'tracking_signal': tracking_signal
        }

    def identify_exceptions(self, threshold_pct=20):
        """
        Identify forecast exceptions requiring attention

        Parameters:
        - threshold_pct: % change threshold for flagging
        """

        df = self.data.copy()

        # Calculate month-over-month change
        df = df.sort_values(['product_family', 'date'])
        df['prev_forecast'] = df.groupby('product_family')['forecast'].shift(1)
        df['forecast_change_pct'] = (
            (df['forecast'] - df['prev_forecast']) / df['prev_forecast'] * 100
        )

        # Flag large changes
        exceptions = df[
            np.abs(df['forecast_change_pct']) > threshold_pct
        ].copy()

        return exceptions[['product_family', 'date', 'forecast',
                          'prev_forecast', 'forecast_change_pct']]

    def generate_baseline_forecast(self, periods_ahead=18):
        """
        Generate statistical baseline forecast

        Simple approach using moving average with trend
        """

        forecasts = []

        for product in self.data['product_family'].unique():
            product_data = self.data[
                self.data['product_family'] == product
            ].sort_values('date')

            # Calculate moving average and trend
            recent_avg = product_data['actual_sales'].tail(3).mean()
            older_avg = product_data['actual_sales'].tail(6).head(3).mean()
            trend = (recent_avg - older_avg) / 3  # Per period trend

            # Generate forecast
            last_date = product_data['date'].max()

            for i in range(1, periods_ahead + 1):
                forecast_date = last_date + pd.DateOffset(months=i)
                forecast_value = recent_avg + (trend * i)
                forecast_value = max(0, forecast_value)  # No negative forecasts

                forecasts.append({
                    'product_family': product,
                    'date': forecast_date,
                    'baseline_forecast': forecast_value,
                    'method': 'MA_with_trend'
                })

        return pd.DataFrame(forecasts)

# Example usage
historical = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=12, freq='MS'),
    'product_family': ['Electronics'] * 12,
    'actual_sales': [1000, 1100, 1050, 1200, 1250, 1300, 1280, 1350, 1400, 1450, 1500, 1550],
    'forecast': [980, 1120, 1000, 1180, 1300, 1250, 1300, 1320, 1380, 1480, 1520, 1500]
})

sop_data = SopDataGathering(historical)

# Calculate accuracy
accuracy = sop_data.calculate_forecast_accuracy()
print("Forecast Accuracy:")
print(f"  MAPE: {accuracy['mape']:.1f}%")
print(f"  Bias: {accuracy['bias_pct']:.1f}%")

# Identify exceptions
exceptions = sop_data.identify_exceptions(threshold_pct=15)
print(f"\nExceptions (>{15}% change): {len(exceptions)}")

# Generate baseline
baseline = sop_data.generate_baseline_forecast(periods_ahead=6)
print("\nBaseline Forecast (next 6 months):")
print(baseline.head())

Step 2: Demand Review

Objectives:

Review and adjust statistical forecast
Incorporate market intelligence
Build consensus demand plan

Participants:

Sales leadership
Marketing
Product management
Demand planning
Finance (observer)

Activities:

Review statistical forecast
Discuss upcoming promotions, launches
Consider market trends, competitive actions
Adjust forecasts based on business intelligence
Document assumptions and risks

Key Questions:

What's changed since last month?
Any new customer wins/losses?
Promotional plans finalized?
Pricing changes impact?
Competitive landscape shifts?

Outputs:

Consensus demand forecast by product family
Demand assumptions documented
Upside/downside scenarios
Risks and opportunities identified

class DemandReview:
    """Demand review and consensus building"""

    def __init__(self, statistical_forecast):
        self.statistical_fcst = statistical_forecast
        self.adjustments = []
        self.assumptions = []

    def add_adjustment(self, product_family, period, adjustment_type,
                      adjustment_value, reason, owner):
        """
        Record demand adjustment

        Parameters:
        - adjustment_type: 'absolute', 'percentage', 'additive'
        - adjustment_value: amount of adjustment
        - reason: business rationale
        - owner: who made the adjustment (Sales, Marketing, etc.)
        """

        self.adjustments.append({
            'product_family': product_family,
            'period': period,
            'adjustment_type': adjustment_type,
            'adjustment_value': adjustment_value,
            'reason': reason,
            'owner': owner,
            'timestamp': datetime.now()
        })

    def add_assumption(self, assumption_text, category, impact_level):
        """
        Document planning assumption

        Parameters:
        - category: 'promotion', 'market', 'competitive', 'economic'
        - impact_level: 'low', 'medium', 'high'
        """

        self.assumptions.append({
            'assumption': assumption_text,
            'category': category,
            'impact_level': impact_level,
            'date_added': datetime.now()
        })

    def calculate_consensus_forecast(self):
        """Apply adjustments to create consensus forecast"""

        consensus = self.statistical_fcst.copy()

        for adj in self.adjustments:
            mask = (
                (consensus['product_family'] == adj['product_family']) &
                (consensus['period'] == adj['period'])
            )

            if adj['adjustment_type'] == 'percentage':
                consensus.loc[mask, 'consensus_forecast'] = (
                    consensus.loc[mask, 'statistical_forecast'] *
                    (1 + adj['adjustment_value'] / 100)
                )
            elif adj['adjustment_type'] == 'additive':
                consensus.loc[mask, 'consensus_forecast'] = (
                    consensus.loc[mask, 'statistical_forecast'] +
                    adj['adjustment_value']
                )
            elif adj['adjustment_type'] == 'absolute':
                consensus.loc[mask, 'consensus_forecast'] = adj['adjustment_value']

        # Calculate forecast value added (FVA)
        consensus['adjustment'] = (
            consensus['consensus_forecast'] - consensus['statistical_forecast']
        )

        return consensus

    def create_demand_scenarios(self, consensus_forecast):
        """
        Create upside/downside scenarios

        Typically: Base, Optimistic (+15%), Pessimistic (-15%)
        """

        scenarios = consensus_forecast.copy()

        scenarios['base_case'] = scenarios['consensus_forecast']
        scenarios['optimistic'] = scenarios['consensus_forecast'] * 1.15
        scenarios['pessimistic'] = scenarios['consensus_forecast'] * 0.85

        return scenarios

    def get_adjustment_summary(self):
        """Summarize adjustments by owner and type"""

        if not self.adjustments:
            return pd.DataFrame()

        df = pd.DataFrame(self.adjustments)

        summary = df.groupby(['owner', 'adjustment_type']).agg({
            'adjustment_value': ['count', 'sum', 'mean']
        }).reset_index()

        return summary

# Example
statistical_fcst = pd.DataFrame({
    'product_family': ['Electronics', 'Electronics', 'Appliances', 'Appliances'],
    'period': ['2025-01', '2025-02', '2025-01', '2025-02'],
    'statistical_forecast': [10000, 10200, 5000, 5100]
})

demand_review = DemandReview(statistical_fcst)

# Add adjustments
demand_review.add_adjustment(
    product_family='Electronics',
    period='2025-01',
    adjustment_type='percentage',
    adjustment_value=10,  # +10%
    reason='New product launch expected to drive 10% uplift',
    owner='Product Management'
)

demand_review.add_adjustment(
    product_family='Appliances',
    period='2025-02',
    adjustment_type='additive',
    adjustment_value=-500,
    reason='Competitor pricing pressure',
    owner='Sales'
)

# Add assumptions
demand_review.add_assumption(
    'Q1 promotional campaign will increase demand 10-15%',
    category='promotion',
    impact_level='high'
)

# Calculate consensus
consensus = demand_review.calculate_consensus_forecast()
print("Consensus Demand Forecast:")
print(consensus)

# Scenarios
scenarios = demand_review.create_demand_scenarios(consensus)
print("\nDemand Scenarios:")
print(scenarios[['product_family', 'period', 'pessimistic', 'base_case', 'optimistic']])

Step 3: Supply Review

Objectives:

Assess supply capacity to meet demand
Identify constraints and gaps
Develop supply alternatives

Participants:

Operations leadership
Manufacturing
Procurement
Supply planning
Engineering

Activities:

Review production capacity vs. demand
Identify bottlenecks and constraints
Assess supplier capability
Evaluate inventory positions
Propose supply solutions

Key Questions:

Can we meet the demand plan?
What are the constraints?
Lead time for capacity additions?
Supply chain risks?
Cost implications?

Outputs:

Supply plan by product family
Capacity gaps identified
Alternative supply scenarios
Inventory strategy
Investment requirements

class SupplyReview:
    """Supply review and capacity analysis"""

    def __init__(self, consensus_demand, capacity_data):
        """
        Parameters:
        - consensus_demand: demand forecast
        - capacity_data: available capacity by period
        """
        self.demand = consensus_demand
        self.capacity = capacity_data

    def analyze_capacity_gaps(self):
        """Identify where demand exceeds capacity"""

        # Merge demand and capacity
        analysis = self.demand.merge(
            self.capacity,
            on=['product_family', 'period'],
            how='left'
        )

        # Calculate gap
        analysis['gap'] = analysis['available_capacity'] - analysis['consensus_forecast']
        analysis['gap_pct'] = (analysis['gap'] / analysis['available_capacity']) * 100
        analysis['status'] = analysis['gap'].apply(
            lambda x: 'OK' if x >= 0 else 'CONSTRAINED'
        )

        # Utilization
        analysis['utilization'] = (
            analysis['consensus_forecast'] / analysis['available_capacity'] * 100
        )

        return analysis

    def propose_supply_scenarios(self, gap_analysis):
        """
        Develop supply alternatives for constrained periods

        Scenarios:
        1. Do Nothing (accept stockouts)
        2. Add Overtime
        3. Outsource
        4. Build Ahead
        """

        constrained = gap_analysis[gap_analysis['status'] == 'CONSTRAINED'].copy()

        if constrained.empty:
            return pd.DataFrame()

        scenarios = []

        for idx, row in constrained.iterrows():
            product = row['product_family']
            period = row['period']
            shortage = abs(row['gap'])

            # Scenario 1: Do Nothing
            scenarios.append({
                'product_family': product,
                'period': period,
                'scenario': 'Do Nothing',
                'additional_supply': 0,
                'cost': shortage * 100,  # Lost sales cost
                'risk': 'High',
                'feasibility': 'Certain'
            })

            # Scenario 2: Overtime
            overtime_capacity = row['available_capacity'] * 0.15  # 15% OT
            overtime_supply = min(shortage, overtime_capacity)
            scenarios.append({
                'product_family': product,
                'period': period,
                'scenario': 'Overtime',
                'additional_supply': overtime_supply,
                'cost': overtime_supply * 15,  # Premium cost
                'risk': 'Medium',
                'feasibility': 'High'
            })

            # Scenario 3: Outsource
            scenarios.append({
                'product_family': product,
                'period': period,
                'scenario': 'Outsource',
                'additional_supply': shortage,
                'cost': shortage * 20,  # Outsource premium
                'risk': 'Medium',
                'feasibility': 'Medium'
            })

            # Scenario 4: Build Ahead
            # Produce in prior period
            scenarios.append({
                'product_family': product,
                'period': period,
                'scenario': 'Build Ahead',
                'additional_supply': shortage,
                'cost': shortage * 5,  # Inventory holding cost
                'risk': 'Low',
                'feasibility': 'High'
            })

        return pd.DataFrame(scenarios)

    def calculate_inventory_plan(self, gap_analysis, safety_stock_days=30):
        """
        Develop inventory strategy

        Target: Safety stock + cycle stock
        """

        inventory_plan = gap_analysis.copy()

        # Daily demand rate
        inventory_plan['daily_demand'] = inventory_plan['consensus_forecast'] / 30

        # Safety stock
        inventory_plan['safety_stock'] = inventory_plan['daily_demand'] * safety_stock_days

        # Cycle stock (assume monthly production)
        inventory_plan['cycle_stock'] = inventory_plan['consensus_forecast'] / 2

        # Target inventory
        inventory_plan['target_inventory'] = (
            inventory_plan['safety_stock'] + inventory_plan['cycle_stock']
        )

        return inventory_plan[['product_family', 'period', 'consensus_forecast',
                              'safety_stock', 'cycle_stock', 'target_inventory']]

# Example
consensus_demand = pd.DataFrame({
    'product_family': ['Electronics', 'Electronics', 'Appliances'],
    'period': ['2025-01', '2025-02', '2025-01'],
    'consensus_forecast': [11000, 10200, 4500]
})

capacity_data = pd.DataFrame({
    'product_family': ['Electronics', 'Electronics', 'Appliances'],
    'period': ['2025-01', '2025-02', '2025-01'],
    'available_capacity': [10000, 12000, 5000]
})

supply_review = SupplyReview(consensus_demand, capacity_data)

# Analyze gaps
gaps = supply_review.analyze_capacity_gaps()
print("Capacity Gap Analysis:")
print(gaps[['product_family', 'period', 'consensus_forecast',
            'available_capacity', 'gap', 'status', 'utilization']])

# Propose scenarios
scenarios = supply_review.propose_supply_scenarios(gaps)
if not scenarios.empty:
    print("\nSupply Scenarios for Constrained Periods:")
    print(scenarios)

# Inventory plan
inventory = supply_review.calculate_inventory_plan(gaps)
print("\nInventory Plan:")
print(inventory)

Step 4: Pre-S&OP Meeting

Objectives:

Reconcile demand and supply
Develop recommendations for executive team
Prepare scenarios and trade-offs

Participants:

S&OP process owner/facilitator
Demand planning leader
Supply planning leader
Finance
Selected business unit leaders

Activities:

Review demand-supply balance
Identify gaps and conflicts
Develop scenarios with pros/cons/costs
Align financial impact
Prepare executive presentation

Key Outputs:

Balanced demand-supply plan (base case)
Alternative scenarios with trade-offs
Financial reconciliation
Recommendation with rationale
Open issues requiring executive decision

class PreSopMeeting:
    """Pre-S&OP meeting preparation and analysis"""

    def __init__(self, demand_plan, supply_plan, financial_data):
        self.demand = demand_plan
        self.supply = supply_plan
        self.financial = financial_data

    def create_demand_supply_balance(self):
        """Create integrated view of demand and supply"""

        balance = self.demand.merge(
            self.supply,
            on=['product_family', 'period'],
            how='outer'
        )

        balance['supply_demand_gap'] = (
            balance['supply_plan'] - balance['consensus_forecast']
        )

        balance['inventory_impact'] = balance['supply_demand_gap'].cumsum()

        return balance

    def financial_reconciliation(self, balance_plan):
        """Calculate financial impact of plan"""

        financial = balance_plan.merge(
            self.financial,
            on='product_family',
            how='left'
        )

        # Revenue
        financial['revenue'] = (
            financial['consensus_forecast'] * financial['price_per_unit']
        )

        # COGS
        financial['cogs'] = (
            financial['supply_plan'] * financial['cost_per_unit']
        )

        # Inventory value
        financial['inventory_value'] = (
            financial['inventory_impact'] * financial['cost_per_unit']
        )

        # Gross margin
        financial['gross_margin'] = financial['revenue'] - financial['cogs']

        # Aggregate by period
        summary = financial.groupby('period').agg({
            'revenue': 'sum',
            'cogs': 'sum',
            'gross_margin': 'sum',
            'inventory_value': 'sum'
        }).reset_index()

        summary['gross_margin_pct'] = (
            summary['gross_margin'] / summary['revenue'] * 100
        )

        return summary

    def create_scenario_comparison(self, scenarios_list):
        """
        Compare multiple scenarios

        Parameters:
        - scenarios_list: list of dicts with scenario details
        """

        comparison = pd.DataFrame(scenarios_list)

        # Rank scenarios
        comparison['total_score'] = (
            comparison['service_level'] * 0.4 +
            (100 - comparison['cost_impact_pct']) * 0.3 +
            comparison['feasibility'] * 0.3
        )

        comparison = comparison.sort_values('total_score', ascending=False)

        return comparison

    def generate_executive_summary(self, balance, financials):
        """Create executive summary for S&OP meeting"""

        summary = {
            'planning_period': balance['period'].min(),
            'total_demand': balance['consensus_forecast'].sum(),
            'total_supply': balance['supply_plan'].sum(),
            'net_inventory_change': balance['supply_demand_gap'].sum(),
            'revenue_plan': financials['revenue'].sum(),
            'gross_margin_pct': (
                financials['gross_margin'].sum() /
                financials['revenue'].sum() * 100
            ),
            'constraints': balance[balance['supply_demand_gap'] < 0].shape[0],
            'excess_capacity': balance[balance['supply_demand_gap'] > balance['consensus_forecast'] * 0.2].shape[0]
        }

        return summary

# Example
demand_plan = pd.DataFrame({
    'product_family': ['Electronics'] * 3,
    'period': ['2025-01', '2025-02', '2025-03'],
    'consensus_forecast': [11000, 10200, 10500]
})

supply_plan = pd.DataFrame({
    'product_family': ['Electronics'] * 3,
    'period': ['2025-01', '2025-02', '2025-03'],
    'supply_plan': [10000, 11000, 10500]
})

financial_data = pd.DataFrame({
    'product_family': ['Electronics'],
    'price_per_unit': [100],
    'cost_per_unit': [60]
})

pre_sop = PreSopMeeting(demand_plan, supply_plan, financial_data)

# Create balance
balance = pre_sop.create_demand_supply_balance()
print("Demand-Supply Balance:")
print(balance)

# Financial reconciliation
financials = pre_sop.financial_reconciliation(balance)
print("\nFinancial Summary:")
print(financials)

# Executive summary
exec_summary = pre_sop.generate_executive_summary(balance, financials)
print("\nExecutive Summary:")
for key, value in exec_summary.items():
    print(f"  {key}: {value}")

# Scenario comparison
scenarios = [
    {
        'scenario': 'Base Plan',
        'service_level': 95,
        'cost_impact_pct': 0,
        'feasibility': 90,
        'description': 'Meet demand with overtime'
    },
    {
        'scenario': 'Constrain Demand',
        'service_level': 85,
        'cost_impact_pct': -5,
        'feasibility': 100,
        'description': 'Limit sales to capacity'
    },
    {
        'scenario': 'Outsource',
        'service_level': 98,
        'cost_impact_pct': 15,
        'feasibility': 70,
        'description': 'Use contract manufacturer'
    }
]

scenario_comparison = pre_sop.create_scenario_comparison(scenarios)
print("\nScenario Comparison:")
print(scenario_comparison)

Step 5: Executive S&OP Meeting

Objectives:

Make final decisions on plans
Resolve gaps and trade-offs
Approve resource commitments
Align on strategic priorities

Participants:

CEO or COO (chair)
VP Sales
VP Operations
CFO
VP Supply Chain
VP Product/Marketing
Business unit heads

Duration: 2-4 hours

Agenda:

Review Performance (15 min)
- Last month actual vs. plan
- Key metrics and KPIs
- Forecast accuracy
Demand Review (30 min)
- Consensus demand by product family
- Key changes and assumptions
- Risks and opportunities
Supply Review (30 min)
- Capacity and constraints
- Supply alternatives
- Inventory strategy
Financial Review (20 min)
- Revenue and margin impact
- Working capital
- Budget alignment
Scenarios and Trade-Offs (45 min)
- Present alternatives
- Discuss implications
- Make decisions
Strategic Issues (30 min)
- New product launches
- Capacity investments
- Market opportunities
- Risk mitigation
Decisions and Actions (20 min)
- Document decisions
- Assign action items
- Set follow-ups

Key Decisions:

Approve demand plan
Approve supply and inventory plan
Resource allocation decisions
Investment approvals
Policy changes

Outputs:

Approved S&OP plan
Decision log
Action items with owners
Risks and contingencies

from dataclasses import dataclass
from typing import List
from datetime import datetime

@dataclass
class SopDecision:
    """Record of S&OP decision"""
    decision_id: str
    decision_text: str
    category: str  # 'demand', 'supply', 'financial', 'strategic'
    owner: str
    due_date: datetime
    status: str  # 'approved', 'pending', 'rejected'
    rationale: str
    financial_impact: float

@dataclass
class SopActionItem:
    """Action item from S&OP meeting"""
    action_id: str
    description: str
    owner: str
    due_date: datetime
    status: str  # 'open', 'in_progress', 'completed'
    priority: str  # 'high', 'medium', 'low'

class ExecutiveSopMeeting:
    """Executive S&OP meeting management"""

    def __init__(self, meeting_date):
        self.meeting_date = meeting_date
        self.decisions = []
        self.action_items = []
        self.approved_plan = None

    def add_decision(self, decision: SopDecision):
        """Record a decision from the meeting"""
        self.decisions.append(decision)

    def add_action_item(self, action: SopActionItem):
        """Record an action item"""
        self.action_items.append(action)

    def approve_plan(self, plan_data):
        """Approve the S&OP plan"""
        self.approved_plan = {
            'approval_date': self.meeting_date,
            'plan': plan_data,
            'status': 'approved'
        }

    def generate_meeting_minutes(self):
        """Create meeting minutes document"""

        minutes = {
            'meeting_date': self.meeting_date,
            'decisions_count': len(self.decisions),
            'action_items_count': len(self.action_items),
            'decisions': [
                {
                    'id': d.decision_id,
                    'decision': d.decision_text,
                    'owner': d.owner,
                    'impact': d.financial_impact
                }
                for d in self.decisions
            ],
            'action_items': [
                {
                    'id': a.action_id,
                    'action': a.description,
                    'owner': a.owner,
                    'due': a.due_date,
                    'priority': a.priority
                }
                for a in self.action_items
            ]
        }

        return minutes

    def get_decision_summary(self):
        """Summarize decisions by category"""

        if not self.decisions:
            return pd.DataFrame()

        decisions_df = pd.DataFrame([
            {
                'category': d.category,
                'status': d.status,
                'financial_impact': d.financial_impact
            }
            for d in self.decisions
        ])

        summary = decisions_df.groupby(['category', 'status']).agg({
            'financial_impact': 'sum'
        }).reset_index()

        return summary

# Example
exec_sop = ExecutiveSopMeeting(meeting_date=datetime(2025, 1, 15))

# Record decisions
exec_sop.add_decision(SopDecision(
    decision_id='DEC-001',
    decision_text='Approve demand plan for Q1 with 11K units for Electronics',
    category='demand',
    owner='VP Sales',
    due_date=datetime(2025, 1, 31),
    status='approved',
    rationale='Aligned with new product launch plan',
    financial_impact=0
))

exec_sop.add_decision(SopDecision(
    decision_id='DEC-002',
    decision_text='Authorize overtime to cover Jan capacity gap',
    category='supply',
    owner='VP Operations',
    due_date=datetime(2025, 1, 20),
    status='approved',
    rationale='Most cost-effective option, $150K vs $220K outsourcing',
    financial_impact=-150000
))

exec_sop.add_decision(SopDecision(
    decision_id='DEC-003',
    decision_text='Approve $3.5M investment for new production line',
    category='strategic',
    owner='CFO',
    due_date=datetime(2025, 6, 30),
    status='approved',
    rationale='Required to support Q3 demand growth',
    financial_impact=-3500000
))

# Add action items
exec_sop.add_action_item(SopActionItem(
    action_id='ACT-001',
    description='Finalize contract with overtime labor agency',
    owner='HR Director',
    due_date=datetime(2025, 1, 20),
    status='open',
    priority='high'
))

exec_sop.add_action_item(SopActionItem(
    action_id='ACT-002',
    description='Complete business case for production line investment',
    owner='VP Operations',
    due_date=datetime(2025, 2, 15),
    status='in_progress',
    priority='high'
))

# Generate minutes
minutes = exec_sop.generate_meeting_minutes()
print("S&OP Meeting Minutes:")
print(f"Date: {minutes['meeting_date']}")
print(f"Decisions: {minutes['decisions_count']}")
print(f"Action Items: {minutes['action_items_count']}")

# Decision summary
decision_summary = exec_sop.get_decision_summary()
print("\nDecisions by Category:")
print(decision_summary)

S&OP Maturity Model

Level 1: Reactive (Ad Hoc)

Characteristics:

No formal S&OP process
Excel-based, manual
Sales and Ops don't communicate
Fire-fighting mode

Symptoms:

Frequent expediting
Poor forecast accuracy (<60%)
Excess inventory or stockouts
Missed commitments

Level 2: Rudimentary

Characteristics:

Monthly S&OP meetings started
Some cross-functional participation
Focus on short-term (1-3 months)
Limited data integration

Capabilities:

Basic demand review
Capacity check
Executive awareness

Level 3: Standard

Characteristics:

Structured 5-step process
12-18 month horizon
Good data integration
Regular cadence

Capabilities:

Consensus forecasting
Capacity planning
Financial reconciliation
Scenario analysis

Level 4: Advanced

Characteristics:

Integrated Business Planning (IBP)
24+ month horizon
Strategic alignment
Real-time updates

Capabilities:

Portfolio management
Profitability optimization
What-if simulation
Automated analytics

Level 5: Proactive/Best-in-Class

Characteristics:

Predictive and prescriptive
AI/ML-driven insights
Dynamic planning
Value chain collaboration

Capabilities:

Predictive analytics
Optimization algorithms
Digital twin modeling
External collaboration (suppliers, customers)

S&OP Metrics & KPIs

Forecast Accuracy

MAPE (Mean Absolute Percentage Error)

Target: <20% for aggregate, <30% for detailed
Measured monthly by product family
Track trend over time

Bias

Target: ±5%
Positive bias = over-forecasting
Negative bias = under-forecasting

Forecast Value Added (FVA)

Does manual override improve accuracy?
Measure statistical vs. consensus performance

Supply Performance

Plan Attainment

% of production plan achieved
Target: >95%

Capacity Utilization

% of capacity used
Target: 80-90% (allows flexibility)

Supply Flexibility

Lead time to adjust capacity
% changeover time

Inventory Metrics

Inventory Turns

COGS / Average Inventory
Target: Industry-dependent (6-12 turns typical)

Days of Supply

Inventory / Daily Sales
Target: 30-60 days

Inventory Accuracy

% of SKUs within tolerance
Target: >95%

Financial Metrics

Revenue Plan Attainment

Actual revenue / plan
Target: 95-105%

Gross Margin

% margin vs. plan
Track variance drivers

Working Capital

Cash tied up in inventory
Optimize cash-to-cash cycle

Process Metrics

Meeting Effectiveness

% decisions made on time
Action item completion rate
Participant engagement scores

Cycle Time

Time from data gathering to decision
Target: <4 weeks

Plan Stability

How often plan changes
Nervousness metric

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

class SopMetrics:
    """S&OP performance metrics tracking"""

    def __init__(self):
        self.metrics_history = []

    def calculate_monthly_metrics(self, actual_data, plan_data):
        """
        Calculate S&OP metrics for a month

        Parameters:
        - actual_data: actual performance
        - plan_data: planned performance
        """

        # Forecast accuracy (MAPE)
        mape = np.mean(
            np.abs((actual_data['demand'] - plan_data['forecast']) /
                   actual_data['demand'])
        ) * 100

        # Bias
        bias = np.mean(plan_data['forecast'] - actual_data['demand'])
        bias_pct = (bias / np.mean(actual_data['demand'])) * 100

        # Plan attainment
        plan_attainment = (
            actual_data['production'].sum() / plan_data['production_plan'].sum()
        ) * 100

        # Inventory metrics
        inventory_turns = (
            actual_data['cogs'].sum() /
            actual_data['avg_inventory'].mean()
        )

        days_of_supply = (
            actual_data['ending_inventory'].iloc[-1] /
            (actual_data['demand'].sum() / 30)
        )

        # Revenue attainment
        revenue_attainment = (
            actual_data['revenue'].sum() / plan_data['revenue_plan'].sum()
        ) * 100

        metrics = {
            'period': actual_data['period'].iloc[0],
            'mape': mape,
            'bias_pct': bias_pct,
            'plan_attainment': plan_attainment,
            'inventory_turns': inventory_turns,
            'days_of_supply': days_of_supply,
            'revenue_attainment': revenue_attainment
        }

        self.metrics_history.append(metrics)

        return metrics

    def plot_metrics_dashboard(self):
        """Create S&OP metrics dashboard"""

        if not self.metrics_history:
            return None

        df = pd.DataFrame(self.metrics_history)

        fig, axes = plt.subplots(2, 3, figsize=(16, 10))
        fig.suptitle('S&OP Performance Dashboard', fontsize=16, fontweight='bold')

        # MAPE
        axes[0, 0].plot(df['period'], df['mape'], marker='o', linewidth=2)
        axes[0, 0].axhline(y=20, color='r', linestyle='--', label='Target')
        axes[0, 0].set_title('Forecast Accuracy (MAPE)')
        axes[0, 0].set_ylabel('MAPE (%)')
        axes[0, 0].legend()
        axes[0, 0].grid(True, alpha=0.3)

        # Bias
        axes[0, 1].plot(df['period'], df['bias_pct'], marker='o', linewidth=2, color='orange')
        axes[0, 1].axhline(y=5, color='r', linestyle='--', alpha=0.5)
        axes[0, 1].axhline(y=-5, color='r', linestyle='--', alpha=0.5)
        axes[0, 1].set_title('Forecast Bias')
        axes[0, 1].set_ylabel('Bias (%)')
        axes[0, 1].grid(True, alpha=0.3)

        # Plan Attainment
        axes[0, 2].plot(df['period'], df['plan_attainment'], marker='o', linewidth=2, color='green')
        axes[0, 2].axhline(y=95, color='r', linestyle='--', label='Min Target')
        axes[0, 2].axhline(y=105, color='r', linestyle='--')
        axes[0, 2].set_title('Plan Attainment')
        axes[0, 2].set_ylabel('Attainment (%)')
        axes[0, 2].legend()
        axes[0, 2].grid(True, alpha=0.3)

        # Inventory Turns
        axes[1, 0].plot(df['period'], df['inventory_turns'], marker='o', linewidth=2, color='purple')
        axes[1, 0].axhline(y=8, color='g', linestyle='--', label='Target')
        axes[1, 0].set_title('Inventory Turns')
        axes[1, 0].set_ylabel('Turns')
        axes[1, 0].legend()
        axes[1, 0].grid(True, alpha=0.3)

        # Days of Supply
        axes[1, 1].plot(df['period'], df['days_of_supply'], marker='o', linewidth=2, color='brown')
        axes[1, 1].axhline(y=45, color='g', linestyle='--', label='Target')
        axes[1, 1].set_title('Days of Supply')
        axes[1, 1].set_ylabel('Days')
        axes[1, 1].legend()
        axes[1, 1].grid(True, alpha=0.3)

        # Revenue Attainment
        axes[1, 2].plot(df['period'], df['revenue_attainment'], marker='o', linewidth=2, color='red')
        axes[1, 2].axhline(y=95, color='r', linestyle='--', alpha=0.5)
        axes[1, 2].axhline(y=105, color='r', linestyle='--', alpha=0.5)
        axes[1, 2].axhspan(95, 105, alpha=0.2, color='green')
        axes[1, 2].set_title('Revenue Attainment')
        axes[1, 2].set_ylabel('Attainment (%)')
        axes[1, 2].grid(True, alpha=0.3)

        plt.tight_layout()

        return fig

# Example
metrics = SopMetrics()

# Simulate 6 months of data
for month in range(1, 7):
    actual = pd.DataFrame({
        'period': [f'2025-{month:02d}'],
        'demand': [10000 + np.random.randint(-500, 500)],
        'production': [10000 + np.random.randint(-300, 300)],
        'revenue': [1000000 + np.random.randint(-50000, 50000)],
        'cogs': [600000],
        'avg_inventory': [500000],
        'ending_inventory': [400000]
    })

    plan = pd.DataFrame({
        'forecast': [10000],
        'production_plan': [10000],
        'revenue_plan': [1000000]
    })

    monthly_metrics = metrics.calculate_monthly_metrics(actual, plan)
    print(f"Month {month} Metrics: MAPE={monthly_metrics['mape']:.1f}%")

# Plot dashboard
metrics.plot_metrics_dashboard()

Tools & Libraries

Python Libraries

Data Analysis:

pandas: Data manipulation
numpy: Numerical computations
scipy: Statistical analysis

Optimization:

pulp: Linear programming
pyomo: Advanced optimization

Visualization:

matplotlib, seaborn: Charts
plotly: Interactive dashboards
dash: Web applications

Commercial S&OP Software

Enterprise Platforms:

Kinaxis RapidResponse: Leading S&OP/IBP platform
o9 Solutions: AI-powered digital platform
SAP IBP: Integrated Business Planning
Oracle Cloud Supply Chain Planning: S&OP modules
Blue Yonder: S&OP and demand-supply matching
Anaplan: Connected planning platform
Logility: Supply chain planning suite

Collaboration Tools:

Microsoft Teams: Meeting and collaboration
Slack: Async communication
Miro / Mural: Virtual whiteboarding
Power BI / Tableau: Visualization

Excel / Google Sheets

Still widely used for S&OP in mid-size companies:

Planning templates
Scenario modeling
Financial reconciliation
Executive dashboards

Common Challenges & Solutions

Challenge: Poor Cross-Functional Collaboration

Problem:

Silos between Sales and Operations
Finger-pointing and blame
Low meeting engagement

Solutions:

Executive sponsorship and accountability
Clear roles and responsibilities (RACI)
Shared metrics and incentives
Trust-building activities
Professional facilitation

Challenge: Data Quality and Integration

Problem:

Multiple sources of truth
Manual data gathering
Errors and inconsistencies
Time-consuming preparation

Solutions:

Single integrated system
Automated data feeds
Data governance process
Master data management
Exception-based review

Challenge: Short-Term Focus

Problem:

Only look 1-3 months ahead
Reactive vs. proactive
Miss strategic issues

Solutions:

Extend horizon to 18-24 months
Monthly rolling forecasts
Quarterly strategic reviews
Long-term capacity planning
New product integration

Challenge: Meeting Overload

Problem:

Too many meetings
Repetitive discussions
Decision fatigue

Solutions:

Streamline to 5-step process
Pre-work and preparation
Clear agendas and time limits
Delegate tactical decisions
Exception-based reviews

Challenge: Lack of Executive Engagement

Problem:

Executives skip meetings
Rubber-stamp decisions
Don't see value

Solutions:

Right level of detail (strategic, not tactical)
Clear decision needs
Show business impact
Tie to financial results
Success stories and wins

Output Format

S&OP Report Structure

Executive Dashboard (1 page):

Metric	Current	Target	Status
Forecast Accuracy (MAPE)	18.5%	<20%	✓
Plan Attainment	96%	>95%	✓
Inventory Turns	7.2	8.0	⚠
Revenue Attainment	102%	95-105%	✓

Demand Plan by Product Family:

Family	Jan	Feb	Mar	Q1 Total	vs. Last Month	vs. Last Year
Electronics	11,000	10,200	10,500	31,700	+5%	+12%
Appliances	4,500	4,800	5,000	14,300	+2%	+8%

Supply Plan & Constraints:

Family	Demand	Capacity	Gap	Status	Solution
Electronics	11,000	10,000	(1,000)	Constrained	Overtime approved
Appliances	4,500	5,000	+500	OK	Normal production

Financial Summary:

Metric	This Month	Next Month	Q1 Plan
Revenue	$1.5M	$1.4M	$4.3M
COGS	$0.9M	$0.85M	$2.6M
Gross Margin %	40%	39%	39.5%
Inventory Value	$5.2M	$5.0M	$5.0M

Decisions Made:

Approve Q1 demand plan with noted assumptions
Authorize overtime for Electronics in January
Proceed with capacity expansion business case
Review appliance pricing strategy by March

Action Items:

Finalize contract with overtime agency (HR, Jan 20)
Complete expansion business case (Ops, Feb 15)
Pricing analysis for appliances (Marketing, Mar 1)

Questions to Ask

If you need more context:

What's the current S&OP process maturity level?
Who participates in S&OP currently?
What's the planning horizon? (months ahead)
What systems/tools are used?
What are the biggest challenges or pain points?
Who owns the S&OP process?
How are forecasts created today?
What decisions typically need to be made?

Related Skills

demand-forecasting: For demand planning input to S&OP
capacity-planning: For supply capacity analysis
master-production-scheduling: For detailed execution
scenario-planning: For risk analysis and alternatives
inventory-optimization: For inventory strategy
supply-chain-analytics: For metrics and KPIs
network-design: For strategic network decisions
financial-planning: For financial reconciliation

sales-operations-planning

Sales & Operations Planning (S&OP)

Initial Assessment

S&OP Framework

S&OP Definition

S&OP vs. IBP (Integrated Business Planning)

S&OP Process Steps

Monthly S&OP Cycle

Step 1: Data Gathering & Forecasting

Step 2: Demand Review

Step 3: Supply Review

Step 4: Pre-S&OP Meeting

Step 5: Executive S&OP Meeting

S&OP Maturity Model

Level 1: Reactive (Ad Hoc)

Level 2: Rudimentary

Level 3: Standard

Level 4: Advanced

Level 5: Proactive/Best-in-Class

S&OP Metrics & KPIs

Forecast Accuracy

Supply Performance

Inventory Metrics

Financial Metrics

Process Metrics

Tools & Libraries

Python Libraries

Commercial S&OP Software

Excel / Google Sheets

Common Challenges & Solutions

Challenge: Poor Cross-Functional Collaboration

Challenge: Data Quality and Integration

Challenge: Short-Term Focus

Challenge: Meeting Overload

Challenge: Lack of Executive Engagement

Output Format

S&OP Report Structure

Questions to Ask

Related Skills