# Pricing Strategy Optimization > Use when developing pricing strategies and models. - Skill: `loopyluci/pricing-strategy-optimization` (Agent Skill) - Install (CLI): `npx skillmds@latest add loopyluci/pricing-strategy-optimization` - Raw SKILL.md: https://api.skillmd.com/api/skills/loopyluci/pricing-strategy-optimization/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - License: MIT - Author: LoopyLuci (https://skillmd.com/u/loopyluci) - Updated: 2026-09-08 - Page: https://skillmd.com/skills/loopyluci/pricing-strategy-optimization --- # Pricing Strategy and Optimization Developing and optimizing pricing strategies — from value-based pricing and tiered models through discounts, packaging, pricing experiments, and elasticity analysis. ## When to Use - Setting initial pricing for a new product - Optimizing existing pricing to increase revenue - Designing pricing tiers and packaging - Running pricing experiments and A/B tests - Analyzing price elasticity and willingness to pay ## Pricing Models ```python PRICING_MODELS = { 'cost_plus': { 'description': 'Cost + desired margin', 'best_for': 'Physical products, manufacturing, retail', 'formula': 'Price = Cost / (1 - Desired Margin)', }, 'value_based': { 'description': 'Based on perceived value to customer', 'best_for': 'B2B, SaaS, services, differentiated products', 'formula': 'Price = Value Delivered × Share of Value Captured', }, 'competitor_based': { 'description': 'Match, undercut, or premium vs competitors', 'best_for': 'Commodity products, competitive markets', 'formula': 'Price = Competitor Price ± Differentiation Premium', }, 'tiered': { 'description': 'Multiple tiers with different feature sets', 'best_for': 'SaaS, subscriptions, services', 'formula': 'Basic (low) → Pro (medium) → Enterprise (high)', }, 'penetration': { 'description': 'Low initial price to gain market share', 'best_for': 'New markets, competitive entry', 'formula': 'Low price → gain users → raise over time', }, 'skimming': { 'description': 'High initial price, lower over time', 'best_for': 'Innovation, limited competition, early adopters', 'formula': 'High price → lower as competition enters', }, 'freemium': { 'description': 'Free basic tier, paid premium', 'best_for': 'SaaS, apps, platforms with network effects', 'formula': 'Free (limited) → Paid (full)', }, 'usage_based': { 'description': 'Pay for what you use (per-unit)', 'best_for': 'APIs, cloud services, utilities', 'formula': 'Price × Units Consumed', }, } def recommend_model(product_type: str, market: str, differentiation: str) -> str: if product_type == 'physical': return 'cost_plus' elif market == 'new' and differentiation == 'high': return 'skimming' elif market == 'competitive' and differentiation == 'low': return 'competitor_based' elif product_type in ('saas', 'digital'): return 'tiered' return 'value_based' ``` ## Tier Design ```python class TierDesigner: """Design SaaS/software pricing tiers.""" def __init__(self, base_name: str, base_price: float): self.base = base_name self.price = base_price self.tiers = [] def add_tier(self, name: str, price: float, features: List[str], limits: Dict = None) -> 'TierDesigner': self.tiers.append({ 'name': name, 'price': price, 'price_display': f"${price:.0f}/mo" if price < 1000 else f"${price:.0f}/yr", 'features': features, 'limits': limits or {}, }) return self def validate_tiers(self) -> List[str]: """Check tier design best practices.""" issues = [] prices = [t['price'] for t in self.tiers] # 3 tiers is optimal (Goldilocks effect) if len(self.tiers) < 2: issues.append("Add at least one more tier (3-tier is optimal)") elif len(self.tiers) > 4: issues.append("Too many tiers — consider consolidating") # Price multiples if len(prices) >= 2: ratios = [prices[i+1]/prices[i] for i in range(len(prices)-1)] for i, ratio in enumerate(ratios): if ratio < 1.5: issues.append(f"Price gap between {self.tiers[i]['name']} and {self.tiers[i+1]['name']} is small (<1.5x)") elif ratio > 4: issues.append(f"Large price gap ({ratio:.1f}x) between {self.tiers[i]['name']} and {self.tiers[i+1]['name']}") if not issues: issues.append("Tier structure follows best practices") return issues def generate_pricing_page(self) -> str: page = f"\n💰 {self.base} — Pricing\n" + "=" * 40 + "\n" for t in self.tiers: page += f"\n**{t['name']}** — {t['price_display']}\n" for f in t['features']: page += f" ✅ {f}\n" if t['limits']: for k, v in t['limits'].items(): page += f" 📊 {k}: {v}\n" page += "\n" + "-" * 30 + "\n" return page ``` ## Pricing Experiment ```python class PricingExperiment: """Design and analyze pricing experiments.""" @staticmethod def van_westendorp(survey_responses: List[Dict]) -> Dict: """Van Westendorp Price Sensitivity Meter. Asks: At what price is this product... - Too expensive (would not consider) - Expensive (but would consider) - Cheap (a bargain) - Too cheap (quality concerns) """ too_cheap = [r['too_cheap'] for r in survey_responses if r.get('too_cheap')] cheap = [r['cheap'] for r in survey_responses if r.get('cheap')] expensive = [r['expensive'] for r in survey_responses if r.get('expensive')] too_expensive = [r['too_expensive'] for r in survey_responses if r.get('too_expensive')] def median(vals): return sorted(vals)[len(vals)//2] if vals else 0 return { 'point_of_marginal_cheapness': median(cheap), 'point_of_marginal_expensiveness': median(expensive), 'optimal_price_point': median(cheap + expensive) // 2, 'indifference_price_point': median(cheap + expensive) // 2, } @staticmethod def conjoint_analysis(feature_levels: List[Dict], responses: List[Dict]) -> Dict: """Simple conjoint analysis to determine feature willingness-to-pay.""" utilities = {} for level in feature_levels: name = level['name'] avg_utility = 0 count = 0 for r in responses: if name in r.get('chosen', {}): avg_utility += r['chosen'].get('price', 0) count += 1 utilities[name] = round(avg_utility / max(count, 1), 2) return utilities ``` ## Discounting Strategy ```python DISCOUNTING_GUIDELINES = { 'annual_subscription': { 'recommended_discount': '15-20%', 'rationale': 'Reduces churn, improves cash flow, increases LTV', 'impact_on_metrics': 'Lower MRR but higher ARR, lower churn', }, 'enterprise_deal': { 'recommended_discount': '10-30% (volume-based)', 'rationale': 'Larger deals justify discount; protect list price', 'impact_on_metrics': 'Higher ACV but lower ARPU', }, 'first_time_buyer': { 'recommended_discount': '15-25%', 'rationale': 'Reduces barrier to trial; can expire after first period', 'impact_on_metrics': 'Higher conversion rate, may attract price-sensitive customers', }, 'win_back': { 'recommended_discount': '25-50%', 'rationale': 'Lapsed customers need more incentive to return', 'impact_on_metrics': 'Recovers some churned MRR', }, 'bundling': { 'recommended_discount': '10-25% off bundle vs individual', 'rationale': 'Increases perceived value, reduces comparison shopping', 'impact_on_metrics': 'Higher AOV, lower churn', }, } def recommend_discount(scenario: str, deal_size: float = None) -> Dict: guide = DISCOUNTING_GUIDELINES.get(scenario, {}) return guide ``` ## Common Pitfalls 1. **Cost-plus ignores value** — customers don't care about your costs; price to value 2. **Too many tiers** — analysis paralysis; 3-4 tiers max 3. **Not testing pricing** — pricing is the most impactful lever; A/B test it 4. **Discounting without discipline** — discounts train customers to wait for sales; use sparingly 5. **Anchoring too low** — you can always discount but rarely raise prices; start higher 6. **Ignoring psychology** — $99 feels significantly cheaper than $100; use charm pricing ## Verification Checklist - [ ] Pricing model selected (value-based, cost-plus, competitor, etc.) - [ ] Willingness-to-pay research conducted - [ ] Tier structure follows best practices (3 tiers, clear differentiation) - [ ] Price anchoring strategy defined - [ ] Discount policy documented (who, when, how much) - [ ] Annual/monthly pricing with appropriate discount - [ ] Pricing page clearly communicates value per tier - [ ] A/B testing plan for pricing changes ## See Also - product-management-roadmap — pricing for product tiers - saas-metrics-reporting — measuring pricing impact on revenue - competitive-intelligence-analysis — market pricing benchmarks - ecommerce-platform-management — ecommerce pricing strategies