| name | markdown-optimization |
| description | When the user wants to optimize markdown strategy, price optimization for clearance, or minimize inventory markdowns. Also use when the user mentions "markdown," "clearance pricing," "price elasticity," "promotional pricing," "discount optimization," "sell-through," "inventory liquidation," or "dynamic pricing." For initial allocation, see retail-allocation. For promotional planning, see promotional-planning. |
Markdown Optimization
You are an expert in retail markdown optimization and clearance pricing strategy. Your goal is to help retailers maximize revenue recovery from slow-moving inventory, minimize markdown costs, and accelerate sell-through using data-driven pricing decisions.
Initial Assessment
Before optimizing markdowns, understand:
-
Inventory Situation
- What inventory needs markdown? (overstock, seasonal, slow movers)
- Current on-hand quantities by SKU/store?
- Age of inventory? (weeks on hand)
- Original cost and retail price?
- Historical sell-through rates?
-
Business Context
- What's the current markdown rate? (% of sales)
- Target markdown rate?
- Margin constraints? (minimum acceptable margin)
- Seasonality? (end of season pressure)
- Competitive pricing environment?
-
Pricing Flexibility
- Who controls pricing? (centralized, regional, store)
- Markdown frequency? (weekly, monthly, continuous)
- Markdown increment rules? (10%, 20%, 30% steps)
- Minimum/maximum discount limits?
- Can prices be personalized? (dynamic, loyalty-based)
-
Channels & Competition
- Single channel or omnichannel?
- Online pricing flexibility?
- Competitor pricing tracked?
- Outlet stores for clearance?
- Liquidation options? (jobbers, donations)
Markdown Optimization Framework
Markdown Strategy Fundamentals
Key Objectives:
- Maximize revenue recovery: Get highest possible price before going to clearance
- Accelerate sell-through: Clear inventory before it becomes obsolete
- Minimize markdown dollars: Reduce total markdown spend
- Preserve brand perception: Avoid excessive discounting
- Optimize timing: Balance early vs. late markdowns
Markdown Lifecycle:
Full Price → First Markdown (10-25%) → Second Markdown (30-50%) →
Final Clearance (50-75%) → Liquidation/Donation
Decision Framework:
- When to markdown? Monitor sell-through rate, weeks of supply
- How much to markdown? Based on price elasticity, urgency
- Which SKUs to markdown? Prioritize by age, quantity, margin
- Which stores to markdown? Store-specific or chain-wide
Price Elasticity & Demand Modeling
Price-Demand Relationship
import numpy as np
import pandas as pd
from scipy.optimize import minimize
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
class PriceElasticityAnalyzer:
"""
Analyze price elasticity of demand for markdown optimization
Measure how demand changes with price reductions
"""
def __init__(self, historical_pricing_data):
"""
Parameters:
- historical_pricing_data: DataFrame with historical price/sales
columns: ['sku', 'date', 'price', 'units_sold', 'original_price']
"""
self.data = historical_pricing_data
def calculate_price_elasticity(self, sku):
"""
Calculate price elasticity of demand
Elasticity = % change in quantity / % change in price
E > 1: Elastic (demand very sensitive to price)
E = 1: Unit elastic
E < 1: Inelastic (demand not very sensitive)
"""
sku_data = self.data[self.data['sku'] == sku].copy()
if len(sku_data) < 10:
return {'error': 'Insufficient data', 'elasticity': None}
sku_data['discount_pct'] = (
(sku_data['original_price'] - sku_data['price']) /
sku_data['original_price'] * 100
)
sku_data[] = np.log(sku_data[])
sku_data[] = np.log(sku_data[] + )
X = sku_data[[]].values
y = sku_data[].values
model = LinearRegression()
model.fit(X, y)
elasticity = model.coef_[]
r_squared = model.score(X, y)
{
: sku,
: (elasticity),
: r_squared,
: ._interpret_elasticity((elasticity)),
: model
}
():
elasticity > :
elasticity > :
elasticity > :
:
():
elasticity_result = .calculate_price_elasticity(sku)
elasticity_result.get():
model = elasticity_result[]
log_price = np.log(target_price)
log_quantity_pred = model.predict([[log_price]])[]
estimated_quantity = np.exp(log_quantity_pred) -
(, estimated_quantity)
():
elasticity_result = .calculate_price_elasticity(sku)
elasticity_result.get():
{: }
price_range = np.linspace(cost * , current_price, )
results = []
test_price price_range:
estimated_weekly_demand = .estimate_demand_at_price(sku, test_price)
estimated_total_sold = (
estimated_weekly_demand * weeks_remaining,
current_inventory
)
revenue = estimated_total_sold * test_price
margin = test_price - cost
margin_pct = margin / test_price * test_price >
estimated_weekly_demand > :
weeks_to_sellout = current_inventory / estimated_weekly_demand
:
weeks_to_sellout =
results.append({
: test_price,
: (current_price - test_price) / current_price * ,
: estimated_weekly_demand,
: estimated_total_sold,
: revenue,
: margin_pct,
: weeks_to_sellout
})
results_df = pd.DataFrame(results)
optimal_idx = results_df[].idxmax()
optimal = results_df.iloc[optimal_idx]
{
: current_price,
: optimal[],
: optimal[],
: optimal[],
: optimal[] / current_inventory * ,
: optimal[],
: results_df
}
np.random.seed()
dates = pd.date_range(, periods=, freq=)
historical_data = []
week ():
base_price =
discount = (week * , )
price = base_price * ( - discount/)
base_demand =
price_factor = (base_price / price) **
units_sold = base_demand * price_factor + np.random.normal(, )
units_sold = (, units_sold)
historical_data.append({
: ,
: dates[week],
: price,
: units_sold,
: base_price
})
historical_df = pd.DataFrame(historical_data)
analyzer = PriceElasticityAnalyzer(historical_df)
elasticity = analyzer.calculate_price_elasticity()
()
()
()
optimization = analyzer.find_optimal_markdown(
sku=,
cost=,
current_price=,
current_inventory=,
weeks_remaining=
)
()
()
()
()
()
Markdown Timing Optimization
Dynamic Markdown Scheduling
class MarkdownScheduler:
"""
Optimize markdown timing to maximize revenue recovery
Decides when to markdown based on:
- Current sell-through rate
- Time remaining in season
- Inventory level
- Competitive pressure
"""
def __init__(self, season_end_date, current_date):
self.season_end = pd.to_datetime(season_end_date)
self.current_date = pd.to_datetime(current_date)
self.weeks_remaining = (self.season_end - self.current_date).days / 7
def calculate_sell_through_rate(self, units_sold, initial_inventory, weeks_elapsed):
"""
Calculate sell-through rate (STR)
STR = units sold / initial inventory
Weekly STR = STR / weeks
"""
if initial_inventory == 0:
return 0
str_total = units_sold / initial_inventory * 100
str_weekly = str_total / weeks_elapsed if weeks_elapsed > 0 else 0
return {
'total_str': str_total,
'weekly_str': str_weekly,
'units_sold': units_sold,
'initial_inventory': initial_inventory
}
def should_markdown(self, sku_data):
"""
Decide if SKU should be marked down now
Factors:
- Sell-through rate below target
- Weeks of supply too high
- End of season approaching
"""
current_inventory = sku_data['current_inventory']
weekly_sales_rate = sku_data[]
target_str = sku_data.get(, )
projected_str = (weekly_sales_rate * .weeks_remaining) / sku_data[] *
weekly_sales_rate > :
weeks_of_supply = current_inventory / weekly_sales_rate
:
weeks_of_supply =
reasons = []
should_md =
projected_str < target_str:
should_md =
reasons.append()
weeks_of_supply > .weeks_remaining * :
should_md =
reasons.append()
.weeks_remaining < projected_str < :
should_md =
reasons.append()
weekly_sales_rate < sku_data[] * :
should_md =
reasons.append()
{
: should_md,
: reasons,
: projected_str,
: weeks_of_supply,
: .weeks_remaining,
: .weeks_remaining < .weeks_remaining <
}
():
decision = .should_markdown(sku_data)
decision[]:
{
: ,
:
}
weeks_of_supply = decision[]
projected_str = decision[]
elasticity = sku_data.get(, )
projected_str < weeks_of_supply > :
base_markdown =
projected_str < weeks_of_supply > :
base_markdown =
:
base_markdown =
elasticity < :
base_markdown *=
elasticity > :
base_markdown *=
.weeks_remaining < :
base_markdown *=
markdown_increments = [, , , , , , , ]
recommended_markdown = (markdown_increments, key= x: (x - base_markdown))
{
: recommended_markdown,
: ,
: decision[]
}
():
weeks_left = .weeks_remaining
cadence = []
decision = .should_markdown(sku_data)
decision[] == :
week_intervals = [, , ]
decision[] == :
week_intervals = [, , ]
:
week_intervals = [, , ]
i, (markdown_pct, week_offset) ((markdown_stages, week_intervals)):
week_offset < weeks_left:
markdown_date = .current_date + pd.Timedelta(weeks=week_offset)
cadence.append({
: i + ,
: markdown_date,
: markdown_pct,
: sku_data[] * ( - markdown_pct/),
: week_offset
})
cadence
scheduler = MarkdownScheduler(
season_end_date=,
current_date=
)
sku_data = {
: ,
: ,
: ,
: ,
: ,
: ,
:
}
decision = scheduler.should_markdown(sku_data)
()
()
()
()
recommendation = scheduler.recommend_markdown_depth(sku_data)
()
()
cadence = scheduler.create_markdown_cadence(sku_data)
()
stage cadence:
()
Markdown Optimization Models
Multi-SKU Markdown Optimization
from scipy.optimize import minimize, LinearConstraint
class MarkdownOptimizer:
"""
Optimize markdowns across multiple SKUs
Maximize total revenue while meeting clearance targets
"""
def __init__(self, skus_data, constraints):
"""
Parameters:
- skus_data: DataFrame with SKU information
columns: ['sku', 'inventory', 'cost', 'current_price', 'elasticity',
'weekly_demand_base']
- constraints: Dict with budget/target constraints
"""
self.skus = skus_data
self.constraints = constraints
def estimate_demand_at_discount(self, base_demand, elasticity, discount_pct):
"""
Estimate demand at a given discount level
Uses price elasticity to project demand lift
"""
if discount_pct >= 100:
return base_demand * 10
price_ratio = 1 / (1 - discount_pct/100)
demand_multiplier = price_ratio ** elasticity
return base_demand * demand_multiplier
def calculate_revenue(self, discount_percentages):
"""
Calculate total revenue for given discount strategy
Parameters:
- discount_percentages: Array of discount % for each SKU
"""
total_revenue = 0
for i, row in self.skus.iterrows():
discount_pct = discount_percentages[i]
new_price = row[] * ( - discount_pct/)
estimated_demand = .estimate_demand_at_discount(
row[],
row[],
discount_pct
)
units_sold = (estimated_demand * , row[])
revenue = units_sold * new_price
total_revenue += revenue
total_revenue
():
n_skus = (.skus)
():
-.calculate_revenue(discounts)
constraints_list = []
():
max_avg_discount - np.mean(discounts)
constraints_list.append({
: ,
: avg_discount_constraint
})
():
total_cleared =
total_inventory =
i, row .skus.iterrows():
discount_pct = discounts[i]
new_price = row[] * ( - discount_pct/)
estimated_demand = .estimate_demand_at_discount(
row[],
row[],
discount_pct
)
units_sold = (estimated_demand * , row[])
total_cleared += units_sold
total_inventory += row[]
clearance_rate = total_cleared / total_inventory *
clearance_rate - min_clearance_rate
constraints_list.append({
: ,
: clearance_constraint
})
bounds = [(, ) _ (n_skus)]
x0 = np.full(n_skus, )
result = minimize(
objective,
x0,
method=,
bounds=bounds,
constraints=constraints_list
)
optimal_discounts = result.x
results = []
i, row .skus.iterrows():
discount = optimal_discounts[i]
new_price = row[] * ( - discount/)
estimated_demand = .estimate_demand_at_discount(
row[],
row[],
discount
)
units_sold = (estimated_demand * , row[])
revenue = units_sold * new_price
clearance_rate = units_sold / row[] *
results.append({
: row[],
: row[],
: discount,
: new_price,
: units_sold,
: revenue,
: clearance_rate
})
results_df = pd.DataFrame(results)
results_df, result
skus_data = pd.DataFrame({
: [ i (, )],
: np.random.randint(, , ),
: np.random.uniform(, , ),
: np.random.uniform(, , ),
: np.random.uniform(, , ),
: np.random.uniform(, , )
})
optimizer = MarkdownOptimizer(skus_data, {})
optimal_strategy, optimization_result = optimizer.optimize_markdowns(
max_avg_discount=,
min_clearance_rate=
)
()
(optimal_strategy[[, , , , ]])
()
()
()
Store-Level Markdown Decisions
Localized Markdown Strategy:
class StoreMarkdownManager:
"""
Manage store-level markdown decisions
Some stores need different markdown strategies than others
"""
def __init__(self, stores_data):
self.stores = stores_data
def should_markdown_locally(self, sku, store_id, chain_markdown_pct=0):
"""
Decide if store should markdown locally vs. follow chain
Factors:
- Local inventory level (excess?)
- Local sell-through performance
- Local competitive pressure
"""
store = self.stores[self.stores['store_id'] == store_id].iloc[0]
sku_inventory = store.get(f'{sku}_inventory', 0)
sku_weekly_sales = store.get(f'{sku}_weekly_sales', 0)
weeks_of_supply = sku_inventory / sku_weekly_sales if sku_weekly_sales > 0 else 999
local_markdown_needed = False
reasons = []
chain_avg_wos = 8
if weeks_of_supply > chain_avg_wos * 1.5:
local_markdown_needed = True
reasons.append(f"Excess inventory: {weeks_of_supply:.1f} weeks (chain avg: {chain_avg_wos})")
chain_avg_str =
local_str = store.get(, )
local_str < chain_avg_str * :
local_markdown_needed =
reasons.append()
store.get(, ):
local_markdown_needed =
reasons.append()
local_markdown_needed:
recommended_markdown = (chain_markdown_pct + , )
:
recommended_markdown = chain_markdown_pct
{
: local_markdown_needed,
: reasons,
: recommended_markdown,
: weeks_of_supply,
: local_markdown_needed
}
():
stores_with_excess = []
idx, store .stores.iterrows():
sku_inventory = store.get(, )
sku_weekly_sales = store.get(, )
sku_inventory > min_inventory:
weeks_of_supply = sku_inventory / sku_weekly_sales
weeks_of_supply > :
stores_with_excess.append({
: store[],
: sku_inventory,
: weeks_of_supply,
: (sku_inventory * )
})
pd.DataFrame(stores_with_excess)
stores_data = pd.DataFrame({
: [ i (, )],
: np.random.choice([, ], , p=[, ])
})
idx, row stores_data.iterrows():
stores_data.at[idx, ] = np.random.randint(, )
stores_data.at[idx, ] = np.random.randint(, )
stores_data.at[idx, ] = np.random.uniform(, )
manager = StoreMarkdownManager(stores_data)
local_decision = manager.should_markdown_locally(, , chain_markdown_pct=)
()
()
()
transfer_candidates = manager.identify_stores_for_clearance_transfer()
()
(transfer_candidates)
Tools & Libraries
Python Libraries
Optimization:
scipy.optimize: Non-linear optimization for price optimizationpulp, pyomo: Mathematical programmingcvxpy: Convex optimization
Machine Learning:
scikit-learn: Regression for price elasticityxgboost: Price-demand modelingstatsmodels: Statistical analysis
Data Processing:
pandas: Data manipulationnumpy: Numerical computations
Commercial Software
Pricing & Markdown:
- Revionics: Price optimization and markdown management
- Blue Yonder (JDA) Price: AI-powered pricing
- Oracle Retail Price Optimization: Enterprise markdown optimization
- Competera: Dynamic pricing platform
- Pricefx: Cloud pricing software
Analytics:
- Tableau, Power BI: Markdown analytics and visualization
- SAP Analytics: Enterprise analytics
Common Challenges & Solutions
Challenge: Cannibalization Risk
Problem:
- Markdowns cannibalize full-price sales
- Customers wait for discounts
- Erodes full-price sell-through
Solutions:
- Targeted markdowns (store-specific, limited locations)
- Don't advertise broadly
- Use loyalty program for personalized discounts
- Mark down oldest inventory first
- Transfer to outlets vs. markdown in-store
- Separate clearance section
Challenge: Brand Damage from Heavy Discounting
Problem:
- Excessive markdowns hurt brand perception
- Conditions customers to wait for sales
- Race to bottom with competitors
Solutions:
- Strategic markdown limits (max 40-50%)
- Use outlets/clearance stores for deep discounts
- Donation/liquidation vs. very deep markdowns
- Improve buying to reduce markdowns
- Focus on sell-through at full price
- Premium vs. value product segmentation
Challenge: Insufficient Price Elasticity Data
Problem:
- New products have no markdown history
- Can't estimate optimal markdown level
- Guessing leads to suboptimal decisions
Solutions:
- Use analog products (similar items)
- Test different markdowns in pilot stores
- Industry benchmark elasticities
- Assume moderate elasticity (1.0-1.5) as starting point
- Machine learning on product attributes
- Build elasticity database over time
Challenge: Omnichannel Pricing Complexity
Problem:
- Different prices online vs. stores
- Customer confusion and complaints
- Showrooming/webrooming behavior
Solutions:
- Uniform pricing across channels (preferred)
- Online-exclusive clearance section
- Price match guarantees
- Zone-based online pricing
- Clear communication of pricing policy
- Use loyalty for personalization vs. blanket markdowns
Challenge: Markdown Timing Mistakes
Problem:
- Mark down too early → lose full-price sales
- Mark down too late → can't clear inventory
- Both costly errors
Solutions:
- Monitor sell-through rate thresholds
- Automated markdown triggers
- Multi-stage markdown cadence
- Regional timing differences (climate)
- Competitive monitoring
- Post-season analysis to improve next year
Output Format
Markdown Optimization Report
Executive Summary:
- Total inventory at risk: $8.2M retail value (42,000 units)
- Current markdown rate: 28% of sales
- Target markdown rate: <22%
- Recommended markdown strategy: Progressive, targeted approach
- Expected markdown cost: $1.8M (22% of inventory value)
- Expected revenue recovery: $6.4M (78%)
SKU-Level Markdown Recommendations:
| SKU | Category | Inventory | Weeks Supply | Current STR | Recommended Action | Discount % | New Price | Expected Revenue |
|---|
| SKU001 | Outerwear | 850 | 18 | 42% | Markdown now | 40% | $59.99 | $41K |
| SKU002 | Dresses | 1,200 | 22 | 38% | Markdown now | 50% | $39.99 | $38K |
| SKU003 | Tops | 650 | 12 | 58% | Markdown week 3 | 30% | $34.99 | $18K |
| SKU004 | Bottoms | 420 | 8 | 68% | Monitor, no action | 0% | $49.99 | $21K |
| SKU005 | Accessories | 2,100 | 25 | 35% | Transfer to outlet | 60% | $15.99 | $27K |
Markdown Cadence by SKU:
| SKU | Stage 1 | Stage 2 | Stage 3 | Clearance |
|---|
| SKU001 | 30% off (Now) | 50% off (Week 3) | 60% off (Week 6) | Liquidate remainder |
| SKU002 | 40% off (Now) | 60% off (Week 2) | 70% off (Week 5) | Donate remainder |
| SKU003 | 20% off (Week 2) | 40% off (Week 5) | - | - |
Store-Level Variations:
| Store Cluster | Chain Markdown | Local Adjustment | Rationale |
|---|
| High-volume urban | Follow chain | None | On track for sell-through |
| Suburban malls | Follow chain | +10% deeper | Excess inventory, competitive pressure |
| Small format | Follow chain | Transfer to larger stores | Limited space, small quantities |
| Outlets | Aggressive | 60-70% off | Clearance destination |
Financial Impact:
| Metric | Without Optimization | With Optimization | Improvement |
|---|
| Total revenue recovery | $5.8M | $6.4M | +$600K |
| Markdown cost | $2.4M (29%) | $1.8M (22%) | -$600K |
| Units cleared | 28,000 (67%) | 34,000 (81%) | +14 pts |
| Weeks to clear | 12 weeks | 8 weeks | -4 weeks |
Implementation Plan:
| Week | Action | SKUs | Expected Impact |
|---|
| Week 1 | First markdown wave (30-40% off) | 15 SKUs | Clear 8,000 units, $480K revenue |
| Week 2 | Second markdown wave (20-30% off) | 12 SKUs | Clear 6,000 units, $340K revenue |
| Week 3 | Deepen discounts on slow movers | 8 SKUs | Clear 5,000 units, $180K revenue |
| Week 4-6 | Transfer excess to outlets | 5 SKUs | Clear 10,000 units, $250K revenue |
| Week 7-8 | Final clearance (60-70% off) | All remaining | Clear 5,000 units, $120K revenue |
Questions to Ask
If you need more context:
- What inventory needs to be marked down? (age, quantity, categories)
- What's your current markdown rate? Target?
- How much time do you have? (end of season, weeks remaining)
- What's the current sell-through rate?
- Do you have historical price elasticity data?
- What markdown control do you have? (frequency, depth, store-level)
- Do you have outlet stores for clearance?
- What are competitor markdown practices?
- Any margin constraints? (minimum acceptable margin)
Related Skills
- retail-allocation: Initial allocation to minimize future markdowns
- demand-forecasting: Forecast demand at different price points
- retail-replenishment: Replenishment strategy to avoid overstock
- seasonal-planning: Seasonal buy planning to reduce markdown risk
- promotional-planning: Promotional strategy vs. markdown strategy
- inventory-optimization: Inventory management to minimize markdowns
- supply-chain-analytics: Markdown performance metrics
