Design pricing tiers, value metrics, and packaging — willingness-to-pay research, Van Westendorp analysis, and monetization strategy for SaaS and software.
Design profitable pricing tiers and packages that capture the true value of your SaaS product. You will get a clear pricing structure and a communication plan that boosts revenue without losing customers. Reach for this advisor when building a pricing model from scratch, redesigning existing plans, or preparing to implement a price increase.
name: “pricing-strategy”
description: “Design, optimize, and communicate SaaS pricing — tier structure, value metrics, pricing pages, and price increase strategy. Use when building a pricing model from scratch, redesigning existing pricing, planning a price increase, or improving a pricing page. Trigger keywords: pricing tiers, pricing page, price increase, packaging, value metric, per seat pricing, usage-based pricing, freemium, good-better-best, pricing strategy, monetization, pricing page conversion, Van Westendorp. NOT for broader product strategy — use product-strategist for that. NOT for customer success or renewals — use customer-success-manager for expansion revenue.”
license: MIT
metadata:
version: 1.0.0
author: Alireza Rezvani
category: marketing
updated: 2026-03-06
Pricing Strategy
You are an expert in SaaS pricing and monetization. Your goal is to design pricing that captures the value you deliver, converts at a healthy rate, and scales with your customers.
Pricing is not math — it’s positioning. The right price isn’t the one that covers costs + margin. It’s the one that sits between what your next-best alternative costs and what your customers believe they get in return. Most SaaS products are underpriced. This skill is about fixing that, clearly and defensibly.
Before Starting
Check for context first:
If marketing-context.md exists, read it before asking questions. Use that context and only ask for what’s missing.
Gather this context:
1. Current State
Do you have pricing today? If so: what plans, what price points, what’s the billing model?
What’s your conversion rate from trial/free to paid? (If known)
What’s your average revenue per customer?
What’s your monthly churn rate?
2. Business Context
Product type: B2B or B2C? Self-serve or sales-assisted?
Customer segments: who are your best customers vs. casual users?
Competitors: who do customers compare you to, and what do those cost?
Cost structure: what does serving one customer cost you per month?
3. Goals
Are you designing, optimizing, or planning a price increase?
Any constraints? (e.g., grandfathered customers, contractual limits, channel partner margins)
How This Skill Works
Mode 1: Design Pricing From Scratch
Starting without a pricing model, or rebuilding entirely. We’ll work through value metric selection, tier structure, price point research, and pricing page design.
Mode 2: Optimize Existing Pricing
Pricing exists but conversion is low, expansion is flat, or customers feel mispriced. We’ll audit what’s there, benchmark, and identify specific improvements.
Mode 3: Plan a Price Increase
Prices need to go up — because of inflation, value improvements, or market repositioning. We’ll design a strategy that increases revenue without burning customers.
The Three Pricing Axes
Every pricing decision lives across three axes. Get all three right.
┌─────────────────┐ │ PACKAGING │ What's in each tier? │ (what you get) │ └────────┬────────┘ │ ┌────────┴────────┐ │ VALUE METRIC │ What do you charge for? │ (how it scales) │ └────────┬────────┘ │ ┌────────┴────────┐ │ PRICE POINT │ How much? │ (the number) │ └─────────────────┘
Most teams skip straight to price point. That’s backwards. Lock in the metric first, then packaging, then test the number.
Value Metric Selection
Your value metric determines how pricing scales with customer value. Choose wrong and you either leave money on the table or create friction that kills growth.
Common Value Metrics for SaaS
Metric
Best For
Example
Per seat / user
Collaboration tools, CRMs
Salesforce, Notion, Linear
Per usage
API tools, infrastructure, AI
Stripe, Twilio, OpenAI
Per feature
Platform plays, add-ons
Intercom, HubSpot
Flat fee
Unlimited-feel, SMB tools
Basecamp, Calendly Basic
Per outcome
High-value, measurable ROI
Commission-based tools
Hybrid
Mix of above
Most mature SaaS
How to Choose
Answer these questions:
What makes a customer willing to pay more? → That’s your value metric
Does the metric scale with their success? → If they grow, you grow
Is it easy to understand? → Complexity kills conversion
Is it hard to game? → Customers shouldn’t be able to work around it
Red flags:
“Per seat” in a tool where one power user does all the work → seats don’t scale with value
“Flat fee” when some customers derive 10x the value of others → you’re subsidizing heavy users
“Per API call” when call count varies wildly week to week → unpredictable bills = churn
Good-Better-Best Tier Structure
Three tiers is the standard. Not because of tradition — because it anchors perception.
Tier Design Principles
Entry tier (Good):
Captures the segment that will churn if priced higher
Limited — either by features, usage, or support
NOT free. Free is a separate strategy (freemium), not a tier.
Price between the next-best alternative and your perceived value.
[Cost of doing nothing] ... [Next-best alternative] ... [YOUR PRICE] ... [Perceived value delivered]
Step 1: Define the next-best alternative
What would the customer do if your product didn’t exist?
A competitor? A spreadsheet? Manual process? Hiring someone?
What does that cost them?
Step 2: Estimate value delivered
Time saved × hourly rate of the person using it
Revenue generated or protected
Cost of error/risk avoided
Ask your best customers: “What would you lose if you stopped using us tomorrow?”
Step 3: Price in the middle
A rough heuristic: price at 10-20% of documented value delivered
Don’t price at 50% of value — customers feel they’re overpaying
Don’t price below the next-best alternative — signals you don’t believe in your own product
Conversion rate as a signal:
40% trial-to-paid: likely underpriced — test a price increase
15-30%: healthy for most SaaS
<10%: pricing may be high, or trial-to-paid funnel has friction
Pricing Research Methods
Van Westendorp Price Sensitivity Meter
Four questions, asked to current customers or target segment:
At what price would this product be so cheap you’d question its quality?
At what price would this product be a bargain — great deal?
At what price would this product start to feel expensive — still acceptable?
At what price would this product be too expensive to consider?
Interpret the results: Plot the four curves. The intersection of “too cheap” and “too expensive” gives your acceptable price range. The intersection of “bargain” and “expensive” gives the optimal price point.
When to use: B2B SaaS, n≥30 respondents, existing customers or qualified prospects.
MaxDiff Analysis
Show respondents sets of features/prices and ask which they value most and least. Statistical analysis reveals relative value of each feature — informs packaging more than price point.
When to use: When deciding which features to put in which tier.
Competitor Benchmarking
Step
What to Do
1
List direct competitors and alternatives customers consider
2
Record their published pricing (plan names, prices, value metrics)
3
Note what’s included at each price point
4
Identify where your product over- and under-delivers vs. each
5
Price relative to positioning: premium = 20-40% above market, value = at or below
Don’t just copy competitor prices — their pricing reflects their cost structure and positioning, not yours.
Price Increase Strategies
Raising prices is one of the highest-ROI moves available to SaaS companies. Most wait too long.
Strategy Selection
Strategy
Use When
Risk
New customers only
Significant pushback expected
Low — doesn’t touch existing base
Grandfather + delayed
Loyal customer base, contract risk
Medium — existing customers feel respected
Tied to value delivery
Clear new features/improvement
Low — justifiable
Plan restructure
Significant packaging change
Medium — complexity for customers
Uniform increase
Confident in value, price is clearly below market
Medium-High
Execution Checklist
Quantify the move: Calculate new MRR at 100%, 80%, 70% retention of existing customers
Segment by risk: Annual contracts, champions vs. detractors, usage-based at-risk accounts
Set the date: 60-90 days notice for existing customers. 30 days minimum.
Communicate the reason: New features, rising costs, investment in [X] — be specific
Offer a path: Lock in current price for annual commitment, or give a 3-month window
Arm your CS team: FAQ, talking points, approved offer authority
Monitor for 60 days: Churn rate, downgrade rate, support ticket volume
Expected churn from a 20-30% price increase: 5-15%. If your net revenue impact is positive, proceed.
Pricing Page Design
The pricing page converts intent to purchase. Design it with that job in mind.
Above the Fold
Must have:
Plan names (simple: Starter / Pro / Enterprise, or named after customer segment)
Price with billing toggle (monthly/annual — annual should show savings)
3-5 bullet differentiators per plan
CTA button per plan
“Most popular” badge on recommended tier
Below the Fold
Full feature comparison table — comprehensive, scannable, uses ✅ and ❌ not walls of text
FAQ section — address the 5 objections that stop people from buying:
“Can I cancel anytime?”
“What happens when I hit limits?”
“Do you offer refunds?”
“Is my data secure?”
“What if I need to upgrade/downgrade?”
Social proof — logos, quotes, or case studies relevant to each tier
Security badges if B2B enterprise (SOC2, ISO 27001, GDPR)
Annual vs. Monthly Toggle
Show annual pricing by default (or highlight it) — it improves LTV
Show savings explicitly: “Save 20%” or “2 months free”
Don’t hide the monthly price — hiding it builds distrust
product-strategist: Use for product roadmap and broader monetization strategy. NOT for pricing page or price increase execution.
copywriting: Use for pricing page copy polish. NOT for pricing structure or tier design.
churn-prevention: Use when churn is the underlying issue — fix retention before raising prices.
ab-test-setup: Use to A/B test price points or pricing page layouts after initial design.
customer-success-manager: Use for expansion revenue through upselling. NOT for pricing design or packaging.
competitor-alternatives: Use for competitive comparison pages that complement pricing pages.
Pricing Models — Deep Dive
Comprehensive reference for SaaS pricing models with real-world examples and when to use each.
Model 1: Per-Seat / Per-User
How it works: Price is multiplied by the number of users who access the product.
Best for:
Collaboration tools where more users = more value
CRMs where every sales rep needs access
Tools where the organization is the buyer and seats map to headcount
Examples: Salesforce ($25-300/seat/mo), Linear ($8/seat/mo), Figma ($12/seat/mo), Notion ($8/seat/mo)
Expansion mechanics: Automatic as companies hire. No upsell conversation needed — new hire gets a seat, revenue grows.
Failure modes:
Single-power-user tools (one person does all the work, team just views results) → seat pricing punishes the customer for your product's design
Tools used by contractors or external stakeholders → billing becomes a negotiation
Products where sharing credentials is easy and enforcement is hard
Seat pricing variants:
Variant
Description
Example
Named seat
Specific user assigned to each license
Salesforce
Concurrent seat
N users can be logged in simultaneously
Legacy enterprise software
Creator/viewer split
Creators pay, viewers free or low-cost
Figma, Miro
Minimum seat count
Plan requires minimum X seats
Most enterprise deals
Tip: Creator/viewer pricing is powerful for B2B tools where one team creates and dozens consume. It drives virality (free viewers) while capturing revenue from actual users.
Model 2: Usage-Based (Consumption)
How it works: Customer pays for what they use — API calls, storage, compute, messages sent, emails delivered.
Best for:
Infrastructure and developer tools
AI/ML tools where compute cost scales with usage
Communication platforms (email, SMS, video)
Products where usage is highly variable across customers
Expansion mechanics: Natural — as customer grows, their usage grows, revenue grows without any action. Best CAC:LTV dynamics in SaaS.
Failure modes:
Unpredictable bills → customers cap usage to avoid overages → you've engineered your own ceiling
High churn during market downturns → when usage drops, revenue drops
Hard to forecast for both you and the customer
Usage pricing variants:
Variant
Description
Example
Pure consumption
Pay only for what you use
AWS Lambda
Prepaid credits
Buy credits, consume at your pace
OpenAI, Resend
Committed use + overage
Flat fee with usage ceiling, then per-unit
Stripe, Twilio volume
Tiered usage
Lower per-unit price at higher volumes
Mailchimp email tiers
Hybrid approach: Most mature usage-based companies add a platform fee (small flat monthly charge) to ensure revenue floor and reduce churn from low-usage months.
Model 3: Feature-Based (Tiered Flat Fee)
How it works: Different bundles of features at different flat price points. The Good-Better-Best model.
Best for:
Products with clear feature differentiation between customer segments
Markets where predictable spend matters (CFOs love this)
SMB-to-enterprise products where enterprise features are genuinely different
Examples: HubSpot (Starter/Professional/Enterprise), Intercom (Starter/Pro/Premium), most SaaS
Expansion mechanics: Requires upsell motion — customer has to outgrow a tier and move up. Less automatic than usage-based but more predictable.
Failure modes:
Feature tiers that don't match actual customer needs → customers cluster in one tier, none move
Enterprise features that aren't compelling enough to justify the jump → stuck mid-market
Too many tiers → analysis paralysis
Model 4: Flat Fee
How it works: One price, everything included, unlimited use.
Expansion mechanics: None. You need a premium tier or add-ons, or you're relying purely on new customer acquisition.
Failure modes:
Heavy users subsidized by light users → heavy users stay forever, light users churn → adverse selection
No path to grow revenue with existing customers → stuck unless you add tiers or raise prices
When flat fee works: When your cost to serve is genuinely flat, or when market positioning around simplicity is worth more than the revenue you'd capture with usage-based pricing.
Model 5: Freemium
Note: Freemium is an acquisition strategy, not a pricing model. It's compatible with any of the above.
How it works: Free tier with limited functionality, paid tiers above.
Best for:
Developer tools (PLG)
Collaboration tools that spread virally
Products where network effects increase value with more users
Examples: Slack, Notion, Figma, GitHub, Airtable
The freemium math:
Free users cost money to serve
You need paid conversion rate high enough to cover free users
Rule of thumb: 2-5% free-to-paid conversion is viable at scale, 1-2% usually isn't
Free vs. trial vs. freemium:
Model
Description
Best For
Free forever tier
Permanently limited free plan
PLG, viral loops
Time-limited trial
Full access for 14-30 days
Sales-assisted, complex products
Usage-limited trial
Full access until limit hit
Developer tools, AI
Freemium
Permanently limited, upsell to paid
Bottoms-up enterprise
Model 6: Hybrid Pricing
Most mature SaaS companies end up with hybrid pricing. Common combinations:
Combination
Example
Platform fee + per seat
Base access + user licenses
Platform fee + usage
Monthly minimum + overage
Feature tiers + usage
Plan determines included usage, overage above
Per seat + usage
Seat license + volume pricing for heavy users
When to go hybrid:
You have both fixed infrastructure costs and variable serving costs
You want revenue floors (platform fee) + upside (usage)
Different customer segments have very different value profiles
Pricing Model Selection Framework
Answer these questions to identify the right model:
1. Does value scale with users?
Yes, linearly → per-seat
Yes, but not linearly → creator/viewer or per-seat with role tiers
2. Does value scale with usage?
Yes, measurably → usage-based
Yes, but usage is hard to measure → feature tiers with usage caps
3. Is your customer a small business wanting simplicity?
Yes → flat fee or simple 2-3 tier feature pricing
No → skip flat fee, go feature or usage-based
4. Do you have enterprise customers with governance/compliance needs?
Yes → enterprise tier required (even if "Contact us")
No → three tiers max
5. Is this a developer/technical product?
Yes → usage-based or consumption with free tier is the market norm
No → feature tiers with flat fee is more accessible
Pricing Model Benchmarks
Metric
Early Stage
Growth
Scale
Trial-to-paid rate
15-25%
20-35%
25-40%
Annual vs monthly mix
30-50% annual
40-60% annual
50-70% annual
Expansion revenue
0-10% of MRR
10-20%
20-40%
Price increase frequency
Ad hoc
Annually
Annually
Churn rate (monthly)
2-8%
1-4%
0.5-2%
The LTV:CAC rule: LTV should be ≥3x CAC. If it's below 3x, pricing or retention (or both) needs fixing.
Pricing Page Playbook
Design specs, copy frameworks, and conversion tactics for SaaS pricing pages.
What a Pricing Page Actually Has to Do
One job: get the right customer to click the right plan's CTA. Everything on the page should serve that job or get removed.
The visitor landing on your pricing page has already decided they're interested. They're now asking:
"Which plan is for me?"
"Is it worth the price?"
"What's the catch?"
Your page answers those three questions, in that order.
Page Structure (Scroll Order)
Above the Fold
Billing toggle (monthly/annual)
Default to annual if annual is your preference (most conversions happen here)
Show savings clearly: "Save 20%" badge, not just the math
Position toggle at the top, before plan cards
Plan cards (3-column)
┌─────────────┬─────────────┬─────────────┐│ Starter │ Pro │ Enterprise ││ │ ★ Popular │ ││ $29/mo │ $99/mo │ Custom ││ │ │ ││ For small │ For growing │ For teams ││ teams │ teams │ needing ││ │ │ control ││ • Feature │ • Feature │ • Feature ││ • Feature │ • Feature │ • Feature ││ • Feature │ • Feature │ • Feature ││ │ │ ││ [Start free]│[Start free] │[Contact us] │└─────────────┴─────────────┴─────────────┘
Each plan card must include:
Plan name (customer-segment-oriented, not just "Basic/Pro")
Price (with billing period and per-seat notation if applicable)
1-line positioning sentence ("For growing teams who need X")
4-6 bullet differentiators (what they get at this tier)
CTA button (clear, action-oriented — not just "Sign Up")
"Most popular" / "Recommended" badge on middle tier
Below the Fold
Full Feature Comparison Table
Exhaustive list of all features
Group by category: Core, Collaboration, Analytics, Admin, Support
Use ✅ / ❌ or checkmarks/dashes — no conditional language
Sticky header so plan names stay visible while scrolling
Make this scannable, not a wall of text
Social Proof Section
3 customer quotes relevant to each tier if possible
Company logos of recognizable customers
Stats if they're real: "Trusted by 10,000+ teams"
FAQ Section (5-7 questions)
Non-negotiable FAQs:
"Can I cancel anytime?" → Yes. Cancel from settings. No calls required.
"What happens at the end of my trial?" → We'll ask if you want to continue.
"Can I switch plans?" → Yes, upgrade or downgrade anytime. Prorated billing.
"What payment methods do you accept?" → Credit card, invoice for annual enterprise.
"Is my data secure?" → SOC 2 Type II / ISO 27001 / brief security statement.
"What if I need more than the top plan offers?" → Talk to us: [link to enterprise form].
Enterprise Call-to-Action
Separate row or section below cards
"Need custom pricing or a demo?" → [Talk to Sales] button
Who it's for: teams over X seats, specific compliance needs, custom contracts
Copy Frameworks
Plan Names
Avoid generic names if possible. Named plans anchor to identity, not just price.
Generic
Better
Why
Free / Basic / Pro
Solo / Studio / Agency
Maps to customer segment
Starter / Growth / Enterprise
Developer / Team / Business
Maps to use case
Individual / Team / Organization
Creator / Collaborator / Company
Maps to role
If your categories are genuinely vague, stick with simple names. Don't force creative names that confuse.
CTA Copy
Match the CTA to the ask:
Context
CTA
Has a free trial
"Start free trial"
Freemium
"Get started free"
No trial, direct purchase
"Get [Plan Name]"
Enterprise / contact sales
"Talk to us" or "Get a demo"
Annual commitment, high price
"Schedule a call"
Avoid:
"Sign Up" — generic, no value
"Subscribe" — sounds like a newsletter
"Buy Now" — transactional, not benefit-oriented
"Learn More" — on a pricing page, this is a dead end
Pricing Display
Scenario
How to Show It
Monthly pricing
"$99/month"
Annual pricing, billed monthly
"$83/month, billed annually"
Annual pricing, billed upfront
"$996/year" with "/mo equivalent" note
Per-seat
"$15/user/month"
Usage-based
"From $0.002 per call"
Enterprise
"Custom" or "Starting at $X"
Always show annual savings as a percentage OR dollar amount (whichever is larger visually).
Conversion Tactics
Anchoring
Price anchoring: The first number shown sets the reference frame. If you show a $500/month plan first, $99 feels cheap.
If you want to push the middle tier:
Show plans left-to-right: Premium → Pro (recommended) → Starter
OR highlight the middle tier with visual treatment (larger card, border, color)
The eye goes to the visually differentiated option
The "Recommended" Badge
Don't just label the middle tier. Make it visually obvious:
Darker background or brand color
Slightly taller card
"Most Popular" or "Recommended for Most Teams" label
First CTA in the tab order
Annual Toggle Default
Research consistently shows defaulting to annual pricing increases annual plan take rate. Show the toggle, but default to annual.
If you want more monthly customers (for cash flow testing, or lower commitment products), default to monthly.
Pricing Page SEO Consideration
Pricing pages often rank for "[Company] pricing" queries. This matters because:
Competitors may be running ads on your brand pricing keywords
The page needs to load fast and be well-structured
Include your pricing in structured data (JSON-LD Schema: PriceSpecification)
Pricing Page Audit Checklist
Score each item 0-2 (0 = missing, 1 = exists but weak, 2 = done well):
Above the Fold
Billing toggle visible
Annual savings shown clearly
Three plan cards with clear differentiation
"Most popular" / recommended tier highlighted
CTA per plan
Content
Full feature comparison table
FAQ section (5+ questions)
Social proof / logos
Enterprise CTA
Copy
Plan names are meaningful (not just Basic/Pro)
Price is unambiguous (per user? per month? billed how?)
CTAs are action-oriented
Positioning line per plan
Trust
Security badges (if B2B)
Money-back guarantee or cancellation policy visible
"Cancel anytime" stated explicitly
Score interpretation:
22-24: Strong page. Test specific elements.
16-21: Good foundation. Fix weak sections.
<16: Material gaps. Rebuild using this playbook.
Pricing Page A/B Test Ideas
High impact, easier to test:
Default billing toggle (annual vs. monthly)
"Most popular" badge placement
CTA copy (Start free trial vs. Get Pro)
Price display ($/mo vs. $/year)
Medium impact, more setup:
5. Plan name messaging (segment-based vs. feature-based)
6. Number of features shown in above-fold cards (3 vs. 6)
7. Social proof placement (above vs. below fold)
8. FAQ accordion vs. expanded
High impact, harder to execute:
9. Actual price points (statistical significance takes longer)
10. Three tiers vs. two tiers
11. Adding vs. removing free tier
Minimum traffic for pricing tests: 500+ visitors per variant per week. Below that, results won't be statistically meaningful.
#!/usr/bin/env python3"""Pricing modeler — projects revenue at different price points and recommends tier structure."""import jsonimport sysimport mathSAMPLE_INPUT = { "current_mrr": 45000, "current_customers": 300, "monthly_new_customers": 25, "monthly_churn_rate_pct": 3.5, "trial_to_paid_rate_pct": 18, "current_plans": [ {"name": "Starter", "price": 29, "customer_count": 180}, {"name": "Pro", "price": 79, "customer_count": 100}, {"name": "Enterprise", "price": 199, "customer_count": 20} ], "competitor_prices": [49, 89, 249], "cogs_per_customer_monthly": 8, "target_gross_margin_pct": 75}def calculate_arpu(plans): total_rev = sum(p["price"] * p["customer_count"] for p in plans) total_cust = sum(p["customer_count"] for p in plans) return total_rev / total_cust if total_cust > 0 else 0def project_revenue_at_price(base_customers, base_arpu, new_arpu, new_customers_monthly, churn_rate, months=12): """Project MRR over N months at a new ARPU, assuming some churn from price change.""" price_increase_pct = (new_arpu - base_arpu) / base_arpu if base_arpu > 0 else 0 # Estimate churn uplift from price increase # Empirical: each 10% price increase causes ~2-4% additional one-time churn if price_increase_pct > 0: price_churn_hit = price_increase_pct * 0.25 # 25% of increase leaks as churn else: price_churn_hit = 0 monthly_churn = churn_rate / 100 mrr_series = [] customers = base_customers * (1 - price_churn_hit) # initial price churn hit mrr = customers * new_arpu for month in range(1, months + 1): mrr_series.append(round(mrr, 0)) customers = customers * (1 - monthly_churn) + new_customers_monthly mrr = customers * new_arpu return { "month_1_mrr": mrr_series[0], "month_6_mrr": mrr_series[5], "month_12_mrr": mrr_series[11], "total_12mo_revenue": sum(mrr_series), "customers_after_price_churn": round(base_customers * (1 - price_churn_hit), 0) }def recommend_tier_structure(plans, competitor_prices, cogs, target_margin_pct): """Recommend Good-Better-Best tier structure based on current state and competitors.""" current_arpu = calculate_arpu(plans) comp_avg = sum(competitor_prices) / len(competitor_prices) if competitor_prices else current_arpu comp_min = min(competitor_prices) if competitor_prices else current_arpu * 0.7 comp_max = max(competitor_prices) if competitor_prices else current_arpu * 1.5 # Minimum price based on cost structure min_viable_price = cogs / (1 - target_margin_pct / 100) # Recommended tier anchors entry_price = max(min_viable_price, comp_min * 0.9) mid_price = entry_price * 2.5 premium_price = mid_price * 2.5 # Round to psychologically clean prices def clean_price(p): if p < 30: return round(p / 5) * 5 - 1 # e.g., 19, 29 elif p < 100: return round(p / 10) * 10 - 1 # e.g., 49, 79, 99 elif p < 500: return round(p / 25) * 25 - 1 # e.g., 149, 199, 299 else: return round(p / 100) * 100 - 1 # e.g., 499, 999 return { "entry": { "name": "Starter", "recommended_price": clean_price(entry_price), "positioning": "For individuals and small teams getting started" }, "mid": { "name": "Professional", "recommended_price": clean_price(mid_price), "positioning": "For growing teams that need the full feature set — recommended for most" }, "premium": { "name": "Enterprise", "recommended_price": clean_price(premium_price), "positioning": "For larger organizations needing security, compliance, and dedicated support" }, "rationale": { "current_arpu": round(current_arpu, 2), "competitor_range": f"${comp_min}-${comp_max}", "min_viable_price": round(min_viable_price, 2), "pricing_vs_market": "at-market" if abs(current_arpu - comp_avg) / comp_avg < 0.15 else "below-market" if current_arpu < comp_avg else "above-market" } }def elasticity_estimate(trial_to_paid_pct, current_arpu): """Rough price elasticity signal based on conversion rate.""" if trial_to_paid_pct > 40: signal = "strong-underpricing" note = "Conversion >40% — strong signal of underpricing. Test 20-30% increase." headroom = 0.30 elif trial_to_paid_pct > 25: signal = "possible-underpricing" note = "Conversion 25-40% — healthy, but may have room for modest price increase." headroom = 0.15 elif trial_to_paid_pct > 15: signal = "market-priced" note = "Conversion 15-25% — likely market-priced. Focus on tier structure and packaging." headroom = 0.05 elif trial_to_paid_pct > 8: signal = "possible-overpricing" note = "Conversion 8-15% — possible price friction. Audit trial experience before reducing price." headroom = -0.05 else: signal = "high-friction" note = "Conversion <8% — significant friction. May be pricing, trial experience, or ICP fit." headroom = -0.15 return { "signal": signal, "note": note, "estimated_price_headroom_pct": round(headroom * 100, 0), "suggested_test_price": round(current_arpu * (1 + headroom), 2) }def print_report(result, inputs): cur = result["current_state"] elast = result["elasticity"] tiers = result["tier_recommendation"] scenarios = result["price_scenarios"] print("\n" + "="*65) print(" PRICING MODELER") print("="*65) print(f"\n📊 CURRENT STATE") print(f" MRR: ${cur['current_mrr']:,.0f}") print(f" Customers: {cur['customers']}") print(f" ARPU: ${cur['arpu']:.2f}/mo") print(f" Trial-to-paid rate: {inputs['trial_to_paid_rate_pct']}%") print(f" Monthly churn rate: {inputs['monthly_churn_rate_pct']}%") print(f" Gross margin (est.): {cur['gross_margin_pct']:.1f}%") print(f"\n💡 PRICE ELASTICITY SIGNAL") print(f" Signal: {elast['signal'].replace('-', ' ').upper()}") print(f" Note: {elast['note']}") print(f" Headroom: {'+' if elast['estimated_price_headroom_pct'] >= 0 else ''}" f"{elast['estimated_price_headroom_pct']:.0f}%") print(f" Test at: ${elast['suggested_test_price']:.2f}/mo ARPU") print(f"\n📐 RECOMMENDED TIER STRUCTURE") tier_rat = tiers['rationale'] print(f" Market position: {tier_rat['pricing_vs_market'].replace('-', ' ').title()}") print(f" Competitor range: {tier_rat['competitor_range']}") print(f" Min viable price: ${tier_rat['min_viable_price']:.2f}/mo") print(f"\n ┌─────────────────┬────────────┬────────────────────────────────────┐") print(f" │ Tier │ Price │ Positioning │") print(f" ├─────────────────┼────────────┼────────────────────────────────────┤") for key in ["entry", "mid", "premium"]: t = tiers[key] name = t["name"].ljust(15) price = f"${t['recommended_price']}/mo".ljust(10) pos = t["positioning"][:34].ljust(34) print(f" │ {name} │ {price} │ {pos} │") print(f" └─────────────────┴────────────┴────────────────────────────────────┘") print(f"\n📈 REVENUE SCENARIOS (12-month projection)") print(f" {'Scenario':<25} {'Mo 1 MRR':>10} {'Mo 6 MRR':>10} {'Mo 12 MRR':>10} {'12mo Total':>12}") print(f" {'-'*67}") for s in scenarios: print(f" {s['scenario']:<25} " f"${s['month_1_mrr']:>9,.0f} " f"${s['month_6_mrr']:>9,.0f} " f"${s['month_12_mrr']:>9,.0f} " f"${s['total_12mo_revenue']:>11,.0f}") print(f"\n🎯 RECOMMENDATION") best = max(scenarios, key=lambda s: s['total_12mo_revenue']) current = next((s for s in scenarios if s['scenario'] == 'Current pricing'), scenarios[0]) uplift = best['total_12mo_revenue'] - current['total_12mo_revenue'] print(f" Best scenario: {best['scenario']}") print(f" 12-month uplift: ${uplift:,.0f} vs. current") print(f" Note: Projections assume trial volume and churn hold constant.") print(f" Test price increases on new customers first.") print("\n" + "="*65 + "\n")def main(): import argparse parser = argparse.ArgumentParser( description="Pricing modeler — projects revenue at different price points and recommends tier structure." ) parser.add_argument( "input_file", nargs="?", default=None, help="JSON file with pricing data (default: run with sample data)" ) parser.add_argument( "--json", action="store_true", help="Output results as JSON" ) args = parser.parse_args() if args.input_file: with open(args.input_file) as f: inputs = json.load(f) else: if not args.json: print("No input file provided. Running with sample data...\n") inputs = SAMPLE_INPUT current_arpu = calculate_arpu(inputs["current_plans"]) total_customers = inputs["current_customers"] cogs = inputs["cogs_per_customer_monthly"] target_margin = inputs["target_gross_margin_pct"] gross_margin = ((current_arpu - cogs) / current_arpu * 100) if current_arpu > 0 else 0 tier_rec = recommend_tier_structure( inputs["current_plans"], inputs.get("competitor_prices", []), cogs, target_margin ) elast = elasticity_estimate(inputs["trial_to_paid_rate_pct"], current_arpu) # Model multiple scenarios churn = inputs["monthly_churn_rate_pct"] new_mo = inputs["monthly_new_customers"] scenarios = [] for label, arpu in [ ("Current pricing", current_arpu), ("5% price increase", current_arpu * 1.05), ("15% price increase", current_arpu * 1.15), ("25% price increase", current_arpu * 1.25), ("Recommended tiers", tier_rec["mid"]["recommended_price"]) ]: proj = project_revenue_at_price(total_customers, current_arpu, arpu, new_mo, churn) scenarios.append({"scenario": label, "arpu": round(arpu, 2), **proj}) result = { "current_state": { "current_mrr": inputs["current_mrr"], "customers": total_customers, "arpu": round(current_arpu, 2), "gross_margin_pct": round(gross_margin, 1) }, "elasticity": elast, "tier_recommendation": tier_rec, "price_scenarios": scenarios } print_report(result, inputs) if args.json: print(json.dumps(result, indent=2))if __name__ == "__main__": main()
Install this Skill
Skills give your AI agent a consistent, structured approach to this task — better output than a one-off prompt.