slotting-fees-optimization

スロッティングフィーの最適化

あなたは、小売店のスロッティングフィー、トレード支出の最適化、カテゴリーマネジメントの経済性に精通しています。スロッティングフィーへの投資を最適化し、小売店とのより良い条件を交渉し、棚スペースへの投資収益を最大化することが目標です。

初期評価

スロッティングフィーを最適化する前に、以下を把握してください。

1. ビジネスの背景

   • どの製品・カテゴリーを導入または維持しますか？
   • どの小売店やチャネルですか？（食料品店、量販店、会員制倉庫型店舗、コンビニエンスストア）
   • 現在のスロッティングフィー支出はいくらですか？（金額および売上に占める割合）
   • 新製品の発売計画はありますか？
   • 市場での位置付けは？（リーダー、挑戦者、ニッチ）

2. 小売店との関係

   • 既存の関係や取引履歴はありますか？
   • 小売店ごとの販売量はどの程度ですか？
   • カテゴリーキャプテンの地位にありますか？
   • 現在の棚スペースとフェイシング数は？
   • パフォーマンス指標（販売速度、棚のリニアフィート当たり利益）は？

3. 製品のパフォーマンス

   • 予想される販売速度は？
   • 利益率の構造は？
   • 販促計画は？
   • 既存製品のカニバリゼーションはありますか？
   • 競合製品と差別化要因は？

4. 財務上の制約

   • 新製品発売の予算はいくらですか？
   • スロッティングフィーの予算上限は？
   • ROI の要件は？
   • 投資回収期間の想定は？

---

スロッティングフィーの枠組み

スロッティングフィーについて

スロッティングフィーとは？

• 棚スペースの対価として小売店に支払う一時金
• 小売店に対し、以下の費用を補償します。
  • 機会費用（既存製品を棚から外すこと）
  • 失敗のリスク（新製品の多くは失敗する）
  • 管理費用（セットアップ、システム、人件費）
  • 倉庫スペースの割り当て

一般的なスロッティングフィーの範囲（SKU・店舗あたり）：

チャネル	低額	平均	高額
食料品店	$500	$1,500	$5,000
量販店	$1,000	$3,000	$10,000
会員制倉庫型店舗	$5,000	$15,000	$50,000
コンビニエンスストア	$100	$500	$2,000
ドラッグストア	$1,000	$2,500	$7,500
自然食品・オーガニック	$500	$2,000	$5,000

スロッティングフィーに影響する要因：

• 小売店の規模と交渉力
• 製品カテゴリー（常温保存品、冷蔵品、冷凍品）
• ブランド力（確立済みか無名か）
• 棚スペースの空き状況
• 予想販売速度
• 要求するフェイシング数
• 地理的範囲（全国か地域限定か）

---

スロッティングフィーの経済性

ROI 計算モデル

import pandas as pd
import numpy as np

class SlottingFeeAnalyzer:
    """
    Analyze slotting fee economics and ROI
    """

    def __init__(self, product_data, retailer_data):
        """
        Initialize analyzer

        Parameters:
        - product_data: dict with product financials
        - retailer_data: dict with retailer scope and fees
        """
        self.product = product_data
        self.retailer = retailer_data

    def calculate_roi(self, time_horizon_months=12):
        """
        Calculate ROI on slotting fee investment

        Returns:
        - comprehensive financial analysis
        """

        # Slotting fee investment
        slotting_fee_per_store = self.retailer['slotting_fee_per_store']
        num_stores = self.retailer['num_stores']
        total_slotting = slotting_fee_per_store * num_stores

        # Sales forecast
        weekly_sales_per_store = self.product['expected_weekly_units_per_store']
        weeks_in_period = (time_horizon_months / 12) * 52
        total_units = weekly_sales_per_store * num_stores * weeks_in_period

        # Revenue
        retail_price = self.product['retail_price']
        wholesale_price = retail_price * (1 - self.retailer['retail_margin'])
        total_revenue = total_units * wholesale_price

        # Costs
        cogs_per_unit = self.product['cogs']
        total_cogs = total_units * cogs_per_unit

        # Gross profit
        gross_profit = total_revenue - total_cogs

        # Other trade spend
        promotional_rate = self.product.get('promotional_rate_pct', 0.20)
        promotional_spend = total_revenue * promotional_rate

        # Marketing support
        marketing_spend = self.product.get('marketing_spend', 0)

        # Net profit
        total_trade_investment = total_slotting + promotional_spend + marketing_spend
        net_profit = gross_profit - total_trade_investment

        # ROI metrics
        roi = net_profit / total_trade_investment if total_trade_investment > 0 else 0
        payback_months = (total_slotting / (net_profit / time_horizon_months)
                         if net_profit > 0 else float('inf'))

        # Profit per store
        profit_per_store = net_profit / num_stores

        # Sales per linear foot (assuming 1 facing = 4 inches)
        facings = self.product.get('facings', 1)
        linear_feet = (facings * 4) / 12
        annual_sales_per_lf = (total_revenue / time_horizon_months * 12) / (num_stores * linear_feet)

        return {
            'investment': {
                'slotting_fee': total_slotting,
                'slotting_per_store': slotting_fee_per_store,
                'promotional_spend': promotional_spend,
                'marketing_spend': marketing_spend,
                'total_investment': total_trade_investment
            },
            'sales': {
                'total_units': total_units,
                'total_revenue': total_revenue,
                'units_per_store_per_week': weekly_sales_per_store
            },
            'profitability': {
                'gross_profit': gross_profit,
                'net_profit': net_profit,
                'profit_per_store': profit_per_store,
                'gross_margin_pct': (gross_profit / total_revenue * 100) if total_revenue > 0 else 0
            },
            'roi_metrics': {
                'roi': roi,
                'roi_pct': roi * 100,
                'payback_months': payback_months,
                'sales_per_linear_foot': annual_sales_per_lf
            },
            'recommendation': self._generate_recommendation(roi, payback_months)
        }

    def _generate_recommendation(self, roi, payback_months):
        """Generate go/no-go recommendation"""

        if roi > 0.50 and payback_months < 12:
            return {
                'decision': 'STRONG GO',
                'rationale': 'High ROI and fast payback'
            }
        elif roi > 0.25 and payback_months < 18:
            return {
                'decision': 'GO',
                'rationale': 'Positive ROI with acceptable payback'
            }
        elif roi > 0:
            return {
                'decision': 'MARGINAL',
                'rationale': 'Positive but weak ROI - negotiate better terms'
            }
        else:
            return {
                'decision': 'NO GO',
                'rationale': 'Negative ROI - do not proceed'
            }

    def sensitivity_analysis(self, variable, values):
        """
        Run sensitivity analysis on key variables

        Parameters:
        - variable: which variable to vary ('sales', 'slotting_fee', etc.)
        - values: range of values to test

        Returns:
        - sensitivity results
        """

        base_case = self.calculate_roi()
        results = []

        for value in values:
            # Modify parameter
            if variable == 'weekly_sales_per_store':
                self.product['expected_weekly_units_per_store'] = value
            elif variable == 'slotting_fee_per_store':
                self.retailer['slotting_fee_per_store'] = value
            elif variable == 'retail_price':
                self.product['retail_price'] = value

            # Recalculate
            scenario = self.calculate_roi()

            results.append({
                variable: value,
                'roi_pct': scenario['roi_metrics']['roi_pct'],
                'payback_months': scenario['roi_metrics']['payback_months'],
                'net_profit': scenario['profitability']['net_profit']
            })

        return pd.DataFrame(results)


# Example usage
product = {
    'sku': 'NEW_PRODUCT_A',
    'retail_price': 4.99,
    'cogs': 2.00,
    'expected_weekly_units_per_store': 5,
    'facings': 2,
    'promotional_rate_pct': 0.20,
    'marketing_spend': 50000
}

retailer = {
    'name': 'Major Grocery Chain',
    'num_stores': 500,
    'slotting_fee_per_store': 1500,
    'retail_margin': 0.25
}

analyzer = SlottingFeeAnalyzer(product, retailer)
analysis = analyzer.calculate_roi(time_horizon_months=12)

print(f"Total Investment: ${analysis['investment']['total_investment']:,.0f}")
print(f"Net Profit (Year 1): ${analysis['profitability']['net_profit']:,.0f}")
print(f"ROI: {analysis['roi_metrics']['roi_pct']:.0f}%")
print(f"Payback: {analysis['roi_metrics']['payback_months']:.1f} months")
print(f"Recommendation: {analysis['recommendation']['decision']}")

---

交渉戦略

スロッティングフィー交渉の枠組み

class SlottingNegotiator:
    """
    Framework for negotiating slotting fees
    """

    def __init__(self, manufacturer_profile, product_profile):
        self.manufacturer = manufacturer_profile
        self.product = product_profile

    def assess_negotiating_power(self):
        """
        Assess negotiating power with retailer

        Factors that strengthen position:
        - Established brand with consumer pull
        - Category leadership
        - High expected velocity
        - Innovation/differentiation
        - Strong marketing support
        - Category captain status
        """

        power_score = 0

        # Brand strength (0-25 points)
        brand_strength = self.manufacturer.get('brand_awareness_pct', 0)
        power_score += (brand_strength / 4)

        # Market share in category (0-25 points)
        market_share = self.manufacturer.get('category_market_share_pct', 0)
        power_score += (market_share * 2.5)

        # Innovation (0-20 points)
        if self.product.get('first_to_market', False):
            power_score += 20
        elif self.product.get('highly_differentiated', False):
            power_score += 15
        elif self.product.get('line_extension', False):
            power_score += 5

        # Expected velocity (0-15 points)
        expected_velocity = self.product.get('expected_velocity_rank', 'medium')
        velocity_points = {'high': 15, 'medium': 10, 'low': 5}
        power_score += velocity_points.get(expected_velocity, 5)

        # Marketing support (0-15 points)
        marketing_budget = self.product.get('marketing_budget', 0)
        if marketing_budget > 500000:
            power_score += 15
        elif marketing_budget > 100000:
            power_score += 10
        else:
            power_score += 5

        # Classify negotiating position
        if power_score >= 75:
            position = 'STRONG'
        elif power_score >= 50:
            position = 'MODERATE'
        else:
            position = 'WEAK'

        return {
            'power_score': power_score,
            'position': position,
            'factors': self._identify_strengths_weaknesses(power_score)
        }

    def _identify_strengths_weaknesses(self, score):
        """Identify negotiating strengths and weaknesses"""

        strengths = []
        weaknesses = []

        if self.manufacturer.get('brand_awareness_pct', 0) > 60:
            strengths.append('Strong brand awareness')
        else:
            weaknesses.append('Low brand awareness')

        if self.manufacturer.get('category_market_share_pct', 0) > 15:
            strengths.append('Category leader')
        else:
            weaknesses.append('Small market share')

        if self.product.get('first_to_market', False):
            strengths.append('First-to-market innovation')

        return {'strengths': strengths, 'weaknesses': weaknesses}

    def generate_negotiation_tactics(self):
        """Generate negotiation tactics based on position"""

        power = self.assess_negotiating_power()
        position = power['position']

        tactics = []

        if position == 'STRONG':
            tactics = [
                'Refuse slotting fees entirely (consumer pull)',
                'Offer performance-based fees (pay only if targets met)',
                'Demand prime shelf location',
                'Request multi-year shelf space guarantee',
                'Negotiate category captain role',
                'Offer exclusive innovation window'
            ]

        elif position == 'MODERATE':
            tactics = [
                'Negotiate reduced slotting fee',
                'Offer performance guarantees (sales velocity)',
                'Bundle multiple SKUs for lower per-SKU fee',
                'Propose trial period with reduced fee',
                'Offer incremental promotional support',
                'Share consumer research data'
            ]

        else:  # WEAK
            tactics = [
                'Pay standard slotting fee',
                'Offer higher promotional support',
                'Accept secondary shelf location',
                'Start with limited distribution (test stores)',
                'Propose consignment terms',
                'Offer free fills or extended payment terms'
            ]

        return {
            'position': position,
            'tactics': tactics,
            'priority': self._prioritize_tactics(tactics)
        }

    def _prioritize_tactics(self, tactics):
        """Prioritize tactics to focus negotiation"""
        return tactics[:3]  # Top 3 tactics


# Example
manufacturer = {
    'brand_awareness_pct': 75,
    'category_market_share_pct': 22,
    'category_captain': True
}

product = {
    'first_to_market': True,
    'highly_differentiated': True,
    'expected_velocity_rank': 'high',
    'marketing_budget': 1000000
}

negotiator = SlottingNegotiator(manufacturer, product)
power = negotiator.assess_negotiating_power()
tactics = negotiator.generate_negotiation_tactics()

print(f"Negotiating Position: {power['position']} (Score: {power['power_score']:.0f})")
print("\nStrengths:")
for s in power['factors']['strengths']:
    print(f"  - {s}")

print("\nRecommended Tactics:")
for t in tactics['priority']:
    print(f"  - {t}")

---

スロッティングフィーに代わる方法

パフォーマンスベースの契約

def design_performance_based_agreement(product, retailer, targets):
    """
    Design performance-based slotting agreement

    Instead of upfront slotting fee, tie payments to performance

    Parameters:
    - product: product information
    - retailer: retailer information
    - targets: performance targets

    Returns:
    - performance-based terms
    """

    # Traditional slotting fee
    traditional_fee = retailer['traditional_slotting_fee']

    # Performance tiers
    agreement = {
        'structure': 'performance_based',
        'upfront_fee': traditional_fee * 0.25,  # 25% upfront
        'performance_tiers': []
    }

    # Tier 1: Meet baseline target
    baseline_sales = targets['baseline_units_year1']
    tier1_payment = traditional_fee * 0.25

    agreement['performance_tiers'].append({
        'tier': 1,
        'target': f"{baseline_sales:,} units in Year 1",
        'payment': tier1_payment,
        'trigger': 'Meet baseline sales'
    })

    # Tier 2: Exceed baseline by 25%
    tier2_target = baseline_sales * 1.25
    tier2_payment = traditional_fee * 0.25

    agreement['performance_tiers'].append({
        'tier': 2,
        'target': f"{tier2_target:,} units in Year 1",
        'payment': tier2_payment,
        'trigger': 'Exceed baseline by 25%'
    })

    # Tier 3: Exceed baseline by 50%
    tier3_target = baseline_sales * 1.50
    tier3_payment = traditional_fee * 0.25

    agreement['performance_tiers'].append({
        'tier': 3,
        'target': f"{tier3_target:,} units in Year 1",
        'payment': tier3_payment,
        'trigger': 'Exceed baseline by 50%'
    })

    # Total potential payment
    agreement['max_total_payment'] = (
        agreement['upfront_fee'] +
        sum(tier['payment'] for tier in agreement['performance_tiers'])
    )

    # Benefits
    agreement['benefits'] = {
        'manufacturer': 'Reduced upfront risk, pay only for performance',
        'retailer': 'Potential for higher total fees, shared success'
    }

    return agreement


# Example
performance_agreement = design_performance_based_agreement(
    product={'sku': 'NEW_PRODUCT'},
    retailer={'traditional_slotting_fee': 750000},
    targets={'baseline_units_year1': 100000}
)

print("Performance-Based Agreement:")
print(f"Upfront: ${performance_agreement['upfront_fee']:,.0f}")
for tier in performance_agreement['performance_tiers']:
    print(f"Tier {tier['tier']}: {tier['target']} → ${tier['payment']:,.0f}")
print(f"Max Total: ${performance_agreement['max_total_payment']:,.0f}")

---

ポートフォリオの最適化

製品全体のスロッティング投資を最適化する

from pulp import *

def optimize_slotting_portfolio(products, total_budget, constraints):
    """
    Optimize slotting fee allocation across product portfolio

    Parameters:
    - products: list of products with slotting costs and expected returns
    - total_budget: total slotting fee budget
    - constraints: business constraints

    Returns:
    - optimal allocation
    """

    # Create problem
    prob = LpProblem("Slotting_Portfolio", LpMaximize)

    # Decision variables: invest in product i or not
    invest = LpVariable.dicts("Invest",
                               [p['sku'] for p in products],
                               cat='Binary')

    # Objective: Maximize total NPV
    prob += lpSum([
        invest[p['sku']] * p['expected_npv']
        for p in products
    ])

    # Constraints

    # 1. Budget constraint
    prob += lpSum([
        invest[p['sku']] * p['total_slotting_cost']
        for p in products
    ]) <= total_budget

    # 2. Minimum new products per year
    min_new_products = constraints.get('min_new_products', 0)
    prob += lpSum([invest[p['sku']] for p in products]) >= min_new_products

    # 3. Category requirements (at least X products per category)
    categories = set(p['category'] for p in products)
    for category in categories:
        min_per_category = constraints.get(f'min_{category}', 0)
        prob += lpSum([
            invest[p['sku']]
            for p in products
            if p['category'] == category
        ]) >= min_per_category

    # 4. Strategic must-haves
    must_invest = constraints.get('must_invest', [])
    for sku in must_invest:
        if sku in [p['sku'] for p in products]:
            prob += invest[sku] == 1

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract results
    selected_products = []
    total_cost = 0
    total_npv = 0

    for p in products:
        if invest[p['sku']].varValue > 0.5:
            selected_products.append({
                'sku': p['sku'],
                'category': p['category'],
                'slotting_cost': p['total_slotting_cost'],
                'expected_npv': p['expected_npv'],
                'roi': p['expected_npv'] / p['total_slotting_cost']
            })
            total_cost += p['total_slotting_cost']
            total_npv += p['expected_npv']

    results = {
        'status': LpStatus[prob.status],
        'selected_products': pd.DataFrame(selected_products),
        'num_products': len(selected_products),
        'total_slotting_cost': total_cost,
        'total_expected_npv': total_npv,
        'portfolio_roi': total_npv / total_cost if total_cost > 0 else 0
    }

    return results


# Example
products = [
    {'sku': 'Product_A', 'category': 'snacks', 'total_slotting_cost': 500000,
     'expected_npv': 750000},
    {'sku': 'Product_B', 'category': 'snacks', 'total_slotting_cost': 400000,
     'expected_npv': 300000},
    {'sku': 'Product_C', 'category': 'beverages', 'total_slotting_cost': 600000,
     'expected_npv': 900000},
    {'sku': 'Product_D', 'category': 'beverages', 'total_slotting_cost': 350000,
     'expected_npv': 200000},
    {'sku': 'Product_E', 'category': 'snacks', 'total_slotting_cost': 450000,
     'expected_npv': 600000}
]

result = optimize_slotting_portfolio(
    products=products,
    total_budget=1500000,
    constraints={
        'min_new_products': 3,
        'must_invest': ['Product_C']  # Strategic priority
    }
)

print(f"Selected {result['num_products']} products")
print(f"Total Investment: ${result['total_slotting_cost']:,.0f}")
print(f"Expected NPV: ${result['total_expected_npv']:,.0f}")
print(f"Portfolio ROI: {result['portfolio_roi']:.1%}")
print("\nSelected Products:")
print(result['selected_products'][['sku', 'slotting_cost', 'expected_npv', 'roi']])

---

モニタリングとパフォーマンス追跡

発売後のパフォーマンス追跡

class SlottingPerformanceTracker:
    """
    Track actual performance vs. business case
    """

    def __init__(self, business_case):
        self.business_case = business_case
        self.actual_performance = []

    def record_performance(self, period_data):
        """Record actual sales performance for a period"""
        self.actual_performance.append(period_data)

    def compare_to_business_case(self):
        """Compare actual to business case projections"""

        if not self.actual_performance:
            return None

        df = pd.DataFrame(self.actual_performance)

        # Cumulative actuals
        cumulative_units = df['units_sold'].sum()
        cumulative_revenue = df['revenue'].sum()

        # Business case projections (annualized)
        bc_units = self.business_case['projected_annual_units']
        bc_revenue = self.business_case['projected_annual_revenue']

        # Months of data
        months_tracked = len(df)

        # Annualized actuals
        annualized_units = cumulative_units * (12 / months_tracked)
        annualized_revenue = cumulative_revenue * (12 / months_tracked)

        # Variance
        units_variance = annualized_units - bc_units
        revenue_variance = annualized_revenue - bc_revenue

        # ROI recalculation
        actual_gross_profit = cumulative_revenue * self.business_case['gross_margin']
        slotting_investment = self.business_case['slotting_fee']
        annualized_gross_profit = actual_gross_profit * (12 / months_tracked)

        actual_roi = (annualized_gross_profit - slotting_investment) / slotting_investment

        comparison = {
            'months_tracked': months_tracked,
            'business_case': {
                'projected_units': bc_units,
                'projected_revenue': bc_revenue,
                'projected_roi': self.business_case['projected_roi']
            },
            'actual_annualized': {
                'units': annualized_units,
                'revenue': annualized_revenue,
                'roi': actual_roi
            },
            'variance': {
                'units': units_variance,
                'units_pct': units_variance / bc_units * 100,
                'revenue': revenue_variance,
                'revenue_pct': revenue_variance / bc_revenue * 100
            },
            'performance_vs_plan': self._classify_performance(
                units_variance / bc_units * 100
            )
        }

        return comparison

    def _classify_performance(self, variance_pct):
        """Classify performance vs. plan"""

        if variance_pct > 10:
            return 'EXCEEDING'
        elif variance_pct > -10:
            return 'ON_TRACK'
        else:
            return 'UNDERPERFORMING'


# Example
business_case = {
    'projected_annual_units': 500000,
    'projected_annual_revenue': 2500000,
    'projected_roi': 0.45,
    'slotting_fee': 750000,
    'gross_margin': 0.35
}

tracker = SlottingPerformanceTracker(business_case)

# Record actual performance
tracker.record_performance({'month': 1, 'units_sold': 35000, 'revenue': 175000})
tracker.record_performance({'month': 2, 'units_sold': 40000, 'revenue': 200000})
tracker.record_performance({'month': 3, 'units_sold': 45000, 'revenue': 225000})

comparison = tracker.compare_to_business_case()

print(f"Performance: {comparison['performance_vs_plan']}")
print(f"Projected Annual Units: {comparison['business_case']['projected_units']:,}")
print(f"Actual Annualized Units: {comparison['actual_annualized']['units']:,.0f}")
print(f"Variance: {comparison['variance']['units_pct']:+.1f}%")

---

ツールとテクノロジー

スロッティングおよびトレード管理ソフトウェア

トレードプロモーション管理（TPM/TPO）：

• SAP TPM：トレードプロモーションとスロッティングの管理
• Oracle TPM：控除およびトレード支出の管理
• Blacksmith Applications：CPG 向け TPM/TPO
• AFS Trade Promotion：分析と最適化
• Wipro Promax：クラウド TPM プラットフォーム

小売分析：

• Nielsen：小売測定と棚分析
• IRI：シンジケートデータとスペースプランニング
• 84.51° (Kroger)：小売店のデータとインサイト
• Catalina：パーソナライズされた小売メディア
• dunnhumby：小売科学と分析

Python ライブラリ

# Financial modeling
import pandas as pd
import numpy as np
from scipy.optimize import minimize

# Optimization
from pulp import *

# Data analysis
import pandas as pd
import numpy as np

# Visualization
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

---

よくある課題と解決策

課題：高額なスロッティングフィーが新製品の発売を妨げる

問題：

• 小売店がスロッティングフィーとして $2M を要求
• 予算は $1M のみ
• この小売店なしでは発売できない

解決策：

• パフォーマンスベースの条件を交渉する（前払い額を減らす）
• 店舗数を絞って開始する（テスト店舗）
• 複数の SKU をまとめて、SKU あたりの料金を引き下げる
• スロッティングの代わりに、より手厚い販促支援を提供する
• 料金の低い別の小売店を探す
• 資金に余裕ができるまで発売を延期する

課題：過去の発売で投資収益率が低い

問題：

• 直近3製品の実績が予測を下回った
• 棚割り投資で損失が発生した
• 経営陣からの信頼が損なわれた

解決策：

• 発売後の分析（製品が失敗した理由を分析）
• 販売予測の改善（保守的な予測）
• 製品テストの強化（調査の拡充、テスト市場の活用）
• 発売基準の厳格化（ROI の基準を引き上げる）
• 小売業者と販売実績保証を交渉する
• より少数の優れた製品に注力する

課題：小売業者からの手数料要求が増加

問題：

• 手数料が前年比で20％増加
• 利益率が圧迫されている
• 収益性が脅かされている

解決策：

• 複数年契約を交渉する（料率を固定する）
• 高い販売速度を示す（データに基づく交渉）
• カテゴリーキャプテンの地位を目指す（一部の手数料をなくす）
• オンライン／直販へ構成を移行する（小売業者を介さない）
• SKU を統合する（手数料負担を軽減する）
• 消費者需要を構築する（プッシュ型ではなくプル型）

---

出力形式

棚割り手数料のビジネスケーステンプレート

製品情報：

• 製品：新しいオーガニックグラノーラバー
• カテゴリー：スナック - バー
• SKU：3種類のフレーバー
• 小売価格：$4.99
• COGS：$2.10
• 粗利益率：58%

小売業者情報：

• 小売業者：全国展開の食料品チェーン
• 店舗数：1,200
• 棚割り手数料：SKU あたり、店舗あたり$1,800
• 棚割り投資総額：$6,480,000

販売予測（1年目）：

指標	1店舗あたりの週次	年間合計
販売数量	8	499,200
売上高（卸売）	$30	$18,637,000
粗利益	$17.40	$10,809,000

コスト構成：

項目	金額	売上比率
棚割り手数料	$6,480,000	34.8%
販促支援	$1,863,700	10.0%
マーケティング	$500,000	2.7%
投資総額	$8,843,700	47.5%

財務指標：

指標	値
1年目の純利益	$1,965,300
ROI	22.2%
投資回収期間	10.8か月
棚の1リニアフィートあたりの売上	$17,320

推奨：実施

• ROI がプラスで、投資回収期間が12か月未満
• 棚の1リニアフィートあたりの売上が高く、スペースを確保する価値がある
• 販売速度を高める強力な販促計画
• リスク軽減策：600店舗から開始する（テスト段階）

リスクと軽減策：

1. リスク：販売速度が予想を下回る

   • 軽減策：実績連動型契約（25％を前払いし、目標達成時に6か月後に残額を支払う）

2. リスク：既存製品のカニバリゼーションが大きい

   • 軽減策：テスト市場分析では、カニバリゼーションは15％未満

3. リスク：小売業者が2年目に棚を維持するための手数料を要求する

   • 軽減策：事前に2年契約を交渉する

---

確認事項

さらに詳しい情報が必要な場合：

1. どの製品を新たに導入、または維持する予定ですか？
2. 対象の小売業者と店舗数を教えてください。
3. 棚割り手数料はいくら提示されていますか？
4. 販売予測（1店舗あたりの週次販売数量）はどのくらいですか？
5. 製品の利益率の構成はどのようになっていますか？
6. これらの小売業者と既存の取引関係がありますか？
7. 新カテゴリーへの参入ですか、それともライン拡張ですか？
8. 交渉力（ブランド力、イノベーションなど）はどの程度ありますか？

---

関連スキル

• promotional-planning：トレードプロモーションの最適化
• retail-replenishment：小売業者の在庫管理
• demand-forecasting：販売予測
• markdown-optimization：価格戦略
• procurement-optimization：交渉のフレームワーク
• supplier-selection：小売業者の選定基準
• strategic-sourcing：小売業者との長期的なパートナーシップ
• spend-analysis：トレード支出の追跡と最適化