opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/usage-based-pricing/SKILL.md

@@ -0,0 +1,547 @@
+---
+name: usage-based-pricing
+description: "Design pricing models that developers understand, accept, and can predict. Trigger phrases: usage-based pricing, API pricing, metered billing, developer pricing, pricing page, cost calculator, pay as you go, pricing transparency, competitive pricing, developer billing"
+risk: unknown
+source: https://github.com/jonathimer/devmarketing-skills/tree/main/skills/usage-based-pricing
+source_repo: jonathimer/devmarketing-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/jonathimer/devmarketing-skills/blob/main/LICENSE
+---
+
+# Usage-Based Pricing
+## When to Use
+
+Use this skill when you need design pricing models that developers understand, accept, and can predict. Trigger phrases: usage-based pricing, API pricing, metered billing, developer pricing, pricing page, cost calculator, pay as you go, pricing transparency, competitive pricing, developer billing.
+
+
+Design pricing models that developers understand, accept, and can predict—without surprise bills or confusing metrics.
+
+## Overview
+
+Developers are uniquely sensitive to pricing. They'll calculate unit economics, compare alternatives, and write blog posts about surprise bills. Usage-based pricing works well for developer tools because it aligns cost with value, but it can also create anxiety about unpredictable costs.
+
+The best developer pricing is predictable, transparent, and obviously fair. Developers should be able to estimate their bill before they commit.
+
+## Before You Start
+
+Review the `/devmarketing-skills/skills/free-tier-strategy` skill to understand how free tiers connect to paid pricing. Your pricing model should feel like a natural extension of the free tier, not a completely different experience.
+
+## Usage Metrics Developers Accept
+
+### Good Metrics: Direct Value Correlation
+
+**API calls/requests**
+- Developers understand what triggers a call
+- Easy to monitor and predict
+- Scales with actual usage
+- Example: Stripe charges per transaction, Twilio per message
+
+**Compute time**
+- Clear relationship to server costs
+- Predictable for consistent workloads
+- Fair for variable workloads
+- Example: AWS Lambda per GB-second, Vercel build minutes
+
+**Storage**
+- Simple to understand
+- Easy to predict growth
+- Clear cost driver
+- Example: S3 per GB stored, databases per GB
+
+**Bandwidth/data transfer**
+- Makes sense for CDN and hosting
+- Can be surprising if not monitored
+- Example: Cloudflare per GB, Vercel bandwidth
+
+**Active users (MAU)**
+- Works for auth and user-facing tools
+- Aligns with customer's growth
+- Example: Auth0, Firebase Auth
+
+### Problematic Metrics
+
+**"Compute units" or proprietary measures**
+```
+Bad: "1 CU = 0.25 CPU seconds at 1.5GHz equivalent with 256MB memory allocation"
+Developers can't estimate usage.
+```
+
+**Compound metrics**
+```
+Bad: "Charged per operation, where operation = read OR write OR delete,
+     multiplied by document size factor"
+Too complex to predict.
+```
+
+**Metrics that punish success**
+```
+Bad: Per-user pricing that penalizes viral growth
+Developer's successful launch becomes a cost crisis.
+```
+
+**Metrics with hidden multipliers**
+```
+Bad: "Per request, but each retry counts, and warming requests count,
+     and health checks count"
+Actual usage is unpredictable.
+```
+
+### Metric Selection Framework
+
+| Metric | When It Works | When It Fails |
+|--------|---------------|---------------|
+| API calls | Discrete operations | Streaming, persistent connections |
+| Compute time | Variable workloads | Idle resources still cost |
+| Storage | Data products | Temporary/cache data |
+| Bandwidth | CDN, media | Retry-heavy protocols |
+| MAU | User-facing apps | Machine-to-machine |
+| Seats | Collaboration tools | Individual developers |
+
+## Pricing Page Clarity
+
+### Essential Pricing Page Elements
+
+1. **Price per unit, clearly stated**
+```
+$0.01 per 1,000 API calls
+$0.10 per GB stored
+$5 per team member
+```
+
+2. **Usage calculator**
+```
+Estimate your monthly cost:
+API calls per month: [____]
+Storage (GB): [____]
+
+Estimated cost: $XX/month
+```
+
+3. **Tier comparison table**
+```
+                Free        Pro         Enterprise
+API calls       10,000/mo   100,000/mo  Unlimited
+Storage         1GB         50GB        500GB
+Support         Community   Email       Priority
+Price           $0          $29/mo      $299/mo
+```
+
+4. **FAQ answering real questions**
+- "What happens if I exceed my limit?"
+- "How do I monitor my usage?"
+- "Are there any hidden fees?"
+- "Can I set spending limits?"
+
+### Pricing Page Examples
+
+**Excellent: Stripe**
+- Simple percentage per transaction
+- Clear calculator
+- All fees visible
+- Volume discounts transparent
+
+**Excellent: Cloudflare**
+- Free tier generous
+- Paid features clearly differentiated
+- Per-feature pricing available
+- Enterprise custom pricing framed simply
+
+**Poor patterns:**
+- "Contact sales" for any pricing information
+- Prices hidden until signup
+- Complex unit definitions
+- Multiple interdependent metrics
+
+### Price Communication Principles
+
+1. **Lead with simple cases** - Show the "typical" cost first
+2. **Reveal complexity gradually** - Edge cases in FAQ, not main pricing
+3. **Use real numbers** - "$47/month for a typical SaaS app" beats "$0.001 per request"
+4. **Compare to alternatives** - "50% less than AWS" (if true and provable)
+
+## Cost Predictability and Caps
+
+### Why Predictability Matters
+
+Developers fear:
+- Unexpected month-end bills
+- Usage spikes from bugs or attacks
+- Being unable to explain costs to managers
+- Services that punish success
+
+### Providing Predictability
+
+**Usage dashboards:**
+```
+Current billing period: March 1-31
+
+API calls:     45,000 / 100,000 (45%)
+Storage:       12GB / 50GB (24%)
+Bandwidth:     89GB / 100GB (89%) ⚠️
+
+Projected bill: $47 (current: $38)
+```
+
+**Usage alerts:**
+```
+Alert settings:
+[ ] 50% of monthly limit
+[x] 75% of monthly limit
+[x] 90% of monthly limit
+[x] 100% of monthly limit
+[ ] Daily usage spike (>2x average)
+```
+
+**Spending caps:**
+```
+Monthly spending cap: $100
+
+When reached:
+( ) Hard stop - service pauses
+(x) Soft stop - alert and require approval
+( ) No stop - continue and alert
+```
+
+### Cap Implementation Considerations
+
+**Hard caps:**
+- Service stops at limit
+- Best for: Development, non-critical
+- Risk: Production outages
+
+**Soft caps:**
+- Service continues, alerts sent
+- Best for: Production, alert required
+- Risk: Unexpected overages
+
+**Burst allowance:**
+- Short-term overage allowed
+- Best for: Handling legitimate spikes
+- Risk: Abuse potential
+
+**Automatic scaling:**
+- Auto-upgrade tier temporarily
+- Best for: Predictable growth
+- Risk: Confusion about costs
+
+## Billing Transparency
+
+### The Bill Should Tell a Story
+
+**Bad invoice:**
+```
+Usage charges: $147.00
+Total: $147.00
+```
+
+**Good invoice:**
+```
+API Usage
+- Requests: 245,000 @ $0.01/1,000 = $2.45
+- Bandwidth: 150GB @ $0.10/GB = $15.00
+
+Compute
+- Function invocations: 50,000 @ $0.0001 = $5.00
+- Compute time: 10,000 GB-sec @ $0.0000166 = $0.17
+
+Storage
+- Database: 25GB @ $0.50/GB = $12.50
+
+Platform fee: $29.00 (Pro plan base)
+
+Subtotal: $64.12
+Credits applied: -$10.00 (new user credit)
+
+Total: $54.12
+```
+
+### Usage Visibility
+
+**Dashboard requirements:**
+- Real-time or near-real-time usage
+- Daily/weekly/monthly views
+- Breakdown by resource/project
+- Comparison to previous periods
+- Export for internal analysis
+
+**API for usage data:**
+```bash
+curl https://api.example.com/usage \
+  -H "Authorization: Bearer sk_live_xxx"
+
+{
+  "period": "2024-03-01/2024-03-31",
+  "api_calls": 245000,
+  "bandwidth_gb": 150,
+  "cost_to_date": 54.12,
+  "projected_cost": 62.00
+}
+```
+
+### Billing Cycle Best Practices
+
+- **Monthly billing** - Standard, predictable
+- **Prepaid credits** - Discount for commitment, reduces uncertainty
+- **Annual contracts** - For enterprise, discount for commitment
+- **Billing date choice** - Let customers align with their accounting
+
+## Communicating Value vs Cost
+
+### The Value Conversation
+
+Don't just communicate price—communicate value relative to alternatives.
+
+**Alternative cost comparisons:**
+```
+Running this yourself:
+- Server costs: $200/mo
+- Engineer time: $5,000/mo
+- Maintenance: $500/mo
+Total: $5,700/mo
+
+Our service: $99/mo
+You save: $5,601/mo
+```
+
+**Time savings:**
+```
+Without [Product]:
+- 2 weeks to build
+- 4 hours/month to maintain
+
+With [Product]:
+- 30 minutes to integrate
+- Zero maintenance
+
+Developer time saved: 120+ hours/year
+```
+
+### ROI Calculators
+
+For enterprise sales, provide ROI tools:
+
+```
+Your company:
+- Developers: [10]
+- Hours/week on auth: [5]
+- Fully-loaded cost/hour: [$150]
+
+Current cost: $3,000/week = $156,000/year
+
+With [Product]:
+- Integration: 20 hours one-time = $3,000
+- Annual cost: $12,000
+- Maintenance: Near zero
+
+First year savings: $141,000
+```
+
+### Pricing Justification
+
+When prices seem high, justify with:
+1. **Feature completeness** - "Includes what others charge extra for"
+2. **Reliability** - "99.99% uptime saves you from outages"
+3. **Support** - "Engineering support, not offshore scripts"
+4. **Scale** - "Handles 10x traffic without config changes"
+5. **Security** - "SOC 2, GDPR, HIPAA included"
+
+## Competitive Pricing Research
+
+### Understanding the Landscape
+
+**Map competitors by:**
+1. Direct competitors (same solution)
+2. Adjacent competitors (different approach, same problem)
+3. Build-it-yourself (internal development cost)
+4. Status quo (doing nothing)
+
+**Pricing model analysis:**
+```
+Competitor A: $0.015/request, no free tier, 99.9% SLA
+Competitor B: $0.008/request, generous free tier, 99.5% SLA
+Open source: $0 + hosting costs (~$0.005/request) + maintenance
+```
+
+### Pricing Position Options
+
+**Premium pricing:**
+- Higher price, higher perceived value
+- Works with: Superior product, enterprise focus
+- Requires: Clear differentiation
+
+**Value pricing:**
+- Comparable price, more features
+- Works with: Feature-rich products
+- Requires: Clear comparison
+
+**Penetration pricing:**
+- Lower price, gain market share
+- Works with: Commoditized features
+- Requires: Path to profitability
+
+**Usage-aligned pricing:**
+- Aligned with customer value
+- Works with: Variable usage patterns
+- Requires: Clear value correlation
+
+### Competitive Analysis Template
+
+For each competitor:
+```
+[Competitor Name]
+Pricing model: [Per-seat / usage-based / flat]
+Free tier: [Yes/No, limits]
+Starting price: [$X/mo or $/unit]
+Enterprise: [Custom / listed price]
+Key differentiator: [Feature/price/market]
+Developer sentiment: [From Twitter, HN, Reddit]
+```
+
+### Price Testing
+
+**A/B testing considerations:**
+- Test different price points (carefully, ethically)
+- Test different packaging (bundles vs. à la carte)
+- Test annual vs. monthly emphasis
+- Test value framing ("save $X" vs. "costs $Y")
+
+**Qualitative research:**
+- Win/loss analysis: Why did they choose us/competitor?
+- Price sensitivity interviews: What would change their decision?
+- Value perception: What do they think is fair?
+
+## Pricing Anti-Patterns
+
+### The Surprise Bill
+
+Developers share horror stories:
+- "My $20/month bill became $2,000"
+- "A bug caused infinite loops and I owe $500"
+- No warning, no cap, no mercy
+
+**Solution:** Spending caps, usage alerts, anomaly detection
+
+### The Pricing Maze
+
+- Requires spreadsheet to calculate
+- Different metrics for different features
+- Hidden fees discovered later
+- Changes frequently without notice
+
+**Solution:** Simple, clear, stable pricing
+
+### The Negotiation Game
+
+- "Contact sales" for all meaningful tiers
+- List price is 10x actual price
+- Every customer gets different deal
+- Penalizes customers who don't negotiate
+
+**Solution:** Transparent pricing, volume discounts listed
+
+### The Bait and Switch
+
+- Free tier gets worse over time
+- Prices increase without grandfathering
+- Features move from free to paid
+- "New pricing" disadvantages existing customers
+
+**Solution:** Grandfathering, clear migration paths, community communication
+
+## Examples: Pricing That Works
+
+### Stripe
+
+- Per-transaction percentage (2.9% + 30¢)
+- Aligns with customer revenue
+- Predictable and simple
+- Volume discounts for scale
+
+### Twilio
+
+- Per-message/per-minute pricing
+- Clear unit costs
+- Usage dashboard and alerts
+- Prepaid credits for discount
+
+### Vercel
+
+- Clear tier structure
+- Generous free tier
+- Usage-based for bandwidth/builds
+- Team pricing separate
+
+### DigitalOcean
+
+- Predictable monthly pricing
+- Clear size/price relationship
+- Hourly billing option
+- Bandwidth included in pricing
+
+## Examples: Pricing Problems
+
+### Confusing Unit Pricing
+
+Some cloud providers:
+- Per "compute unit" (undefined)
+- Multiple meters per service
+- Different rates for different operations
+- Bill requires expert interpretation
+
+### Enterprise Tax
+
+Some companies:
+- SSO requires enterprise tier
+- SSO tier is 10x team tier
+- No intermediate option
+- Punishes security-conscious teams
+
+### Punishing Success
+
+Some user-based pricing:
+- Free tier: 100 users
+- Paid tier: $0.10/user
+- Viral success = immediate $$$
+- Discourages growth
+
+## Tools
+
+### Billing Platforms
+
+- **Stripe Billing** - Subscription and usage-based billing
+- **Orb** - Usage-based billing infrastructure
+- **Lago** - Open source billing platform
+- **Metronome** - Usage metering and billing
+- **Chargebee** - Subscription management
+
+### Usage Metering
+
+- **Segment** - Event tracking for usage
+- **Rudderstack** - Open source alternative
+- **Custom** - Most companies build their own metering
+
+### Pricing Pages
+
+- **PricingPage.io** - Templates and inspiration
+- **ProfitWell** - Pricing analytics
+- **Baremetrics** - SaaS metrics and pricing tools
+
+### Competitive Intelligence
+
+- **Competitors.app** - Track competitor pricing changes
+- **Manual monitoring** - Sign up for competitor newsletters
+- **Community research** - Reddit, HN, Twitter sentiment
+
+## Related Skills
+
+- `/devmarketing-skills/skills/free-tier-strategy` - Free tier design
+- `/devmarketing-skills/skills/developer-signup-flow` - Getting to the pricing page
+- `/devmarketing-skills/skills/developer-onboarding` - Demonstrating value before price
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.