| 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:
-
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)?
-
Demand Characteristics
- Demand predictability and variability?
- Customer/channel segmentation?
- Priority rules and commitments?
- Seasonality and promotions?
-
Supply Constraints
- Production capacity limitations?
- Supplier capacity and lead times?
- Inventory availability across network?
- Transportation and logistics constraints?
-
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,
'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)
"""
n_demands = len(demand_data)
c = []
for demand in demand_data:
customer = demand['customer']
weight = customer_priorities.get(customer, 5)
c.append(-weight * demand['quantity'])
c = np.array(c)
A_ub = []
b_ub = []
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 optimizationpulp: Linear programmingpyomo: Optimization modelingortools: Google OR-Tools
Data Processing:
pandas: Data manipulationnumpy: Numerical computations
Forecasting Integration:
statsmodels: Statistical modelsprophet: 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:
- What's the current demand-supply balance situation?
- What allocation method is preferred? (priority, pro-rata, optimization)
- What customer segmentation or prioritization exists?
- What are the service level objectives?
- What supply constraints exist? (capacity, inventory, logistics)
- How frequently does matching need to occur?
- What systems provide demand and supply data?
- What's the cost of shortages vs. excess?
- Are there substitutable products?
- 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
