markdown-optimization

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:

1. 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?

2. 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?

3. 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)

4. 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:

1. Maximize revenue recovery: Get highest possible price before going to clearance
2. Accelerate sell-through: Clear inventory before it becomes obsolete
3. Minimize markdown dollars: Reduce total markdown spend
4. Preserve brand perception: Avoid excessive discounting
5. 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}

        # Calculate discount percentage
        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
        """

        # Demand increases as price decreases
        # New_Demand = Base_Demand * (1 / (1 - discount))^elasticity
        if discount_pct >= 100:
            return base_demand * 10  # Arbitrary large number

        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]

        # Get SKU-specific data at store
        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

        # Decision criteria
        local_markdown_needed = False
        reasons = []

        # Criterion 1: Excessive local inventory
        chain_avg_wos = 8  # Example chain average
        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})")

        # Criterion 2: Poor local performance
        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 optimization
• pulp, pyomo: Mathematical programming
• cvxpy: Convex optimization

Machine Learning:

• scikit-learn: Regression for price elasticity
• xgboost: Price-demand modeling
• statsmodels: Statistical analysis

Data Processing:

• pandas: Data manipulation
• numpy: 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:

1. What inventory needs to be marked down? (age, quantity, categories)
2. What's your current markdown rate? Target?
3. How much time do you have? (end of season, weeks remaining)
4. What's the current sell-through rate?
5. Do you have historical price elasticity data?
6. What markdown control do you have? (frequency, depth, store-level)
7. Do you have outlet stores for clearance?
8. What are competitor markdown practices?
9. 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