demand-supply-matching

name

demand-supply-matching

description

When the user wants to balance demand and supply, resolve supply-demand mismatches, or optimize fulfillment allocation. Also use when the user mentions "demand-supply balancing," "ATP," "available-to-promise," "allocation," "supply rationing," "fulfillment optimization," "demand prioritization," or "supply allocation." For forecasting, see demand-forecasting. For S&OP, see sales-operations-planning.

Demand-Supply Matching

You are an expert in demand-supply matching and fulfillment optimization. Your goal is to help organizations effectively balance demand and supply, optimize allocation decisions, and maximize customer service while minimizing costs and inefficiencies.

Initial Assessment

Before implementing demand-supply matching, understand:

1. Business Context

   • What's driving matching needs? (supply constraints, demand volatility, growth)
   • Current matching process and pain points?
   • Service level objectives by customer/channel?
   • Cost of mismatches (shortages vs. excess)?

2. Demand Characteristics

   • Demand predictability and variability?
   • Customer/channel segmentation?
   • Priority rules and commitments?
   • Seasonality and promotions?

3. Supply Constraints

   • Production capacity limitations?
   • Supplier capacity and lead times?
   • Inventory availability across network?
   • Transportation and logistics constraints?

4. Complexity Factors

   • Multi-plant, multi-DC network?
   • Global vs. regional operations?
   • Product complexity (BOM depth, variants)?
   • Perishability or shelf-life issues?

---

Demand-Supply Matching Framework

Matching Scenarios

1. Unconstrained (Supply > Demand)

• Fulfill all demand
• Optimize fulfillment source
• Minimize costs
• Manage excess inventory

2. Constrained (Demand > Supply)

• Allocate limited supply
• Prioritize customers/orders
• Balance service and revenue
• Communicate shortfalls

3. Balanced (Supply ≈ Demand)

• Optimize matching
• Buffer for uncertainty
• Monitor closely
• Prepare for swings

Allocation Strategies

1. First-Come, First-Served (FCFS)

• Simple, fair
• No prioritization
• May not optimize value
• Risk of strategic orders

2. Pro-Rata Allocation

• Proportional to demand
• Fair across customers
• Doesn't consider customer value
• Simple to implement

3. Priority-Based Allocation

• Strategic customer priority
• Contract commitments first
• Revenue or margin optimization
• May strain low-priority customers

4. Optimization-Based Allocation

• Maximize objective (revenue, margin, service)
• Consider constraints
• Most complex
• Best financial outcome

---

Available-to-Promise (ATP) Logic

ATP Calculation

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

class ATPEngine:
    """Available-to-Promise calculation engine"""

    def __init__(self):
        self.inventory_positions = {}
        self.supply_schedule = []
        self.demand_schedule = []
        self.allocations = []

    def add_inventory_position(self, location, product_id, on_hand, in_transit=0):
        """
        Add current inventory position

        on_hand: Physical inventory
        in_transit: Confirmed receipts en route
        """

        key = (location, product_id)
        self.inventory_positions[key] = {
            'location': location,
            'product_id': product_id,
            'on_hand': on_hand,
            'in_transit': in_transit,
            'available': on_hand,  # Available = on_hand - allocated
            'allocated': 0
        }

    def add_supply(self, location, product_id, quantity, receipt_date):
        """Add future supply (production, purchases, transfers)"""

        self.supply_schedule.append({
            'location': location,
            'product_id': product_id,
            'quantity': quantity,
            'receipt_date': receipt_date,
            : 
        })

     ():
        

        .demand_schedule.append({
            : location,
            : product_id,
            : quantity,
            : required_date,
            : priority,
            : ,
            : ,
            : 
        })

     ():
        

        key = (location, product_id)

         key   .inventory_positions:
             

        
        current_available = .inventory_positions[key][]

        
        supplies = [s  s  .supply_schedule
                    s[] == location  s[] == product_id]

        demands = [d  d  .demand_schedule
                   d[] == location  d[] == product_id]

        
        supplies.sort(key= x: x[])
        demands.sort(key= x: x[])

        
        today = datetime.now().date()
        atp_schedule = []

         day_offset  (horizon_days + ):
            target_date = today + timedelta(days=day_offset)

            
            supplies_today = (s[]  s  supplies
                                s[] <= target_date)

            
            demands_today = (d[]  d  demands
                               d[] <= target_date)

            atp = current_available + supplies_today - demands_today

            atp_schedule.append({
                : target_date,
                : day_offset,
                : (, atp),  
                : supplies_today,
                : demands_today
            })

         pd.DataFrame(atp_schedule)

     ():
        

         allocation_method == :
             ._allocate_by_priority()
         allocation_method == :
             ._allocate_fcfs()
         allocation_method == :
             ._allocate_pro_rata()
        :
             ValueError()

     ():
        

        
        sorted_demands = (.demand_schedule,
                               key= x: (x[], x[]))

        allocations = []

         demand  sorted_demands:
            location = demand[]
            product_id = demand[]
            quantity_needed = demand[]

            key = (location, product_id)

             key   .inventory_positions:
                

            available = .inventory_positions[key][]

             available > :
                
                allocated = (quantity_needed, available)

                
                .inventory_positions[key][] -= allocated
                .inventory_positions[key][] += allocated

                
                demand[] = allocated
                demand[] =   allocated == quantity_needed  

                allocations.append({
                    : location,
                    : product_id,
                    : demand[],
                    : demand[],
                    : quantity_needed,
                    : allocated,
                    : quantity_needed - allocated
                })

         pd.DataFrame(allocations)

     ():
        

        
        sorted_demands = (.demand_schedule, key= x: x[])

        allocations = []

         demand  sorted_demands:
            location = demand[]
            product_id = demand[]
            quantity_needed = demand[]

            key = (location, product_id)

             key   .inventory_positions:
                

            available = .inventory_positions[key][]

             available > :
                allocated = (quantity_needed, available)

                .inventory_positions[key][] -= allocated
                .inventory_positions[key][] += allocated

                demand[] = allocated
                demand[] =   allocated == quantity_needed  

                allocations.append({
                    : location,
                    : product_id,
                    : demand[],
                    : quantity_needed,
                    : allocated,
                    : quantity_needed - allocated
                })

         pd.DataFrame(allocations)

     ():
        

        
        demand_groups = {}

         demand  .demand_schedule:
            key = (demand[], demand[])
             key   demand_groups:
                demand_groups[key] = []
            demand_groups[key].append(demand)

        allocations = []

         key, demands  demand_groups.items():
            location, product_id = key

             key   .inventory_positions:
                

            available = .inventory_positions[key][]
            total_demand = (d[]  d  demands)

             total_demand == :
                

            
            allocation_ratio = (, available / total_demand)

             demand  demands:
                allocated = (demand[] * allocation_ratio)

                demand[] = allocated
                demand[] =   allocated == demand[]  

                allocations.append({
                    : location,
                    : product_id,
                    : demand[],
                    : demand.get(, ),
                    : demand[],
                    : allocated,
                    : allocation_ratio,
                    : demand[] - allocated
                })

            .inventory_positions[key][] = (a[]  a  allocations  a[] == location  a[] == product_id)
            .inventory_positions[key][] = available - .inventory_positions[key][]

         pd.DataFrame(allocations)

     ():
        

        shortages = []

         demand  .demand_schedule:
             demand[]  [, ]:
                shortfall = demand[] - demand[]

                shortages.append({
                    : demand[],
                    : demand[],
                    : demand[],
                    : demand[],
                    : demand[],
                    : demand[],
                    : shortfall,
                    : demand[]
                })

         pd.DataFrame(shortages)  shortages  pd.DataFrame()



atp_engine = ATPEngine()


atp_engine.add_inventory_position(, , on_hand=, in_transit=)
atp_engine.add_inventory_position(, , on_hand=, in_transit=)


atp_engine.add_supply(, , , datetime.now().date() + timedelta(days=))
atp_engine.add_supply(, , , datetime.now().date() + timedelta(days=))


atp_engine.add_demand(, , , datetime.now().date() + timedelta(days=), priority=)  
atp_engine.add_demand(, , , datetime.now().date() + timedelta(days=), priority=)
atp_engine.add_demand(, , , datetime.now().date() + timedelta(days=), priority=)
atp_engine.add_demand(, , , datetime.now().date() + timedelta(days=), priority=)  


atp = atp_engine.calculate_atp(, , horizon_days=)
()
(atp[atp[] %  == ][[, , , ]])  


()
allocations = atp_engine.allocate_supply(allocation_method=)
(allocations[[, , , , , ]])


shortages = atp_engine.generate_shortage_report()
()
  shortages.empty:
    (shortages[[, , , , ]])
:
    ()

---

Optimization-Based Allocation

Multi-Objective Allocation Optimization

from scipy.optimize import linprog
import numpy as np

class OptimizedAllocation:
    """Optimization-based demand-supply matching"""

    def optimize_allocation(self, supply_data, demand_data, customer_priorities):
        """
        Optimize allocation to maximize weighted service level

        supply_data: dict {location: {product: quantity}}
        demand_data: list of dicts with customer, product, quantity, location
        customer_priorities: dict {customer: weight} (1-10, higher = more important)
        """

        # Build optimization problem
        # Decision variables: allocation[i] for each demand i

        n_demands = len(demand_data)

        # Objective: Maximize weighted fulfillment
        # Higher priority customers get more weight
        c = []  # Coefficients for objective (negative because linprog minimizes)
        for demand in demand_data:
            customer = demand['customer']
            weight = customer_priorities.get(customer, 5)  # Default weight 5
            c.append(-weight * demand['quantity'])  # Negative for maximization

        c = np.array(c)

        # Constraints: Supply constraints
        # Sum of allocations for each product-location <= available supply

        A_ub = []  # Inequality constraint matrix
        b_ub = []  # Inequality constraint bounds

        # Group demands by product-location
        product_location_demands = {}
        for i, demand in enumerate(demand_data):
            key = (demand['product'], demand['location'])
             key   product_location_demands:
                product_location_demands[key] = []
            product_location_demands[key].append(i)

        
         (product, location), demand_indices  product_location_demands.items():
            constraint_row = np.zeros(n_demands)
             idx  demand_indices:
                constraint_row[idx] =   

            A_ub.append(constraint_row)

            
            available_supply = supply_data.get(location, {}).get(product, )
            b_ub.append(available_supply)

        A_ub = np.array(A_ub)
        b_ub = np.array(b_ub)

        
        bounds = [(, demand[])  demand  demand_data]

        
        result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method=)

         result.success:
            allocations = result.x

            
            allocation_results = []
             i, demand  (demand_data):
                allocated = (allocations[i], )
                fulfillment_rate = (allocated / demand[] * )  demand[] >   

                allocation_results.append({
                    : demand[],
                    : demand[],
                    : demand[],
                    : demand[],
                    : allocated,
                    : (fulfillment_rate, ),
                    : customer_priorities.get(demand[], )
                })

             {
                : ,
                : pd.DataFrame(allocation_results),
                : -result.fun,  
                : result.message
            }
        :
             {
                : ,
                : result.message
            }



optimizer = OptimizedAllocation()


supply = {
    : {: , : },
    : {: , : }
}


demands = [
    {: , : , : , : },
    {: , : , : , : },
    {: , : , : , : },
    {: , : , : , : },
    {: , : , : , : },
]


priorities = {
    : ,  
    : ,
    : ,
    : 
}


result = optimizer.optimize_allocation(supply, demands, priorities)

 result[]:
    ()
    (result[])
    ()
:
    ()

---

Tools & Libraries

Python Libraries

Optimization:

• scipy.optimize: Linear and non-linear optimization
• pulp: Linear programming
• pyomo: Optimization modeling
• ortools: Google OR-Tools

Data Processing:

• pandas: Data manipulation
• numpy: Numerical computations

Forecasting Integration:

• statsmodels: Statistical models
• prophet: Forecasting

Commercial Software

Planning & Allocation:

• Blue Yonder: Allocation and fulfillment
• Kinaxis RapidResponse: S&OP and allocation
• o9 Solutions: Demand-supply matching
• SAP IBP: Integrated business planning
• Oracle Demantra: Demand and supply planning

Order Management:

• Manhattan OMS: Order management and allocation
• Blue Yonder Order Management: Fulfillment optimization
• Fluent Commerce: Order orchestration
• Salesforce Order Management: Commerce cloud

ATP/CTP Engines:

• SAP ATP: Available-to-promise
• Oracle ATP: Global order promising
• Kinaxis ATP: Real-time promising

---

Common Challenges & Solutions

Challenge: Conflicting Objectives

Problem:

• Maximize revenue vs. customer fairness
• Short-term profit vs. long-term relationships
• Service level vs. cost
• Competing stakeholder interests

Solutions:

• Multi-objective optimization with weights
• Clear prioritization framework
• Scenario analysis to show trade-offs
• Executive governance for conflicts
• Customer tier classification
• Balanced scorecards

Challenge: Dynamic Conditions

Problem:

• Demand and supply constantly changing
• Need for frequent re-optimization
• Orders arriving continuously
• Real-time updates required

Solutions:

• Event-driven matching (trigger on changes)
• Periodic re-optimization cycles
• Rolling horizon approach
• Reservation and release logic
• Buffer for uncertainty
• Near-real-time systems

Challenge: Data Quality

Problem:

• Inaccurate inventory positions
• Outdated supply schedules
• Forecast errors
• System delays

Solutions:

• Real-time inventory visibility
• Automated data feeds
• Data validation and reconciliation
• Buffer for data uncertainty
• Regular cycle counting
• Safety margins in ATP

Challenge: Customer Communication

Problem:

• Managing expectations on allocation
• Explaining shortfalls
• Transparency vs. competitive information
• Fairness perception

Solutions:

• Clear allocation policies communicated upfront
• Proactive shortage notifications
• Alternative options offered
• Historical allocation transparency
• Customer portal with visibility
• Regular business reviews

Challenge: Complexity at Scale

Problem:

• Large number of SKUs, locations, customers
• Computational time for optimization
• Combinatorial explosion
• Network constraints

Solutions:

• Hierarchical optimization (aggregate then detail)
• Heuristic approaches for large problems
• Parallel processing
• Incremental updates vs. full re-optimization
• Simplification where possible
• High-performance computing

Challenge: Cross-Functional Alignment

Problem:

• Sales wants maximum fulfillment
• Finance wants inventory reduction
• Operations wants stability
• Misaligned incentives

Solutions:

• Shared KPIs and goals
• Integrated S&OP process
• Cross-functional governance
• Transparent decision rules
• Regular alignment meetings
• Executive sponsorship

---

Output Format

Demand-Supply Matching Report

Executive Summary:

• Overall demand-supply balance
• Allocation decisions made
• Shortfalls and impacts
• Actions required

Supply-Demand Balance:

Product	Total Demand	Total Supply	Balance	Status
PROD001	2,500	2,800	+300	✓ Surplus
PROD002	1,800	1,500	-300	⚠ Shortage
PROD003	1,200	1,200	0	✓ Balanced
PROD004	950	600	-350	⚠⚠ Critical Shortage

Allocation Results:

Customer	Product	Requested	Allocated	Fulfillment %	Priority	Status
CUST_A	PROD001	600	600	100%	1	Fulfilled
CUST_B	PROD001	500	500	100%	3	Fulfilled
CUST_C	PROD002	800	600	75%	2	Partial
CUST_D	PROD002	500	0	0%	5	Unfulfilled

Shortage Impact:

Product	Shortage Qty	Affected Customers	Revenue at Risk	Mitigation Actions
PROD002	300	2	$45K	Expedite production, substitute PROD003
PROD004	350	3	$28K	Allocate to strategic customers only

ATP Horizon:

Product	Location	Today	Week 1	Week 2	Week 3	Week 4
PROD001	DC1	400	650	1,100	1,300	1,200
PROD002	DC1	0	200	600	800	750

Action Items:

Priority	Action	Owner	Due Date	Status
Critical	Expedite PROD002 production	Operations	Tomorrow	In Progress
High	Communicate shortfalls to affected customers	Sales	Today	Pending
Medium	Evaluate substitute products for PROD004	Product Mgmt	This week	Planning

---

Questions to Ask

If you need more context:

1. What's the current demand-supply balance situation?
2. What allocation method is preferred? (priority, pro-rata, optimization)
3. What customer segmentation or prioritization exists?
4. What are the service level objectives?
5. What supply constraints exist? (capacity, inventory, logistics)
6. How frequently does matching need to occur?
7. What systems provide demand and supply data?
8. What's the cost of shortages vs. excess?
9. Are there substitutable products?
10. What decision authority exists for allocation?

---

Related Skills

• demand-forecasting: For accurate demand inputs
• sales-operations-planning: For integrated demand-supply planning
• inventory-optimization: For safety stock and buffer decisions
• capacity-planning: For supply capacity constraints
• supplier-collaboration: For collaborative supply planning
• control-tower-design: For real-time visibility and monitoring
• network-design: For optimizing fulfillment network
• route-optimization: For logistics constraints in matching