cpg-network-design

name

cpg-network-design

description

When the user wants to design CPG (Consumer Packaged Goods) distribution networks, optimize DC locations for retail distribution, or plan omnichannel fulfillment networks. Also use when the user mentions "CPG network," "retail distribution network," "DC strategy," "forward deployment centers," "store replenishment network," or "omnichannel distribution." For general network design, see network-design. For promotional supply chain, see promotional-planning.

CPG Network Design

You are an expert in CPG (Consumer Packaged Goods) distribution network design and retail supply chain optimization. Your goal is to help design cost-effective distribution networks that balance inventory investment, transportation costs, and service levels to retail customers.

Initial Assessment

Before designing CPG networks, understand:

1. Business Context

   • What product categories? (food, beverage, personal care, household)
   • What channels? (grocery, mass, club, convenience, DSD, e-commerce)
   • What's the geographic scope? (regional, national, international)
   • Current network? (# DCs, flow patterns, costs)
   • Growth plans or channel expansion?

2. Customer Requirements

   • Retailer order lead times? (2-7 days typical)
   • Order frequency? (daily, weekly)
   • Case fill rates? (>98% expected)
   • Delivery windows and appointment scheduling?
   • Drop ship vs. warehouse delivery?

3. Product Characteristics

   • SKU complexity? (100s to 10,000+ SKUs)
   • Velocity distribution? (A/B/C analysis)
   • Shelf life? (days, months, years)
   • Storage requirements? (ambient, refrigerated, frozen)
   • Cube density and weight?

4. Economic Drivers

   • Current transportation spend?
   • Current DC operating costs?
   • Inventory carrying costs?
   • Service level performance and fill rates?
   • Target cost reduction or service improvement?

---

CPG Network Design Framework

CPG-Specific Network Characteristics

vs. General Industrial:

• High SKU complexity (1,000-10,000+ SKUs typical)
• Fast-moving products (high velocity)
• Short lead times (2-5 days)
• High service level requirements (>98%)
• Promotional variability (30-50% lift)
• Multi-channel distribution (retail, DSD, e-commerce)
• Thin margins (2-5% operating margin)

Network Echelon Options:

1. Direct-to-Store (Plant → Store)

• Fresh/DSD products (bread, milk, snacks)
• High frequency, small drops
• Driver merchandising
• See dsd-route-optimization

2. Single-Tier (Plant → DC → Store)

• Most common for shelf-stable
• Regional DCs (3-6 typically)
• Full product line at each DC
• Economic order quantities

3. Two-Tier (Plant → RDC → Forward DC → Store)

• National brand with broad coverage
• RDCs for slow movers (1-2 large)
• Forward DCs for fast movers (10-15 smaller)
• Inventory optimization across tiers

4. Hybrid (Multiple Strategies)

• Fast movers: Forward DCs
• Slow movers: Direct ship from RDC
• Promotional: Special builds
• E-commerce: Dedicated fulfillment centers

---

Network Design Models

CPG Facility Location Model

from pulp import *
import pandas as pd
import numpy as np
from scipy.spatial.distance import cdist

class CPGNetworkOptimizer:
    """
    CPG-specific network design optimization
    """

    def __init__(self, customers_df, potential_dcs_df, plants_df):
        """
        Initialize CPG network optimizer

        Parameters:
        - customers_df: retailers with demand ['customer_id', 'lat', 'lon',
                       'demand_cases', 'service_level_days']
        - potential_dcs_df: potential DC locations ['dc_id', 'lat', 'lon',
                           'fixed_cost', 'variable_cost_per_case', 'capacity']
        - plants_df: manufacturing plants ['plant_id', 'lat', 'lon', 'capacity']
        """
        self.customers = customers_df
        self.dcs = potential_dcs_df
        self.plants = plants_df

        # Calculate distance matrices
        self.dc_to_customer_dist = self._calc_distances(
            self.dcs[['lat', 'lon']],
            self.customers[['lat', 'lon']]
        )

        self.plant_to_dc_dist = self._calc_distances(
            self.plants[['lat', 'lon']],
            self.dcs[['lat', 'lon']]
        )

    def _calc_distances(self, from_coords, to_coords):
        
        distances = cdist(from_coords.values, to_coords.values, metric=)
         distances *   

     ():
        

        prob = LpProblem(, LpMinimize)

        
        C = ((.customers))
        D = ((.dcs))
        P = ((.plants))

        
        y = LpVariable.dicts(, D, cat=)

        
        x = LpVariable.dicts(,
                              [(c,d)  c  C  d  D],
                              lowBound=)

        
        z = LpVariable.dicts(,
                              [(p,d)  p  P  d  D],
                              lowBound=)

        
        objective = 

        
         d  D:
            objective += .dcs.iloc[d][] * y[d]

        
         c  C:
             d  D:
                handling_cost = .dcs.iloc[d][]
                objective += x[c,d] * handling_cost

        
         c  C:
             d  D:
                distance = .dc_to_customer_dist[d,c]
                demand = .customers.iloc[c][]

                
                 demand < :  
                    cost = distance * transport_rate_ltl /  * demand *  /   
                :
                    cost = distance * transport_rate_tl

                objective += x[c,d] * cost / demand  

        
         p  P:
             d  D:
                distance = .plant_to_dc_dist[p,d]
                
                cost_per_mile = transport_rate_tl
                objective += z[p,d] * distance * cost_per_mile /   

        prob += objective

        

        
         c  C:
            prob += lpSum([x[c,d]  d  D]) >= .customers.iloc[c][]

        
         d  D:
            prob += lpSum([x[c,d]  c  C]) <= \
                    .dcs.iloc[d][] * y[d]

        
         d  D:
            inbound = lpSum([z[p,d]  p  P])
            outbound = lpSum([x[c,d]  c  C])
            prob += inbound >= outbound

        
         p  P:
            prob += lpSum([z[p,d]  d  D]) <= .plants.iloc[p][]

        
         service_distance:
             c  C:
                 d  D:
                     .dc_to_customer_dist[d,c] > service_distance:
                        prob += x[c,d] == 

        
         max_dcs:
            prob += lpSum([y[d]  d  D]) <= max_dcs

        
        prob.solve(PULP_CBC_CMD(msg=))

         ._extract_solution(prob, x, y, z, C, D, P)

     ():
        

         prob.status != :
             {: }

        
        open_dcs = [
            {
                : .dcs.iloc[d][],
                : ,
                : .dcs.iloc[d][],
                : .dcs.iloc[d][]
            }
             d  D  y[d].varValue > 
        ]

        
        assignments = []
         c  C:
             d  D:
                 x[c,d].varValue > :
                    assignments.append({
                        : .customers.iloc[c][],
                        : .dcs.iloc[d][],
                        : x[c,d].varValue,
                        : .dc_to_customer_dist[d,c]
                    })

        
        total_flow = (a[]  a  assignments)
        weighted_distance = (a[] * a[]  a  assignments)
        avg_distance = weighted_distance / total_flow  total_flow >   

         {
            : ,
            : value(prob.objective),
            : (open_dcs),
            : open_dcs,
            : pd.DataFrame(assignments),
            : avg_distance,
            : total_flow
        }



customers = pd.DataFrame({
    : [, , , ],
    : [, , , ],
    : [-, -, -, -],
    : [, , , ],
    : [, , , ]
})

potential_dcs = pd.DataFrame({
    : [, , , ],
    : [, , , ],
    : [-, -, -, -],
    : [, , , ],
    : [, , , ],
    : [, , , ]
})

plants = pd.DataFrame({
    : [, ],
    : [, ],
    : [-, -],
    : [, ]
})

optimizer = CPGNetworkOptimizer(customers, potential_dcs, plants)
result = optimizer.optimize_network(max_dcs=, service_distance=)

()
()
()
()

---

Service Level Modeling

Days-to-Market Analysis

def calculate_days_to_market(dc_locations, customer_locations,
                              production_lead_time=3, dc_processing_days=1):
    """
    Calculate end-to-end days from production to customer delivery

    Parameters:
    - dc_locations: DC coordinates
    - customer_locations: customer coordinates
    - production_lead_time: days to produce
    - dc_processing_days: days for DC receiving/putaway

    Returns:
    - service time analysis
    """

    from scipy.spatial.distance import cdist

    # Calculate distances
    distances = cdist(
        dc_locations[['lat', 'lon']].values,
        customer_locations[['lat', 'lon']].values,
        metric='euclidean'
    ) * 69  # miles

    # Transportation time (miles → days)
    # Assume: <250 miles = 1 day, 250-500 = 2 days, 500-750 = 3 days, etc.
    transport_days = np.ceil(distances / 250)

    # Total days to market
    total_days = production_lead_time + dc_processing_days + transport_days

    # Service level metrics
    service_metrics = {
        '1_day_service_pct': np.mean(transport_days <= 1) * 100,
        '2_day_service_pct': np.mean(transport_days <= 2) * 100,
        '3_day_service_pct': np.mean(transport_days <= 3) * 100,
        'avg_transport_days': np.mean(transport_days),
        'avg_total_days': np.mean(total_days),
        'max_days_to_market': np.max(total_days)
    }

    return service_metrics


# Benchmark service targets for CPG
service_targets = {
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    }
}

---

Inventory Optimization Across Network

Multi-Echelon Inventory Model

def optimize_inventory_deployment(sku_data, network_config, service_level=0.98):
    """
    Optimize safety stock across multi-echelon CPG network

    Parameters:
    - sku_data: SKU demand and variability
    - network_config: network structure (RDC, DCs, stores)
    - service_level: target service level

    Returns:
    - optimal inventory placement
    """

    from scipy.stats import norm

    z_score = norm.ppf(service_level)

    inventory_plan = []

    for sku in sku_data:
        # Demand parameters
        weekly_demand = sku['weekly_demand']
        demand_std = sku['demand_std']
        lead_time_weeks = sku['lead_time_weeks']

        # Safety stock calculation
        lead_time_demand = weekly_demand * lead_time_weeks
        lead_time_std = demand_std * np.sqrt(lead_time_weeks)

        safety_stock = z_score * lead_time_std

        # Cycle stock (replenishment quantity)
        order_frequency_weeks = sku.get('order_frequency_weeks', 2)
        cycle_stock = weekly_demand * order_frequency_weeks / 2

        # Total inventory
        total_inventory = safety_stock + cycle_stock

        inventory_plan.append({
            'sku': sku['sku_id'],
            'lead_time_demand': lead_time_demand,
            'safety_stock': safety_stock,
            'cycle_stock': cycle_stock,
            'total_inventory': total_inventory,
            'inventory_value': total_inventory * sku['unit_cost'],
            'service_level': service_level
        })

    return pd.DataFrame(inventory_plan)


# Network inventory pooling effect
def calculate_inventory_pooling_benefit(current_locations, new_locations,
                                         current_inventory):
    

    pooling_factor = np.sqrt(new_locations / current_locations)
    new_inventory = current_inventory * pooling_factor
    inventory_reduction = current_inventory - new_inventory

    savings = {
        : current_locations,
        : new_locations,
        : current_inventory,
        : new_inventory,
        : inventory_reduction,
        : inventory_reduction / current_inventory * 
    }

     savings



pooling = calculate_inventory_pooling_benefit(
    current_locations=,
    new_locations=,
    current_inventory=  
)

()
()

---

Omnichannel Network Design

Hybrid Fulfillment Network

class OmnichannelNetworkDesigner:
    """
    Design omnichannel fulfillment network for CPG

    Channels:
    - Traditional retail (store replenishment)
    - E-commerce (direct-to-consumer)
    - Click & collect (buy online, pick up in store)
    """

    def __init__(self, retail_demand, ecom_demand):
        self.retail = retail_demand
        self.ecom = ecom_demand

    def design_hybrid_network(self, strategy='integrated'):
        """
        Design network based on strategy

        Strategies:
        - 'integrated': Shared DCs for retail and e-commerce
        - 'dedicated': Separate e-commerce fulfillment centers
        - 'hybrid': Regional DCs + dedicated e-com nodes
        """

        if strategy == 'integrated':
            return self._design_integrated()
        elif strategy == 'dedicated':
            return self._design_dedicated()
        elif strategy == 'hybrid':
            return self._design_hybrid()

    def _design_integrated(self):
        """Shared network for all channels"""

        total_demand = self.retail['demand'].sum() + self.ecom['demand'].sum()

        network = {
            'strategy': 'integrated',
            'dc_type': 'multi-channel',
            : ._optimal_dc_count(total_demand),
            : {
                : ,
                : ,
                : ,
                : [, , ],
                : [, , ]
            }
        }

         network

     ():
        

        retail_dcs = ._optimal_dc_count(.retail[].())
        ecom_fcs = ._optimal_fc_count(.ecom[].())

        network = {
            : ,
            : retail_dcs,
            : ecom_fcs,
            : retail_dcs + ecom_fcs,
            : {
                : ,
                : ,
                : ,
                : [, , ],
                : [, , ]
            }
        }

         network

     ():
        

        network = {
            : ,
            : ,  
            : ,  
            : {
                : ,
                : ,
                : ,
                : ,
                : [, , ],
                : [, ]
            }
        }

         network

     ():
        
        
         (, (demand / ))

     ():
        
        
         (, (demand / ))



designer = OmnichannelNetworkDesigner(
    retail_demand=pd.DataFrame({: []}),  
    ecom_demand=pd.DataFrame({: []})      
)

integrated = designer.design_hybrid_network()
dedicated = designer.design_hybrid_network()
hybrid = designer.design_hybrid_network()

(, integrated)
(, dedicated)
(, hybrid)

---

CPG-Specific Considerations

Promotional Surge Capacity

def size_network_for_promotions(base_demand, promotional_lift=0.40,
                                  promotional_weeks_per_year=12):
    """
    Size network capacity considering promotional surge

    CPG challenge: Promotions can increase demand 30-50%
    Network must handle surge without stockouts
    """

    # Annual base demand
    annual_base = base_demand * 52

    # Promotional demand
    promo_demand_per_week = base_demand * (1 + promotional_lift)
    promo_weeks = promotional_weeks_per_year
    base_weeks = 52 - promo_weeks

    # Total annual demand
    annual_total = (base_demand * base_weeks) + (promo_demand_per_week * promo_weeks)

    # Peak week capacity needed
    peak_capacity = promo_demand_per_week

    # Design capacity (with buffer)
    design_capacity = peak_capacity * 1.15  # 15% buffer

    capacity_plan = {
        'base_weekly_demand': base_demand,
        'peak_weekly_demand': peak_capacity,
        'design_capacity': design_capacity,
        'capacity_utilization_base': base_demand / design_capacity,
        'capacity_utilization_peak': peak_capacity / design_capacity,
        'annual_demand': annual_total,
        'promotional_weeks': promo_weeks,
        'avg_utilization': annual_total / (design_capacity * 52)
    }

    return capacity_plan


# Example
promo_capacity = size_network_for_promotions(
    base_demand=100000,  # cases/week
    promotional_lift=0.40,
    promotional_weeks_per_year=12
)

print(f"Design Capacity: {promo_capacity['design_capacity']:,f} cases/week")
()
()

Slotting and Forward Deployment

def optimize_forward_deployment(skus, dc_network, forward_deployment_cost):
    """
    Optimize which SKUs to forward-deploy to more DCs

    Trade-off:
    - Forward deploy fast movers: Lower transport, higher inventory
    - Centralize slow movers: Higher transport, lower inventory
    """

    sku_strategy = []

    for sku in skus:
        velocity = sku['annual_demand']
        unit_value = sku['unit_cost']

        # Transport cost savings from forward deployment
        transport_savings = calculate_transport_savings(sku, dc_network)

        # Inventory cost increase from duplication
        inventory_increase = (dc_network['num_forward_dcs'] - 1) * \
                            sku['safety_stock'] * unit_value * 0.25  # 25% carrying cost

        # Net benefit
        net_benefit = transport_savings - inventory_increase

        # Decision
        if net_benefit > 0:
            strategy = 'forward_deploy'
            locations = dc_network['num_forward_dcs']
        else:
            strategy = 'centralize'
            locations = 1  # Keep at RDC only

        sku_strategy.append({
            'sku': sku['sku_id'],
            'strategy': strategy,
            'locations': locations,
            'transport_savings': transport_savings,
            'inventory_increase': inventory_increase,
            'net_benefit': net_benefit
        })

    return pd.DataFrame(sku_strategy)


def calculate_transport_savings(sku, dc_network):
    

    
    central_distance = dc_network[]
    forward_distance = dc_network[]

    distance_savings = central_distance - forward_distance

    
    shipments_per_year = sku[] / sku[]

    
    cost_per_mile = 
    cost_savings = shipments_per_year * distance_savings * cost_per_mile

     cost_savings

---

Performance Metrics

CPG Network KPIs

class CPGNetworkMetrics:
    """
    Track CPG network performance metrics
    """

    def __init__(self, network_data):
        self.data = network_data

    def calculate_kpis(self):
        """Calculate comprehensive network KPIs"""

        kpis = {}

        # Cost metrics
        kpis['total_network_cost'] = self._total_network_cost()
        kpis['cost_per_case'] = kpis['total_network_cost'] / self.data['total_cases']

        # Cost breakdown
        kpis['cost_breakdown'] = {
            'fixed_dc_costs': self._fixed_dc_costs(),
            'variable_dc_costs': self._variable_dc_costs(),
            'inbound_transport': self._inbound_transport_cost(),
            'outbound_transport': self._outbound_transport_cost(),
            'inventory_carrying': self._inventory_carrying_cost()
        }

        # Service metrics
        kpis['avg_distance_to_customer'] = self._avg_distance()
        kpis['2_day_service_pct'] = self._service_coverage(max_distance=500)
        kpis['3_day_service_pct'] = self._service_coverage(max_distance=750)

        # Efficiency metrics
        kpis['dc_utilization'] = ._dc_utilization()
        kpis[] = .data[] / .data[]

        
        kpis[] = ._total_inventory()
        kpis[] = ._inventory_turns()
        kpis[] =  / kpis[]

         kpis

     ():
        
         (.data[].values())

     ():
        
         (dc[]  dc  .data[])

     ():
        
         .data[] * .data[]

     ():
        
         .data.get(, )

     ():
        
         .data.get(, )

     ():
        
         ._total_inventory() * 

     ():
        
         .data[]

     ():
        
         .data[].get(max_distance, )

     ():
        
         .data[] / (dc[]  dc  .data[])

     ():
        
         .data.get(, )

     ():
        
        annual_cogs = .data.get(, )
        avg_inventory = ._total_inventory()
         annual_cogs / avg_inventory  avg_inventory >   



cpg_benchmarks = {
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    },
    : {
        : ,
        : ,
        : 
    }
}

---

Tools & Technologies

CPG Network Design Software

Commercial:

• Coupa Supply Chain Design: Network optimization for CPG
• LLamasoft (Coupa): Supply Chain Guru
• Blue Yonder Network Design: JDA heritage
• Optilogic Cosmic Frog: Cloud-based network design
• AIMMS: Network optimization platform
• Llamasoft Guru: Scenario planning

Analytics Platforms:

• Kinaxis RapidResponse: S&OP and network planning
• o9 Solutions: Digital planning platform
• Anaplan: Cloud planning with optimization
• SAP IBP: Integrated business planning

Python Libraries

# Network optimization
from pulp import *
import pyomo.environ as pyo

# Geospatial analysis
import geopandas as gpd
from shapely.geometry import Point
from scipy.spatial import distance_matrix

# Optimization solvers
from ortools.linear_solver import pywraplp
import gurobipy as gp

# Data analysis
import pandas as pd
import numpy as np

# Visualization
import plotly.express as px
import folium
import matplotlib.pyplot as plt

---

Common Challenges & Solutions

Challenge: High SKU Complexity

Problem:

• 5,000-10,000 SKUs to manage
• Slow movers create inventory burden
• Forward deployment is expensive

Solutions:

• ABC/XYZ segmentation
• Forward deploy only A items (top 20%)
• Ship B/C items from central location
• Use drop ship for very slow movers
• SKU rationalization program

Challenge: Promotional Variability

Problem:

• Base demand 100K, promo demand 150K
• Need surge capacity
• Risk of stockouts or obsolescence

Solutions:

• Size capacity for peak (with buffer)
• Forward-stock promotional inventory
• Use flexible 3PL for surge
• Demand sensing and rapid replenishment
• Negotiate capacity with retailers

Challenge: Omnichannel Complexity

Problem:

• Retail needs cases, e-com needs eaches
• Different service levels
• Inventory allocation conflicts

Solutions:

• Hybrid network (shared + dedicated)
• Ship-from-store for e-commerce
• DC slotting for both modes
• Advanced ATP (available-to-promise)
• Unified inventory visibility

Challenge: Low Margins

Problem:

• CPG margins 2-5%
• Network costs 3-5% of sales
• Every dollar counts

Solutions:

• Continuous optimization (quarterly reviews)
• Benchmark against peers
• Negotiate transportation rates annually
• Automation in DCs (labor = 50% of DC cost)
• Inventory reduction programs

---

Output Format

CPG Network Design Report

Executive Summary:

• Current Network: 8 DCs, $45M annual cost
• Recommended Network: 5 DCs, $38M annual cost
• Annual Savings: $7M (15.6%)
• Service Level: Maintained at 98%
• Implementation: 18 months

Network Configuration:

DC	Location	Type	Size (SF)	Capacity	Fixed Cost	Annual Volume
DC1	Memphis, TN	Regional	500K	120M cases	$8M	95M
DC2	LA, CA	Regional	400K	100M cases	$9M	75M
DC3	Newark, NJ	Regional	450K	110M cases	$8.5M	85M
DC4	Dallas, TX	Forward	250K	60M cases	$5M	45M
DC5	Atlanta, GA	Forward	300K	75M cases	$6M	55M

Cost Comparison:

Cost Category	Current	Proposed	Delta	% Change
Fixed DC Costs	$18M	$15M	-$3M	-17%
DC Operations	$12M	$10M	-$2M	-17%
Inbound Transport	$8M	$7M	-$1M	-13%
Outbound Transport	$7M	$6M	-$1M	-14%
Total	$45M	$38M	-$7M	-15.6%

Service Level Analysis:

Metric	Current	Proposed	Change
Avg Distance to Customer	420 mi	385 mi	-35 mi
2-Day Service	78%	85%	+7 pts
3-Day Service	94%	96%	+2 pts
Fill Rate	96.5%	98.0%	+1.5 pts

---

Questions to Ask

If you need more context:

1. What product categories and channels?
2. Current network configuration and costs?
3. What's the geographic scope?
4. How many SKUs and what's the velocity distribution?
5. What are the service level requirements?
6. Any promotional or seasonal patterns?
7. E-commerce component and growth?
8. Budget for network redesign?

---

Related Skills

• network-design: For general network optimization techniques
• facility-location-problem: For mathematical models
• inventory-optimization: For safety stock and inventory deployment
• promotional-planning: For handling promotional surge
• dsd-route-optimization: For direct store delivery
• warehouse-design: For DC layout and automation
• demand-forecasting: For demand planning
• omnichannel-fulfillment: For e-commerce integration
• freight-optimization: For transportation optimization