mvp-launcher

Original source / Raw SKILL.md

---
name: mvp-launcher
description: Rapid MVP validation and launch framework following Y Combinator and lean startup principles. Use when user wants to validate a business idea, launch an MVP, define product strategy, calculate unit economics, or needs structured approach to test product-market fit. Includes monetization models, metrics frameworks, and execution templates.
---

# MVP Launcher

Framework for rapid MVP validation and launch using proven startup methodologies from Y Combinator, lean startup, and first-principles thinking.

## Core Workflow

### 1. Problem-Solution Validation

**Ask the forcing questions:**
- What specific problem are you solving? (Not a solution in disguise)
- Who has this problem urgently enough to pay?
- How are they solving it now? (Current alternatives = market validation)
- Why will they switch to your solution?

**Output:** One-sentence value proposition that passes the "mom test"

### 2. Market Sizing (Быстрая оценка)

Use `scripts/market_sizer.py` for TAM/SAM/SOM calculation:

```bash
python scripts/market_sizer.py --total-market 1000000 --addressable-percent 10 --obtainable-percent 5
```

**Reality checks:**
- TAM > $1B = maybe real market
- SAM > $100M = venture-scale potential
- SOM (first year) = be honest, usually <1% of SAM

### 3. MVP Scope Definition

**Принцип:** Smallest thing that proves value hypothesis

Use `assets/mvp_canvas.md` template to define:
- Core value proposition (1 sentence)
- Primary user action (1 action)
- Success metric (1 number)
- Time to first value (<5 minutes ideal)

**Anti-pattern:** "But we also need..." → NO. Ship, measure, iterate.

### 4. Monetization Strategy

See `references/monetization-models.md` for quick selection guide.

**Key decisions:**
- Pricing model: subscription / usage-based / transaction / freemium
- Price point: value-based (not cost-plus)
- Payment psychology: annual discounts, tiered pricing, anchor pricing

**Forcing function:** If they won't pay $X for this, the problem isn't urgent enough.

### 5. Unit Economics

Use `scripts/unit_economics.py` for rapid calculation:

```bash
python scripts/unit_economics.py --ltv 1200 --cac 400 --churn-rate 5
```

**Minimum viability:**
- LTV:CAC ratio ≥ 3:1
- CAC payback ≤ 12 months
- Monthly churn ≤ 5% (for SaaS)

If numbers don't work at scale, pivot or kill the idea.

### 6. Build & Launch Strategy

**Week 1-2:** Core feature + payment
**Week 3:** First 10 paying customers (manual sales, no automation yet)
**Week 4:** Measure, learn, decide: iterate / pivot / kill

**Tech principles:**
- No-code/low-code first (n8n, Airtable, Webflow)
- Manual processes behind automated facade
- Don't build what you can integrate
- PostgreSQL + Python API = enough for 100k users

### 7. Metrics Framework

See `references/metrics-framework.md` for stage-specific KPIs.

**MVP stage - track only:**
- Activation rate (signup → first value)
- Retention (D1, D7, D30)
- Revenue per user
- NPS or qualitative feedback

Ignore: total users, page views, social followers (vanity metrics)

### 8. Go-to-Market

**Before product-market fit:**
- Do things that don't scale (Paul Graham)
- Talk to users every day
- Manual sales → learn messaging
- Early adopters ≠ mainstream market

**Channel testing sequence:**
1. Direct outreach (LinkedIn, email, communities)
2. Content/SEO (if long sales cycle)
3. Paid ads (only after LTV:CAC proven)
4. Partnerships/integrations

## Decision Points

### When to iterate:
- Users sign up but don't activate → onboarding problem
- Users try once then churn → not enough value
- Good engagement, won't pay → wrong audience or positioning

### When to pivot:
- No organic growth after 3 months of trying
- LTV:CAC fundamentally broken
- Users love it, but market too small

### When to kill:
- No one cares (not even early adopters)
- You've stopped believing in it
- Better opportunity identified

## Reference Materials

Load as needed:
- **Monetization models**: See `references/monetization-models.md`
- **Metrics frameworks**: See `references/metrics-framework.md`
- **YC startup playbook**: See `references/yc-playbook.md`

## Templates

- **MVP Canvas**: `assets/mvp_canvas.md` - One-page planning template
- **Unit economics sheet**: Generate via scripts
- **Weekly progress template**: In assets/

## Anti-Patterns to Avoid

- Building for 6 months before talking to users
- Perfecting features instead of testing core hypothesis
- Raising money before product-market fit
- Hiring before proving the model works
- Optimizing conversion before understanding why users stay
- "If we build it, they will come"


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### scripts/market_sizer.py

```python
#!/usr/bin/env python3
"""
Market Sizing Calculator (TAM/SAM/SOM)

Calculates Total Addressable Market, Serviceable Addressable Market, 
and Serviceable Obtainable Market.
"""

import argparse
import sys


def calculate_market_size(
    total_market: float,
    addressable_percent: float,
    obtainable_percent: float,
    avg_revenue_per_customer: float = None
) -> dict:
    """Calculate TAM/SAM/SOM metrics"""
    
    if not (0 <= addressable_percent <= 100):
        raise ValueError("Addressable percent must be between 0 and 100")
    if not (0 <= obtainable_percent <= 100):
        raise ValueError("Obtainable percent must be between 0 and 100")
    
    sam = total_market * (addressable_percent / 100)
    som = sam * (obtainable_percent / 100)
    
    result = {
        'tam': total_market,
        'sam': sam,
        'som': som,
        'sam_percent': addressable_percent,
        'som_percent': obtainable_percent
    }
    
    if avg_revenue_per_customer:
        result['tam_customers'] = total_market / avg_revenue_per_customer
        result['sam_customers'] = sam / avg_revenue_per_customer
        result['som_customers'] = som / avg_revenue_per_customer
    
    return result


def format_number(num: float) -> str:
    """Format large numbers with K/M/B suffixes"""
    if num >= 1_000_000_000:
        return f"${num/1_000_000_000:.1f}B"
    elif num >= 1_000_000:
        return f"${num/1_000_000:.1f}M"
    elif num >= 1_000:
        return f"${num/1_000:.1f}K"
    else:
        return f"${num:,.0f}"


def main():
    parser = argparse.ArgumentParser(
        description='Calculate TAM/SAM/SOM market sizing',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  python market_sizer.py --total-market 10000000000 --addressable-percent 15 --obtainable-percent 3
  python market_sizer.py --total-market 5000000000 --addressable-percent 20 --obtainable-percent 5 --arpu 1200

TAM: Total Addressable Market (entire market size)
SAM: Serviceable Addressable Market (portion you can serve)
SOM: Serviceable Obtainable Market (realistic near-term capture)
        '''
    )
    
    parser.add_argument('--total-market', type=float, required=True,
                       help='Total Addressable Market (TAM) in $')
    parser.add_argument('--addressable-percent', type=float, required=True,
                       help='Percent of TAM you can address (0-100)')
    parser.add_argument('--obtainable-percent', type=float, required=True,
                       help='Percent of SAM you can obtain (0-100)')
    parser.add_argument('--arpu', type=float, default=None,
                       help='Average revenue per customer (optional, for customer count)')
    
    args = parser.parse_args()
    
    try:
        results = calculate_market_size(
            args.total_market,
            args.addressable_percent,
            args.obtainable_percent,
            args.arpu
        )
        
        # Market size assessments
        tam_assessment = (
            "✅ Venture scale" if results['tam'] >= 1_000_000_000
            else "⚠️  Small market" if results['tam'] >= 100_000_000
            else "❌ Too small for VC"
        )
        
        sam_assessment = (
            "✅ Large opportunity" if results['sam'] >= 100_000_000
            else "✅ Good opportunity" if results['sam'] >= 10_000_000
            else "⚠️  Niche market"
        )
        
        som_assessment = (
            "✅ Strong first-year target" if results['som'] >= 1_000_000
            else "✅ Realistic" if results['som'] >= 100_000
            else "⚠️  May need to increase obtainable %"
        )
        
        # Output
        print("\n" + "="*60)
        print("MARKET SIZING ANALYSIS")
        print("="*60)
        
        print("\n📊 INPUTS:")
        print(f"  Total Market (TAM):            {format_number(args.total_market)}")
        print(f"  Addressable Segment:           {args.addressable_percent}% of TAM")
        print(f"  Obtainable (Year 1-3):         {args.obtainable_percent}% of SAM")
        if args.arpu:
            print(f"  Avg Revenue per Customer:      ${args.arpu:,.2f}")
        
        print("\n💰 MARKET SIZES:")
        print(f"  TAM (Total Addressable):       {format_number(results['tam'])}")
        print(f"    → {tam_assessment}")
        print(f"\n  SAM (Serviceable Addressable): {format_number(results['sam'])}")
        print(f"    → {args.addressable_percent}% of TAM")
        print(f"    → {sam_assessment}")
        print(f"\n  SOM (Serviceable Obtainable):  {format_number(results['som'])}")
        print(f"    → {args.obtainable_percent}% of SAM")
        print(f"    → {som_assessment}")
        
        if args.arpu:
            print("\n👥 CUSTOMER COUNTS:")
            print(f"  TAM Customers:                 {results['tam_customers']:,.0f}")
            print(f"  SAM Customers:                 {results['sam_customers']:,.0f}")
            print(f"  SOM Customers (Year 1-3):      {results['som_customers']:,.0f}")
        
        print("\n🎯 STRATEGIC ASSESSMENT:")
        
        # TAM analysis
        if results['tam'] >= 1_000_000_000:
            print("\n  ✅ TAM supports venture-scale business")
            print("     • Large enough for VC funding")
            print("     • Room for multiple players")
        elif results['tam'] >= 100_000_000:
            print("\n  ⚠️  TAM is smallish for traditional VC")
            print("     • Consider bootstrapping or focused VC")
            print("     • May need to expand TAM definition")
        else:
            print("\n  ❌ TAM likely too small for VC model")
            print("     • Bootstrap or find adjacent markets")
            print("     • Expand TAM definition if possible")
        
        # SAM analysis
        if results['sam'] >= 100_000_000:
            print("\n  ✅ Strong serviceable market")
            print("     • Enough room to build significant business")
        elif results['sam'] >= 10_000_000:
            print("\n  ⚠️  Moderate serviceable market")
            print("     • Validate obtainable % is realistic")
            print("     • Consider expanding addressable segment")
        else:
            print("\n  ⚠️  Small serviceable market")
            print("     • Increase addressable % or expand definition")
            print("     • Verify market sizing assumptions")
        
        # SOM analysis
        som_percent_of_sam = args.obtainable_percent
        if som_percent_of_sam > 10:
            print("\n  ⚠️  Obtainable % seems high (>10% of SAM)")
            print("     • Be more conservative in projections")
            print("     • Typical first 3 years: 1-5% of SAM")
        elif som_percent_of_sam >= 1:
            print("\n  ✅ Obtainable % looks realistic")
            print("     • Focus on execution to capture SOM")
        else:
            print("\n  ⚠️  Obtainable % very conservative")
            print("     • Possibly too pessimistic")
            print("     • Or SAM definition too broad")
        
        print("\n📈 NEXT STEPS:")
        print("  1. Validate TAM assumptions with research")
        print("  2. Identify specific SAM segments to target")
        print("  3. Build bottom-up model for SOM")
        print("  4. Test pricing and unit economics")
        print("  5. Define 12-month customer acquisition plan")
        
        print("\n" + "="*60)
        print("\nBENCHMARKS:")
        print("  TAM:  >$1B = venture scale, >$100M = viable")
        print("  SAM:  >$100M = large opportunity")
        print("  SOM:  1-5% of SAM realistic for Year 1-3")
        print("  Reality check: Build bottom-up model to verify")
        print("="*60 + "\n")
        
    except ValueError as e:
        print(f"\n❌ Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ Unexpected error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

```

### scripts/unit_economics.py

```python
#!/usr/bin/env python3
"""
Unit Economics Calculator

Calculates key SaaS metrics: LTV, CAC, payback period, and ratios.
"""

import argparse
import sys


def calculate_ltv(arpu: float, gross_margin: float, monthly_churn: float) -> dict:
    """Calculate Customer Lifetime Value"""
    if monthly_churn <= 0 or monthly_churn >= 100:
        raise ValueError("Monthly churn must be between 0 and 100")
    
    churn_rate = monthly_churn / 100
    customer_lifetime_months = 1 / churn_rate
    
    # LTV = ARPU × Gross Margin × Customer Lifetime
    ltv = arpu * (gross_margin / 100) * customer_lifetime_months
    
    return {
        'ltv': ltv,
        'lifetime_months': customer_lifetime_months
    }


def calculate_payback_period(cac: float, arpu: float, gross_margin: float) -> float:
    """Calculate CAC Payback Period in months"""
    monthly_gross_profit = arpu * (gross_margin / 100)
    if monthly_gross_profit <= 0:
        raise ValueError("Monthly gross profit must be positive")
    
    payback_months = cac / monthly_gross_profit
    return payback_months


def main():
    parser = argparse.ArgumentParser(
        description='Calculate SaaS unit economics',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  python unit_economics.py --arpu 100 --cac 300 --churn-rate 5 --margin 80
  python unit_economics.py --arpu 50 --cac 150 --churn-rate 8 --margin 70
  
Output explains:
  - LTV (Lifetime Value)
  - LTV:CAC ratio (target: ≥3:1)
  - CAC Payback Period (target: ≤12 months)
  - Customer Lifetime in months
        '''
    )
    
    parser.add_argument('--arpu', type=float, required=True,
                       help='Average Revenue Per User (monthly, in $)')
    parser.add_argument('--cac', type=float, required=True,
                       help='Customer Acquisition Cost (in $)')
    parser.add_argument('--churn-rate', type=float, required=True,
                       help='Monthly churn rate (in %, e.g., 5 for 5%%)')
    parser.add_argument('--margin', type=float, default=80,
                       help='Gross margin (in %%, default: 80)')
    
    args = parser.parse_args()
    
    try:
        # Calculate LTV
        ltv_data = calculate_ltv(args.arpu, args.margin, args.churn_rate)
        ltv = ltv_data['ltv']
        lifetime_months = ltv_data['lifetime_months']
        
        # Calculate ratios
        ltv_cac_ratio = ltv / args.cac if args.cac > 0 else 0
        payback_months = calculate_payback_period(args.cac, args.arpu, args.margin)
        
        # Assessments
        ltv_cac_assessment = (
            "✅ Excellent" if ltv_cac_ratio >= 5
            else "✅ Good" if ltv_cac_ratio >= 3
            else "⚠️  Marginal" if ltv_cac_ratio >= 1
            else "❌ Broken"
        )
        
        payback_assessment = (
            "✅ Excellent" if payback_months <= 6
            else "✅ Good" if payback_months <= 12
            else "⚠️  Marginal" if payback_months <= 18
            else "❌ Too long"
        )
        
        churn_assessment = (
            "✅ Excellent" if args.churn_rate <= 3
            else "✅ Good" if args.churn_rate <= 5
            else "⚠️  High" if args.churn_rate <= 10
            else "❌ Critical"
        )
        
        # Output results
        print("\n" + "="*60)
        print("UNIT ECONOMICS ANALYSIS")
        print("="*60)
        
        print("\n📊 INPUTS:")
        print(f"  ARPU (Monthly):        ${args.arpu:,.2f}")
        print(f"  CAC:                   ${args.cac:,.2f}")
        print(f"  Monthly Churn Rate:    {args.churn_rate}%")
        print(f"  Gross Margin:          {args.margin}%")
        
        print("\n💰 KEY METRICS:")
        print(f"  LTV:                   ${ltv:,.2f}")
        print(f"  Customer Lifetime:     {lifetime_months:.1f} months")
        print(f"  LTV:CAC Ratio:         {ltv_cac_ratio:.2f}:1  {ltv_cac_assessment}")
        print(f"  CAC Payback Period:    {payback_months:.1f} months  {payback_assessment}")
        
        print("\n🎯 ASSESSMENT:")
        print(f"  LTV:CAC Ratio:         {ltv_cac_assessment}")
        print(f"  Payback Period:        {payback_assessment}")
        print(f"  Churn Rate:            {churn_assessment}")
        
        print("\n📈 IMPROVEMENT LEVERS:")
        
        if ltv_cac_ratio < 3:
            print("  ⚠️  LTV:CAC below 3:1 - Options:")
            print("     • Reduce CAC (optimize channels, improve conversion)")
            print("     • Increase ARPU (pricing, upsells, cross-sells)")
            print("     • Reduce churn (improve retention, product value)")
        
        if payback_months > 12:
            print("  ⚠️  Payback > 12 months - Options:")
            print("     • Annual billing (get cash upfront)")
            print("     • Reduce CAC (more efficient channels)")
            print("     • Increase ARPU (higher pricing)")
        
        if args.churn_rate > 5:
            print("  ⚠️  High churn - Focus on:")
            print("     • Onboarding improvements")
            print("     • Product stickiness features")
            print("     • Customer success programs")
            print("     • Better customer targeting")
        
        if ltv_cac_ratio >= 3 and payback_months <= 12 and args.churn_rate <= 5:
            print("  ✅ Unit economics look healthy!")
            print("     • Focus on scaling customer acquisition")
            print("     • Maintain or improve these ratios at scale")
        
        print("\n" + "="*60)
        print("\nBENCHMARKS (B2B SaaS):")
        print("  LTV:CAC Ratio:   ≥3:1 minimum, ≥5:1 excellent")
        print("  Payback Period:  ≤12 months good, ≤6 months excellent")
        print("  Monthly Churn:   ≤5% good, ≤3% excellent")
        print("="*60 + "\n")
        
    except ValueError as e:
        print(f"\n❌ Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ Unexpected error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

```

### assets/mvp_canvas.md

```markdown
# MVP Canvas Template

Use this one-page template to crystallize your MVP scope and hypothesis.

## 🎯 Core Value Proposition

**One sentence that passes the "mom test":**

[Your value prop here - What problem → For whom → Why now]

Example: "Automated invoice reconciliation for small accounting firms who waste 10+ hours/week on manual matching"

---

## 👤 Target User

**Specific person, not a segment:**

- Role/Title:
- Company size/type:
- Current behavior:
- Pain point intensity (1-10):
- Budget authority (Y/N):

**How they solve it now:**

[Current alternative - this validates market exists]

**Why they'll switch:**

[Your unfair advantage - 10x better, not 10% better]

---

## ⚡ Primary User Action

**The ONE thing users must do to get value:**

[Single core action - e.g., "Upload invoice → See matched transaction"]

**Time to first value:**

[Target: <5 minutes from signup to "aha moment"]

**Success looks like:**

[Observable behavior - e.g., "User uploads 2nd invoice without prompting"]

---

## 📊 Success Metric

**Primary metric that proves hypothesis:**

[Pick ONE - examples below]

- Activation rate: X% complete core action within 24h
- Retention: X% return within 7 days
- Payment: X% pay within first use
- Engagement: X actions per user per week

**Target number:**

[Set specific target - e.g., "30% activation in first session"]

**How we'll measure:**

[Tracking method - mixpanel, postgres query, manual count]

---

## 💰 Monetization

**Pricing model:**

[ ] Subscription (monthly/annual)
[ ] Usage-based (per API call, transaction, etc.)
[ ] One-time purchase
[ ] Freemium
[ ] Transaction/marketplace fee

**Price point:**

$_____ per _____ (month/year/transaction/etc.)

**Value anchor:**

[What ROI/value does user get? Must be 10x price minimum]

---

## 🚀 Build Scope (Week 1-2)

**Must have (core value delivery):**

1. [Feature 1 - minimum to deliver value]
2. [Feature 2 - if truly essential]
3. [Payment mechanism - even if manual]

**Deliberately excluded (will add only if proven necessary):**

- [Feature X - nice to have]
- [Feature Y - premature optimization]
- [Feature Z - can be manual for first 10 users]

**Manual workarounds (do things that don't scale):**

- [Process 1 - handled manually behind scenes]
- [Process 2 - personal onboarding for early users]

---

## 🎬 Launch Plan

**Week 1-2: Build + First Users**

- Complete MVP build
- Target: 3-5 alpha users (manually recruited)
- Method: [Direct outreach, community, personal network]

**Week 3: First 10 Paying Customers**

- Manual sales, learn messaging
- User interviews daily
- Iterate based on feedback

**Week 4: Measure & Decide**

- Hit/miss on success metric?
- Retention curve flattening?
- Users demonstrating problem is real?
- Decision: Iterate / Pivot / Kill

---

## ✅ Validation Criteria (Go/No-Go)

**Signals we're onto something:**

- [ ] 40%+ activation rate
- [ ] 20%+ D7 retention
- [ ] Users asking "when can I pay?"
- [ ] Organic word-of-mouth starting
- [ ] Using it ourselves regularly

**Kill signals:**

- [ ] <10% activation after multiple iterations
- [ ] Users try once, never return
- [ ] "Nice to have" but won't pay
- [ ] We've stopped believing in it

---

## 📝 Assumptions to Test

**Riskiest assumption #1:**

[What must be true for this to work?]

Test method: [How will we validate this quickly?]

**Riskiest assumption #2:**

[Second critical assumption]

Test method: [Validation approach]

**Riskiest assumption #3:**

[Third assumption]

Test method: [Quick test]

---

## 🔄 Iteration Hypotheses

After first week, document what you're learning:

**Hypothesis 1:**

"We believe [doing X] will result in [outcome Y] because [reason Z]"

Result after test: [What happened]

**Hypothesis 2:**

"We believe [doing X] will result in [outcome Y] because [reason Z]"

Result after test: [What happened]

---

## 🚫 Anti-Patterns to Avoid

Check yourself before wrecking yourself:

- [ ] Building for 6+ weeks before first user
- [ ] Adding features before core value proven
- [ ] Optimizing before understanding retention
- [ ] Talking to investors before customers
- [ ] Focusing on UI polish over functionality
- [ ] "One more feature and then we'll launch"

---

## 📅 Timeline Reality Check

- Day 1-7: Build core feature
- Day 8-10: First 3 alpha users
- Day 11-14: Iterate on feedback
- Day 15-21: First 10 paying customers
- Day 22-28: Measure, learn, decide

If you're taking longer, you're probably building too much.

**Ship date (commit to it):**

[Specific date - create urgency]

---

Fill this out in 30 minutes. If it takes longer, you're overthinking it.

Launch in 2 weeks. Talk to users daily. Measure ruthlessly. Iterate or pivot.

```

### references/monetization-models.md

```markdown
# Monetization Models Quick Reference

## Model Selection Framework

Choose based on: value delivery pattern, customer behavior, competitive landscape.

## 1. Subscription (SaaS)

**When to use:**
- Continuous value delivery
- Regular usage pattern
- Retention is core metric

**Pricing tiers:**
- **Freemium**: Free tier → conversion to paid (10-20% typical)
- **Tiered**: Good/Better/Best (anchor middle tier at 3x free value)
- **Usage-based tiers**: Pay as you grow (reduces initial friction)

**Price points (B2B SaaS):**
- Entry: $29-99/mo (prosumer, small teams)
- Mid: $199-499/mo (SMB, clear ROI)
- Enterprise: $1000+/mo (custom, volume discounts)

**Annual billing strategy:**
- 2 months free standard (16% discount)
- Improves cash flow and retention
- Require annual for enterprise

## 2. Usage-Based (Consumption)

**When to use:**
- Variable usage patterns
- Value directly tied to consumption
- "Pay for what you use" resonates

**Examples:**
- API calls (per 1000 requests)
- Storage (per GB)
- Credits/tokens system
- Transaction volume

**Advantages:**
- Lower entry barrier
- Scales with customer growth
- Natural expansion revenue

**Risks:**
- Revenue volatility
- Complex pricing communication
- Requires good usage monitoring

## 3. Transaction/Marketplace

**When to use:**
- Facilitate transactions between parties
- Value = successful completion
- Network effects exist

**Take rates:**
- Digital goods: 15-30%
- Services marketplace: 10-20%
- B2B transactions: 1-5%

**Hybrid model:**
- Transaction fee + subscription (guaranteed revenue floor)
- Example: Stripe (2.9% + $0.30) + monthly platform fee

## 4. One-Time Purchase

**When to use:**
- Discrete value delivery
- Low ongoing costs
- Lifetime access makes sense

**Price anchoring:**
- Entry: $9-29 (impulse buy)
- Mid: $49-199 (considered purchase)
- Premium: $299-999 (must justify ROI)

**Upgrade path:**
- Major versions (v1 → v2)
- Add-ons and extensions
- Priority support tier

## 5. Freemium

**When to use:**
- Viral growth potential
- Word-of-mouth critical
- Free tier creates network effects

**Conversion triggers:**
- Usage limits (API calls, storage, seats)
- Feature gates (advanced functionality)
- Support/SLA requirements

**Success metrics:**
- 2-5% conversion = okay
- 5-10% = good
- 10%+ = excellent

**Anti-pattern:**
- Free tier too generous (no pressure to upgrade)
- Paid tier not compelling enough

## 6. Hybrid Models

### Subscription + Usage
- Base platform fee + usage overages
- Example: $99/mo + $0.01 per extra API call
- Predictable base + scales with value

### Freemium + Transaction
- Free to use, take cut of revenue
- Example: Shopify (subscription + transaction fees)

### Tiered + Usage Pooling
- Different tiers with included usage
- Example: $49/mo (10k credits) → $199/mo (100k credits)

## Pricing Psychology

### Value-Based Pricing
- Price on customer value received, not cost to deliver
- What's the ROI/value multiple? (10x minimum)
- Competitive alternatives set ceiling

### Anchoring Effects
- Show higher price first (annual vs monthly)
- Position middle tier as "most popular"
- Display savings percentage

### Price Experimentation
- A/B test pricing (if traffic allows)
- Grandfather existing customers on old pricing
- Test 2x increase on new cohorts (most founders underprice)

## Red Flags

**Pricing too low:**
- Can't afford customer acquisition
- Signals low value perception
- Attracts wrong customer segment

**Pricing too complex:**
- Users confused = won't buy
- Sales cycle lengthens
- Support burden increases

**No monetization MVP:**
- Must charge from day 1
- Even beta users should pay something
- Free = no validation that problem matters

## Quick Decision Tree

1. **Continuous value + retention model?** → Subscription
2. **Variable usage patterns?** → Usage-based or hybrid
3. **Facilitate transactions?** → Marketplace/transaction
4. **One-time delivery?** → One-time purchase
5. **Need viral growth?** → Freemium with conversion path

## Benchmarks by Business Model

**SaaS (subscription):**
- Monthly churn: <5% good, <3% excellent
- LTV:CAC: ≥3:1 minimum, 5:1+ great
- CAC payback: <12 months
- Annual contract value: $5k-50k (SMB), $100k+ (enterprise)

**Usage-based:**
- Revenue growth rate: 100%+ Year 1-3
- Net revenue retention: 120%+ (expansion > churn)
- Gross margin: 70%+ (scaling costs with usage)

**Marketplace:**
- Take rate: 10-20% standard
- Gross margin: 60-80% (after payment processing)
- Supply-side retention: Key metric (harder to replace)

```

### references/metrics-framework.md

```markdown
# Metrics Framework by Stage

## Stage 0: Idea Validation (Pre-MVP)

**Focus:** Does anyone care?

**Track:**
- Number of problem interviews conducted (target: 20-50)
- % who say problem is "urgent" or "must-have" (need: >40%)
- Current solution spend/time investment
- Willingness to pay (specific $ amount, not "maybe")

**Output:** Go/No-Go decision based on problem intensity

## Stage 1: MVP Launch (Weeks 1-8)

**Focus:** Does the solution work?

**Critical metrics:**
1. **Activation rate** = (Users who complete core action) / (Total signups)
   - Target: >40% within first session
   - Below 20% = major UX/value prop problem

2. **Time to first value**
   - Target: <5 minutes ideal, <15 minutes acceptable
   - Measure: signup → first successful action

3. **D1/D7 retention**
   - D1 (next day): >40% good
   - D7 (week): >20% good
   - Below 10% = not sticky enough

4. **Payment conversion** (even if beta pricing)
   - >10% of activated users = problem validated
   - <5% = reconsider pricing or target audience

**Ignore:**
- Total user count (vanity metric)
- Traffic sources (too early to optimize)
- Social media followers
- Press coverage

**Weekly review:**
- 10 user interviews (why staying/leaving)
- Top 3 friction points identified
- 1 hypothesis tested

## Stage 2: Product-Market Fit Hunt (Months 2-6)

**Focus:** Who loves it and why?

**North Star Metric:** Choose ONE based on business model:
- SaaS: Weekly/Monthly Active Users (WAU/MAU)
- Marketplace: Gross Merchandise Volume (GMV)
- Usage-based: API calls / Actions completed
- Content: Time spent / Return visits

**Core metrics:**
1. **Retention cohorts**
   - Week 1: X% → Week 4: Y% → Week 12: Z%
   - Flatten curve = product-market fit signal
   - Target: 30%+ retained at Week 8

2. **NPS (Net Promoter Score)**
   - Survey: "How likely recommend 0-10?"
   - NPS = % Promoters (9-10) - % Detractors (0-6)
   - Target: >50 = strong product-market fit

3. **Organic growth rate**
   - % new users from referrals/word-of-mouth
   - Target: >20% = natural virality exists

4. **Revenue per user (ARPU)**
   - Track by cohort, by channel
   - Should be increasing MoM if learning/improving

**Unit economics (emerging):**
- LTV calculation (still early, use retention proxies)
- CAC by channel (start measuring)
- Contribution margin per user

**PMF signals:**
- Users complaining if product goes down
- Organic word-of-mouth referrals happening
- Pulling product from market would disappoint segment
- Usage becoming habitual (80%+ of users return weekly)

## Stage 3: Growth & Scale (Post-PMF)

**Focus:** Efficient customer acquisition

**Financial metrics:**
1. **LTV:CAC ratio**
   - Target: ≥3:1
   - Calculate: (ARPU × Gross Margin% × 1/Churn%) / CAC

2. **CAC Payback Period**
   - Target: ≤12 months
   - Calculate: CAC / (ARPU × Gross Margin%)

3. **Monthly Recurring Revenue (MRR) growth**
   - Early stage: 15-20% MoM
   - Later stage: 5-10% MoM sustainable

4. **Net Revenue Retention (NRR)**
   - Target: >100% (expansion > churn)
   - Great: >120%
   - Calculate: (Starting MRR + Expansion - Churn) / Starting MRR

5. **Churn rate**
   - Gross churn: <5% monthly (SaaS)
   - Net churn: negative ideal (expansion > churn)

**Operational metrics:**
1. **Customer Acquisition Cost (CAC) by channel**
   - Paid ads, content, referral, partnerships
   - Focus budget on CAC < 1/3 LTV channels

2. **Conversion funnel**
   - Visitor → Signup → Activation → Payment
   - Optimize bottleneck step only

3. **Sales efficiency**
   - Magic Number = (Net New MRR × 4) / Sales & Marketing Spend
   - Target: >0.75

**Growth channels:**
- Track CAC, conversion rate, volume potential per channel
- Double down on what works (power law distribution)
- Kill underperforming channels ruthlessly

## Stage 4: Mature Business

**Focus:** Profitability & defensibility

**Executive dashboard:**
1. **Rule of 40**
   - Growth Rate% + Profit Margin% ≥ 40
   - Benchmark for SaaS health

2. **Gross Margin**
   - Target: >70% (SaaS), >50% (marketplace)

3. **Operating Margin**
   - Path to profitability visible
   - Target: 20%+ at scale

4. **Cash flow & runway**
   - Months of runway remaining
   - Burn multiple = Cash Burned / Net New ARR

## Metric Anti-Patterns

**Vanity metrics (ignore these):**
- Registered users (vs active users)
- App downloads (vs usage)
- Page views (vs time spent / actions)
- Social media followers (unless core to model)
- Press mentions (unless drives revenue)

**Premature optimization:**
- Conversion funnel before product-market fit
- Complex attribution before meaningful volume
- A/B testing with <1000 users per variant
- Paid acquisition before unit economics proven

**Metrics that lie:**
- Average (use median and distribution)
- Cumulative charts (use cohorts)
- Monthly actives hiding declining engagement
- Revenue without churn/retention context

## Weekly Metrics Review Template

**For MVP/early stage:**

1. **Growth**
   - New users this week
   - Activation rate trend
   - D7 retention by cohort

2. **Engagement**
   - WAU/MAU ratio
   - Time spent / actions per user
   - Feature usage breakdown

3. **Revenue**
   - New MRR
   - Churn MRR
   - ARPU trend

4. **Qualitative**
   - User interviews completed
   - Top feature requests
   - Main churn reasons

5. **Decision**
   - What we learned
   - What we're testing next week
   - What we're stopping

## When Metrics Conflict

**Example:** High signups, low activation
→ Fix: Onboarding flow, value prop clarity

**Example:** Good retention, no growth
→ Fix: Distribution strategy, not product

**Example:** Growth + churn both high
→ Fix: Wrong target audience or unmet expectation

**Example:** Good engagement, won't pay
→ Fix: Pricing too high OR wrong monetization model OR targeting wrong segment

## Metric Calculation Scripts

Use provided scripts for quick calculation:
- `unit_economics.py` - LTV, CAC, payback period
- `market_sizer.py` - TAM/SAM/SOM
- `cohort_retention.py` - Retention curves (if you provide data)

## Red Flags in Metrics

🚨 **Kill signals:**
- Flat or declining engagement after 3 months
- Retention curve doesn't flatten (keeps dropping)
- LTV:CAC < 1:1 with no path to improvement
- Churn accelerating despite product improvements

⚠️ **Warning signals:**
- Growth slowing without intentional focus shift
- CAC rising faster than LTV
- Lengthening sales cycles
- Increasing support burden per user

✅ **Green lights:**
- Organic growth emerging
- Retention curves flattening
- Users self-organizing (communities forming)
- Expansion revenue > churn
- Decreasing support tickets per user over time

```

### references/yc-playbook.md

```markdown
# Y Combinator Startup Playbook

Distilled principles from YC partners, essays, and startup school.

## Core Philosophy

**"Make something people want"** - Paul Graham

The only thing that matters is building something a small number of users love, not something a large number of users like.

## Idea Selection

### Good Idea Characteristics:
1. **You want it yourself** (founder-market fit)
2. **You can build MVP quickly** (<2 weeks ideal)
3. **Few but desperate users** (not many meh users)
4. **Recently became possible** (timing)
5. **Proximate to existing behavior** (low adoption friction)

### Red Flags:
- "This would be cool" (not a burning problem)
- Requires behavior change to work
- "Everyone could use this" (too broad = no one cares urgently)
- "We'll figure out monetization later" (business model unclear)
- Solving a problem you don't have

### The Mom Test:
Don't ask: "Would you use this?"
Ask: "How do you currently solve X? How much time/money do you spend on it?"

## MVP Principles

**Launch in days/weeks, not months.**

### What to Include:
- One core feature that delivers value
- Way to take payment (even if manual)
- Minimal viable quality (can be embarrassingly simple)

### What to Exclude:
- Everything else
- Polish and perfection
- Scalability concerns (for now)
- Features users "might want"

**"Do things that don't scale"** - Paul Graham

Manual everything initially:
- Onboard users personally
- Do customer support via text/DM
- Manually trigger processes
- Write code that only works for first 10 users

Why: Learn what users actually need before automating.

## Growth Pre-PMF

**Talk to users. Every. Single. Day.**

### User Interview Cadence:
- Week 1-4: 5+ interviews per week
- Month 2-6: 3+ interviews per week
- Always: Respond to every piece of feedback

### Questions to Ask:
1. "What were you doing right before using our product?"
2. "What would you do if our product disappeared?"
3. "What almost stopped you from signing up?"
4. "When do you use it? Why then?"
5. "Have you recommended it? To whom? What did you say?"

### Distribution Before Product-Market Fit:

**Do not:**
- Build growth team
- Run paid ads
- Hire salespeople
- Optimize funnels

**Do:**
- Manually recruit first 100 users
- Go where your users are (communities, events, DMs)
- Get users one-by-one
- Focus on retention, not acquisition

## Product-Market Fit Detection

**"You'll know when you have it"** - Marc Andreessen

### Strong Signals:
- Organic word-of-mouth happening
- Users get upset when product is down
- Usage becoming habitual (weekly+)
- Pulling product would disappoint segment
- Hiring can't keep up with inbound demand

### False Signals:
- Press coverage
- Award nominations
- User growth (without retention/engagement)
- Investor interest
- Revenue (if churn is high)

### The "Would you be very disappointed" test:
Survey users: "How would you feel if you could no longer use this product?"
- >40% "very disappointed" = PMF exists
- 25-40% = on the path
- <25% = not there yet

## Common Founder Mistakes

### 1. Building Too Long Before Launching
**Fix:** Launch embarrassingly early. Get feedback day 1.

### 2. Not Talking to Users
**Fix:** Set daily calendar reminder. 30min user calls.

### 3. Focusing on Wrong Metrics
**Fix:** Retention > acquisition. Revenue > traffic.

### 4. Hiring Too Early
**Fix:** Stay small until PMF. Founders should do sales/support.

### 5. Fundraising Before PMF
**Fix:** Raise only if needed. Traction > pitch deck.

### 6. Building for Imaginary Users
**Fix:** Design for specific person you've talked to.

### 7. Ignoring Unit Economics
**Fix:** Calculate LTV:CAC from first paid user.

### 8. Death by 1000 Features
**Fix:** Remove features, don't add. Less surface area = faster iteration.

## Pivoting Guidance

**When to pivot:**
- No organic growth after 3-6 months of real trying
- Talking to users reveals they don't have the problem
- You've stopped using the product yourself
- Team has better idea they believe in more

**How to pivot:**
- Keep talking to same users (insight remains)
- Pivot to adjacent problem in same space
- Test new hypothesis fast (days not weeks)
- Don't throw away code/learnings unnecessarily

**Pivot types:**
1. Customer segment (same product, different buyer)
2. Problem (different pain point for same customer)
3. Solution (different approach to same problem)
4. Business model (same product, different monetization)

## Focus Ruthlessly

**"Startups die from doing too many things, not too few"**

### The One Thing Exercise:
Each week, what is THE ONE THING that moves needle?
- If blocked, what's preventing it?
- Everything else is distraction until this is solved

### Time Allocation (Pre-PMF):
- 60%: Building core product
- 30%: Talking to users
- 10%: Everything else (fundraising, press, admin)

### Say No To:
- Conferences (unless users are there)
- Press opportunities (vanity, no users)
- Enterprise sales before SMB works
- Features requested by non-customers
- Optimization before core workflow works
- Building for "what if we get big" scenarios

## Iteration Speed

**Speed is your only advantage vs incumbents.**

### Weekly Cycle:
- Monday: What are we shipping this week?
- Wednesday: Mid-week check-in
- Friday: Ship + user feedback review

### Deployment Cadence:
- Daily deploys minimum (after basic testing)
- Break things, fix fast
- Perfect is the enemy of shipped

### Decision Making:
- Reversible decisions: Make them fast (most decisions)
- Irreversible decisions: Think more, but still decide quickly
- "Let's discuss next week" = death by committee

## Team & Culture

### Early Team Principles:
- Cofounder > solo (ideally technical + business)
- Keep team small (<5 people pre-PMF)
- Everyone talks to users
- Everyone ships code or equivalent
- Avoid remote if possible (pre-PMF communication is critical)

### Role of Founders:
1. **CEO:** Vision, fundraising, key hires, culture
2. **CTO/Technical cofounder:** Build product, technical decisions
3. **(Optional) Sales/Growth cofounder:** Customer acquisition, partnerships

**Both founders should be involved in product and users.**

### Equity Splits:
- Cofounder split: Equal or near-equal (40-50% each)
- Early employees: 0.5-2% (based on timing and role)
- Advisors: 0.1-0.5% (over 2-4 years)

**Vesting:** 4 years, 1 year cliff, for everyone including founders

## Fundraising Guidance

### When to Raise:
- Need cash to survive next 18-24 months
- Traction exists (growth, revenue, or strong engagement)
- Can articulate clear use of funds

### When NOT to Raise:
- No traction yet (build more first)
- Haven't launched (launch first)
- "Everyone else is raising" (wrong reason)
- To pay yourself comfortable salary (stay lean)

### Seed Round (2025):
- Typical: $500k - $2M
- Valuation: $5M - $15M (highly variable)
- Dilution: 10-20% of company
- Runway: 18-24 months

### Fundraising Process:
1. Build deck (10-15 slides max)
2. Get warm intros to target investors
3. Parallel process (meet 20-30 investors in 2-3 weeks)
4. Create urgency with rolling close
5. Close and get back to building

**Fundraising takes 4-6 weeks of founder time. Minimize this.**

## Pricing Strategy

**Most founders underprice by 2-5x.**

### Principles:
- Charge from day 1 (even beta users)
- Value-based pricing, not cost-plus
- Price on ROI delivered, not hours worked
- Higher price = better customers (less support, faster decisions)

### Price Testing:
- Start higher than comfortable
- Easiest to discount than raise prices later
- If no one complains about price, you're too cheap
- Grandfather existing users when raising prices

### B2B SaaS Guideline:
- Start: $50-200/mo
- If solving urgent problem: 2-5x that
- Enterprise: $1000+/mo (but add manual sales process)

## Key Metrics to Track

### Pre-PMF:
- Weekly active users (WAU)
- Retention (D1, D7, D30)
- Activation rate (signup → value)
- Qualitative feedback themes

### Post-PMF:
- MRR growth rate
- CAC by channel
- LTV:CAC ratio
- Churn rate (gross and net)
- NPS score

## Mental Models

### 1. "Make something people want" (not what you think they want)
### 2. "Do things that don't scale" (initially)
### 3. "Launch fast and iterate" (not build in secret)
### 4. "Focus on retention, not acquisition" (pre-PMF)
### 5. "Talk to users" (constantly)
### 6. "Move fast, don't optimize early" (speed > perfection)
### 7. "One thing at a time" (ruthless prioritization)

## Reading List

**Essential essays:**
1. "Do Things That Don't Scale" - Paul Graham
2. "How to Get Startup Ideas" - Paul Graham  
3. "The Only Thing That Matters" - Marc Andreessen
4. "The Pmarca Guide to Startups" - Marc Andreessen
5. "Startup = Growth" - Paul Graham

**YC Resources:**
- YC Startup School (free video courses)
- YC Library (essays and advice)
- How to Start a Startup (Stanford course)

## Execution Checklist

**Week 1:**
- [ ] Launch MVP (even if embarrassing)
- [ ] Get first 3 users (manually recruited)
- [ ] Set up payment collection
- [ ] Start user interview cadence

**Month 1:**
- [ ] 20+ user conversations
- [ ] First paid customer
- [ ] Core activation flow working
- [ ] Measure D1/D7 retention

**Month 3:**
- [ ] 50+ total users (ideally 10+ paying)
- [ ] Retention curves flattening
- [ ] NPS survey completed
- [ ] Unit economics calculated
- [ ] Decision: iterate / pivot / kill

**Month 6:**
- [ ] Clear signal of PMF or pivot
- [ ] Revenue trajectory visible
- [ ] LTV:CAC path to profitability
- [ ] Repeatable acquisition channel identified

```