| name | sdlc-product-growth |
| description | Product-led growth (PLG), developer-led growth, growth loops, activation funnels, A/B testing, SaaS metrics (MRR/ARR/LTV/CAC/NRR), unit economics, pricing strategy, monetization, onboarding optimization, feature gating, competitive analysis, growth hacking, referral programs, paywall design. |
| version | 6.0.0-moderate |
| author | Dinoudon |
| license | MIT |
| platforms | ["linux","macos","windows"] |
| metadata | {"hermes":{"tags":["sdlc","product-growth","plg","growth-engineering","saas-metrics","pricing","monetization","experimentation","ab-testing","funnels","activation","retention","unit-economics","developer-led-growth"],"related_skills":["sdlc-prd-to-production","sdlc-requirements-engineering","sdlc-testing-qa","sdlc-developer-relations","sdlc-gtm-strategy","sdlc-finance-ops"]}} |
Product Growth Engineering
Product-led growth, growth loops, experimentation, SaaS metrics, pricing strategy, and monetization. How unicorn companies drive revenue from product.
When to Use
Trigger when user:
- Designs pricing, plans tiers, or evaluates monetization models
- Asks about growth hacking, viral loops, or referral programs
- Needs SaaS metrics (MRR, ARR, LTV, CAC, NRR, churn)
- Wants A/B testing or experimentation setup
- Designs onboarding, activation funnels, or paywalls
- Asks "how do companies like Stripe/Slack/Notion grow?"
- Plans feature gating or freemium strategy
- Needs unit economics or cohort analysis
Step 1: Growth Philosophy — Product-Led vs Sales-Led
The Spectrum
PRODUCT-LED ◄─────────────────────────────► SALES-LED
(Free signup, (Hybrid: (Demos,
self-serve) free trial + contracts,
sales assist) procurement)
Examples:
PLG: Notion, Figma, Slack, Zoom, Dropbox, Canva
Hybrid: Stripe, Datadog, Confluent, MongoDB
Sales: Salesforce, Oracle, Workday, ServiceNow
Developer-Led Growth (DLG)
Source: Stripe, Twilio, SendGrid
Developer-led growth is a subset of PLG where developers are the primary adopters. The developer discovers, evaluates, integrates, and champions the product internally.
Developer discovers API → Reads docs → Gets API key → Builds integration
→ Shows team → Team adopts → Company buys enterprise plan
Key principles (from Stripe):
- 7 lines of code to first value — minimize time-to-integration
- Docs are the product — API reference is the landing page
- Sandboxes for everyone — test without talking to sales
- SDKs in every language — meet developers where they are
- Transparent pricing — no "contact sales" for basic features
Product-Led Growth Flywheel
Source: OpenView Partners
┌─────────────┐
│ EVALUATE │
│ (Free trial │
│ or freemium)│
└──────┬──────┘
│
┌───────────────┼───────────────┐
▼ │
┌─────────────┐ ┌──────┴──────┐
│ ACTIVATE │ │ EXPAND │
│ (Time-to- │ │ (Upsell, │
│ value <5m) │ │ cross-sell) │
└──────┬──────┘ └──────┬──────┘
│ │
└───────────────┬───────────────┘
▼
┌─────────────┐
│ ADVOCATE │
│ (Referral, │
│ word-of- │
│ mouth) │
└─────────────┘
Step 2: SaaS Metrics Framework
Pirate Metrics (AARRR)
Source: Dave McClure, 500 Startups
| Stage | Metric | Definition | Target |
|---|
| Acquisition | Visitor → Signup rate | % of visitors who create account | 5-15% |
| Activation | Time-to-value | Time from signup to first success | <5 min |
| Retention | D1/D7/D30 retention | % returning after N days | D1: 40%+, D7: 20%+, D30: 10%+ |
| Revenue | MRR, ARPU | Monthly recurring revenue per user | Varies |
| Referral | Viral coefficient (k-factor) | Invites sent × conversion rate | k > 1 = viral |
Core SaaS Metrics
MRR = Σ (paying customers × monthly subscription)
ARR = MRR × 12
ARPU = MRR / paying customers
NRR = (MRR start + expansion - contraction - churn) / MRR start × 100
LTV = ARPU × (1 / monthly churn rate)
CAC = Total sales & marketing spend / new customers acquired
LTV:CAC ratio = LTV / CAC (target: >3:1)
CAC Payback = CAC / (ARPU × gross margin) (target: <18 months)
Churn Rate = Customers lost / Total customers at start
Net Revenue Retention = (start MRR + expansion - contraction - churn) / start MRR
Gross Margin = (Revenue - COGS) / Revenue (target: >70% for SaaS)
Healthy SaaS Benchmarks
Source: OpenView Partners, Bessemer Venture Partners
| Metric | Good | Great | Elite |
|---|
| NRR | 100-110% | 110-130% | >130% |
| LTV:CAC | 3:1 | 5:1 | >7:1 |
| CAC Payback | 18 months | 12 months | <6 months |
| Gross Margin | 70% | 80% | >85% |
| Logo Churn (annual) | <10% | <5% | <3% |
| Rule of 40 | 40% | 50% | >60% |
Rule of 40: Growth rate (%) + Profit margin (%) should exceed 40%.
Cohort Analysis Template
Cohort: January 2026 signups (1000 users)
Month 0: 1000 active (100%)
Month 1: 600 active (60%) ← D30 retention
Month 2: 450 active (45%)
Month 3: 380 active (38%)
Month 6: 300 active (30%) ← Long-term retention
Month 12: 250 active (25%) ← Plateau
Revenue cohort:
Month 0: $5,000 MRR
Month 3: $7,200 MRR ← expansion revenue kicks in
Month 6: $9,800 MRR ← upgrades + seat expansion
Month 12: $15,000 MRR ← enterprise deals close
Step 3: Pricing Strategy
Pricing Models Compared
| Model | How It Works | Best For | Examples |
|---|
| Freemium | Free tier + paid upgrades | PLG, viral products | Slack, Notion, Figma |
| Free Trial | Time-limited full access | Complex products | Salesforce, HubSpot |
| Usage-Based | Pay per API call/compute/GB | APIs, infrastructure | Stripe, AWS, Twilio |
| Seat-Based | Per-user per-month | Collaboration tools | Atlassian, GitHub |
| Hybrid | Base + usage overage | Mixed workloads | Datadog, Snowflake |
| Tiered | Good/Better/Best packages | Multiple segments | Zoom, Mailchimp |
Stripe's Pricing Model (Case Study)
Starter: 2.9% + 30¢ per transaction (no monthly fee)
Scale: 2.9% + 30¢ + volume discounts
Enterprise: Custom pricing + dedicated support
Key insight: Pricing aligns with customer success.
When customer processes more, Stripe earns more.
No upfront cost → zero friction to start.
Pricing Page Template
┌─────────────────────────────────────────────────────────┐
│ Pricing Plans │
├──────────────┬──────────────┬──────────────┬────────────┤
│ Free │ Pro │ Business │ Enterprise │
│ $0/mo │ $29/mo │ $99/mo │ Custom │
├──────────────┼──────────────┼──────────────┼────────────┤
│ 3 users │ 10 users │ Unlimited │ Unlimited │
│ 1 project │ 10 projects │ Unlimited │ Unlimited │
│ Community │ Email support│ Priority │ Dedicated │
│ Basic feat. │ All features │ Advanced │ Custom │
│ │ │ SSO/SAML │ SLA/On-prem│
├──────────────┼──────────────┼──────────────┼────────────┤
│ [Get Started]│ [Start Trial]│ [Start Trial]│ [Contact] │
└──────────────┴──────────────┴──────────────┴────────────┘
Feature Gating Framework
Tier 1 (Free): Core functionality, single user, limited volume
Tier 2 (Pro): Team features, integrations, higher limits
Tier 3 (Business): Admin controls, SSO, audit logs, compliance
Tier 4 (Enterprise): Custom, SLA, dedicated infra, white-glove
Gating rules:
- NEVER gate core value prop (that's the hook)
- Gate collaboration (teams need to pay)
- Gate compliance (enterprises expect to pay)
- Gate scale (volume needs to pay)
- Gate support (premium support = premium price)
Step 4: Growth Loops & Viral Mechanics
Growth Loops vs Funnels
Funnels are linear (acquire → activate → retain). Growth loops are circular — output of one cycle becomes input of next.
Examples of Growth Loops
Content Loop (Pinterest, Stack Overflow):
User creates content → Content indexed by SEO → New user discovers content
→ New user creates content → Loop repeats
Viral Loop (Slack, Dropbox):
User invites teammate → Teammate signs up → Teammate invites others
→ Network effect increases value → More invites
Collaboration Loop (Figma, Notion):
User shares doc → Recipient opens it → Recipient edits → Shared with more people
→ More people see value → More signups
Payment Loop (Stripe, Square):
Merchant integrates Stripe → Customer pays → Merchant sees revenue
→ Merchant tells other merchants → More integrations
Viral Coefficient (k-factor)
k = invites_per_user × conversion_rate_of_invites
k > 1.0 = exponential growth (viral)
k = 0.5-1.0 = significant boost to organic growth
k < 0.5 = limited viral effect
Example:
- Average user sends 3 invites
- 20% of invites convert to signups
- k = 3 × 0.20 = 0.6 (good but not viral)
To make viral:
- Increase invites (better sharing UX, incentives)
- Increase conversion (better invite content, social proof)
Referral Program Design
Components:
1. Incentive: What does referrer get? (credits, features, cash)
2. Trigger: When to prompt? (after success moment, not onboarding)
3. Friction: How easy? (one-click share, pre-filled message)
4. Tracking: Attribution (referral codes, UTM, invite links)
5. Reward timing: Immediate or after referee activates?
Examples:
Dropbox: 500MB extra storage per referral (both sides)
Slack: Credit toward bill (referrer only)
Stripe: No formal referral (word-of-mouth from DX)
PayPal: $10 cash per referral (both sides) — early growth hack
Step 5: Activation & Onboarding
Time-to-Value (TTV) Framework
Goal: Get user to first success moment as fast as possible.
TTV Components:
1. Signup friction (email+password vs SSO vs magic link)
2. First-run experience (empty state, guided tour)
3. Aha moment (when user first sees value)
4. Setup completion (profile, integrations, first action)
Aha Moments (by company):
Slack: 2,000 messages sent in a workspace
Dropbox: File saved in Dropbox folder on 2+ devices
Facebook: 7 friends in 10 days
Twitter: 30 followers
Zoom: First successful video call
Stripe: First test payment in sandbox
Onboarding Patterns
1. Checklist: Show progress (5/7 steps complete)
2. Empty states: Guide to first action instead of blank page
3. Progressive disclosure: Don't show everything at once
4. Templates: Pre-built starting points
5. Tooltips: Contextual help at point of need
6. Interactive tutorial: Walk through core flow
7. Milestone emails: Triggered by behavior, not time
Activation Funnel Template
Signup (100%)
→ Email verified (70%)
→ Profile completed (50%)
→ First action (core feature used) (35%)
→ Second session (D1 retention) (25%)
→ Teammate invited (15%)
→ Converted to paid (5%)
Step 6: Experimentation & A/B Testing
Experiment Design
1. Hypothesis: "Changing CTA from 'Sign Up' to 'Start Free Trial'
will increase signup rate by 10%"
2. Metric: Primary = signup conversion. Secondary = activation rate.
3. Sample size: Use power analysis (α=0.05, β=0.2, MDE=10%)
4. Duration: Minimum 2 full business weeks (avoid novelty effect)
5. Variants: Control (current) vs Treatment (new CTA)
6. Randomization: User-level (not session-level) to avoid contamination
7. Analysis: Intention-to-treat, guard against Simpson's paradox
Experimentation Platforms
| Platform | Type | Best For |
|---|
| LaunchDarkly | Feature flags + experiments | Engineering-led |
| Optimizely | A/B testing | Marketing-led |
| Statsig | Feature gates + analytics | Product-led |
| GrowthBook | Open-source A/B | Budget-conscious |
| Amplitude Experiment | Analytics + testing | Data teams |
| PostHog | Open-source analytics | Self-hosted |
Common A/B Testing Pitfalls
1. Peeking: Checking results before reaching sample size
2. Multiple testing: Running 20 variants, one "wins" by chance
3. Novelty effect: Users engage with change briefly, then revert
4. Sample ratio mismatch: 50/50 split becomes 48/52
5. Survivorship bias: Only measuring users who didn't churn
6. Network effects: Users in treatment affect control users
7. Segment dilution: Overall no effect, but huge effect for subset
Step 7: Competitive Analysis
Competitive Intelligence Framework
1. Feature comparison matrix
2. Pricing comparison
3. Market positioning map
4. SWOT analysis per competitor
5. Customer win/loss analysis
6. Technical architecture comparison
7. Developer experience comparison (docs, SDKs, sandbox)
Positioning Map Template
ENTERPRISE
│
Salesforce │ ServiceNow
│
────────────────────┼────────────────────
SELF-SERVE │ SALES-ASSISTED
│
Notion │ Stripe
Slack │ Datadog
│
STARTUP/SMB
Step 8: Unicorn Growth Playbooks
Stripe: Developer-Led Growth
- API-first: 7 lines of code to first payment
- Docs-as-product: Best-in-class API documentation
- Sandbox: Full test environment, no signup required
- Transparent pricing: No hidden fees, no sales calls
- Expand: Start with payments → billing → connect → radar → atlas
- Result: $107B valuation, processes $1T+/year
Slack: Viral Team Adoption
- Freemium with generous limits (10K messages)
- Bottom-up: Individual → team → company
- Integrations: 2400+ apps create switching costs
- Fun UX: Custom emoji, bots, playful design
- Growth loop: User invites → team grows → needs paid plan
- Result: Acquired by Salesforce for $27.7B
Notion: PLG + Community
- Templates: Community-created templates drive discovery
- Power users become advocates (YouTube, Twitter)
- Flexible: Notes → docs → wiki → database → project management
- Education: Notion Academy, certification program
- Result: $10B valuation
Figma: Collaboration as Growth
- Browser-based: Zero install, instant sharing
- Real-time collab: Like Google Docs for design
- Sharing loop: Designer shares link → stakeholder views → signs up
- Community: Figma Community for plugins and templates
- Result: Acquired by Adobe for $20B
Zoom: Frictionless Experience
- One-click join: No account needed to join a meeting
- Reliability: "It just works" — superior video quality
- Free tier: 40-minute meetings (generous enough to hook)
- Viral: Every meeting invite is a product demo
- Result: IPO, peak $150B market cap
Step 9: Growth Engineering (Technical Implementation)
Event Tracking Architecture
Client → Analytics SDK → Event Pipeline → Data Warehouse → BI Tool
Event Schema:
{
"event": "feature_used",
"user_id": "usr_123",
"timestamp": "2026-06-16T10:30:00Z",
"properties": {
"feature": "export_csv",
"plan": "pro",
"team_size": 5,
"source": "onboarding_checklist"
},
"context": {
"page": "/dashboard",
"referrer": "/onboarding",
"device": "desktop"
}
}
Analytics Stack Options
| Layer | Tool | Type | Best For |
|---|
| Collection | Segment | SaaS | Multi-destination routing |
| Collection | RudderStack | Open-source | Self-hosted, cost control |
| Collection | PostHog | Open-source | All-in-one analytics+flags |
| Warehouse | BigQuery | Managed | Large-scale analytics |
| Warehouse | Snowflake | Managed | Enterprise data platform |
| Warehouse | ClickHouse | Open-source | Real-time analytics |
| BI | Metabase | Open-source | Self-serve dashboards |
| BI | Looker | Enterprise | Governed metrics layer |
| BI | Hex | Collaborative | Data team notebooks |
Key Growth Queries (SQL)
SELECT
DATE_TRUNC('week', u.created_at) AS cohort_week,
COUNT(DISTINCT u.id) AS signups,
COUNT(DISTINCT CASE WHEN a.event = 'key_action'
AND a.created_at < u.created_at + INTERVAL '7 days' THEN u.id END) AS activated,
ROUND(activated * 100.0 / signups, 1) AS activation_rate
FROM users u
LEFT JOIN events a ON u.id = a.user_id
GROUP BY 1 ORDER BY 1;
SELECT
DATE_TRUNC('month', u.created_at) AS cohort,
COUNT(DISTINCT u.id) AS users,
COUNT(DISTINCT CASE WHEN e.created_at::date = (u.created_at + 1)::date THEN u.id END) AS d1,
COUNT(DISTINCT CASE WHEN e.created_at::date = (u.created_at + 7)::date THEN u.id END) AS d7,
COUNT(DISTINCT CASE WHEN e.created_at::date = (u.created_at + 30)::date THEN u.id END) AS d30
FROM users u
LEFT JOIN events e ON u.id = e.user_id
GROUP BY 1 ORDER BY 1;
SELECT
DATE_TRUNC('month', p.started_at) AS cohort_month,
SUM(p.mrr_at_start) AS starting_mrr,
SUM(p.mrr_current) AS current_mrr,
ROUND(SUM(p.mrr_current) * 100.0 / SUM(p.mrr_at_start), 1) AS nrr_pct
FROM subscriptions p
WHERE p.started_at >= NOW() - INTERVAL '12 months'
GROUP BY 1 ORDER BY 1;
Feature Flagging for Growth
Use feature flags for:
1. Gradual rollouts (1% → 10% → 50% → 100%)
2. A/B testing (50/50 split, measure impact)
3. Kill switches (instantly disable broken features)
4. Segment targeting (beta users, enterprise, specific cohorts)
Tools: LaunchDarkly, Unleash, GrowthBook, PostHog, Statsig
Example:
flag: new_onboarding_flow
rollout: 20% of new signups
metric: activation_rate (key_action within 7 days)
guardrail: signup_completion_rate must not drop >5%
duration: 14 days minimum
decision: ship if activation +10% with p < 0.05
Step 10: Retention & Engagement Deep Dive
Retention Framework
RETENTION = FUNCTION(Activation, Engagement, Resurrection)
Activation (Day 0-7):
- Get user to first value moment
- Remove all friction from signup → first success
- Personalize based on use case / persona
Engagement (Day 7-90):
- Build habit loops (trigger → action → reward)
- Progressive feature discovery
- Social features (collaboration, sharing)
- Content and community
Resurrection (Day 90+):
- Win-back campaigns (email, in-app)
- "What's new" notifications for churned users
- Surveys for churned users (why did you leave?)
- Special offers or extended trials
Engagement Scoring
Engagement Score = weighted sum of key actions
Actions and weights:
- Login (1x)
- Core feature used (5x)
- Collaboration action (3x)
- Settings/config changed (2x)
- Integration connected (4x)
- Teammate invited (6x)
Segments:
Highly engaged: score > 80 (power users, upsell targets)
Engaged: score 40-80 (healthy, maintain)
At risk: score 10-40 (intervention needed)
Dormant: score < 10 (win-back campaign)
Churn Prediction Signals
Leading indicators of churn (2-4 weeks before):
1. Login frequency drops >50%
2. Core feature usage stops
3. Support tickets spike (frustration)
4. Team admin removes integrations
5. Billing page visited (price shopping)
6. Export/download activity (data portability)
7. Cancellation page visited
8. NPS score drops below 6
Interventions:
- In-app nudge: "Need help with [feature]?"
- Email: Personal outreach from CSM
- Offer: Discount, extended trial, plan downgrade option
- Product: Simplify workflow, offer concierge onboarding
Step 11: Growth Team Structure
Growth Team Roles
Growth Team (5-8 people):
├── Growth Lead (PM or Engineering Manager)
├── Growth Engineer (full-stack, experimentation)
├── Data Analyst (metrics, experiments, insights)
├── Product Designer (onboarding, activation UX)
├── Marketing Ops (email, campaigns, automation)
└── Content Strategist (in-app messaging, copy)
Steering:
- Weekly growth review (metrics dashboard)
- Bi-weekly experiment planning
- Monthly growth retrospective
Growth Team Charter
Mission: Increase the rate at which users discover and experience core value.
Scope:
- Signup flow optimization
- Onboarding and activation
- Feature adoption and engagement
- Pricing and packaging experiments
- Viral and referral mechanics
NOT in scope:
- Core product features (product team)
- Enterprise sales (sales team)
- Brand marketing (marketing team)
- Infrastructure (platform team)
Growth Operating Cadence
Monday: Experiment review (last week's results)
Tuesday: Experiment planning (this week's experiments)
Wednesday: Implementation (build experiments)
Thursday: Analysis (review running experiments)
Friday: Documentation (record learnings, update playbook)
Monthly: Growth review with leadership
Quarterly: Strategy review (what bets to place next)
Step 12: Metrics Dashboard Templates
Executive Growth Dashboard
┌─────────────────────────────────────────────────────────┐
│ GROWTH DASHBOARD — Week of June 16, 2026 │
├────────────────┬────────────────┬───────────────────────┤
│ MRR: $245K │ ARR: $2.94M │ NRR: 114% │
│ ↑8% MoM │ ↑32% YoY │ ↑2pts QoQ │
├────────────────┼────────────────┼───────────────────────┤
│ New MRR: $18K │ Expansion: $5K│ Churn: -$3K │
│ ↑12% WoW │ ↑8% WoW │ ↓2pts from last wk │
├────────────────┴────────────────┴───────────────────────┤
│ Activation Funnel (this week): │
│ Signup (850) → Verified (595, 70%) → Activated (298, │
│ 35%) → Invited Team (127, 15%) → Converted (43, 5%) │
├─────────────────────────────────────────────────────────┤
│ Experiments Running: 5 | Completed: 3 | Won: 1 │
│ Top experiment: +18% activation (new onboarding flow) │
└─────────────────────────────────────────────────────────┘
Retention Cohort Heatmap
Month 0 Month 1 Month 2 Month 3 Month 6 Month 12
Jan '26 100% 62% 48% 42% 35% 28%
Feb '26 100% 65% 51% 44% — —
Mar '26 100% 68% 54% — — —
Apr '26 100% 70% — — — —
Trend: D1 retention improving (62% → 70%) ← onboarding changes working
Step 13: Growth Playbook Templates
Experiment Backlog Template
| ID | Hypothesis | Metric | MDE | Sample | Duration | Status |
|---|
| EXP-001 | New onboarding increases activation | D7 activation | 10% | 5K users | 14d | Running |
| EXP-002 | Social proof on pricing page increases conversion | Signup→paid | 15% | 3K visitors | 14d | Planned |
| EXP-003 | In-app referral prompt increases invites | K-factor | 20% | 2K users | 21d | Planned |
| EXP-004 | Usage-based pricing reduces churn | Monthly churn | 2pts | 1K subs | 30d | Backlog |
Growth Experiment Template
## Experiment: [Name]
### Hypothesis
If we [change], then [metric] will [improve/decrease] by [amount]
because [reasoning].
### Design
- Variant A (control): [current state]
- Variant B (treatment): [proposed change]
- Split: 50/50, user-level randomization
- Duration: [X days minimum]
- Sample size: [N per variant]
### Primary Metric
[Name] — [definition] — [how measured]
### Guardrail Metrics
- [Metric that must not degrade]
- [Metric that must not degrade]
### Results
- Variant A: [value] (n=[N])
- Variant B: [value] (n=[N])
- Lift: [X%] (p-value: [Y])
- Decision: [Ship / Iterate / Kill]
### Learnings
[What did we learn? What's next?]
Pitfalls
- Optimizing for vanity metrics — Page views and signups don't equal revenue. Track activation and retention.
- Pricing too low — Underpricing signals low value. Raise prices until you get pushback.
- Premature scaling — Don't invest in growth before product-market fit. PMF signal: organic retention > 40%.
- Ignoring churn — Acquiring 100 users/month while losing 80 is a leaky bucket. Fix retention first.
- A/B testing without traffic — Need ~10K visitors/week per variant for statistical significance.
- Copy-pasting growth tactics — What works for Slack won't work for enterprise. Adapt to your market.
- Free tier too generous — If free users never need to upgrade, you have a free product, not freemium.
- Free tier too stingy — Users can't experience value → never convert. Find the balance.
- Ignoring expansion revenue — NRR > 100% means existing customers grow faster than churn. Critical for SaaS.
- Sales-led when should be PLG — Developers don't want sales calls. If your users are devs, go PLG.
Step 14: Growth Accounting & North Star Metric
Growth Accounting Framework
Growth Accounting decomposes user base changes:
Net New Users = New Users + Resurrected Users - Churned Users
Weekly example:
Start of week: 10,000 users
New: +500 (signups)
Resurrected: +100 (returned after 30+ days)
Churned: -200 (inactive 30+ days)
End of week: 10,400 users
Net growth: +4% (healthy)
Growth Rate = (End - Start) / Start × 100
Sustainable growth: growth rate stays constant or increases
Unsustainable: growth rate declining (means churn accelerating)
North Star Metric Selection
The North Star Metric (NSM) is the single metric that best captures
the core value your product delivers to customers.
Selection criteria:
1. Measures value delivered to customers
2. Correlates with revenue growth
3. Reflects engagement quality (not vanity)
4. Actionable by the team
5. Leading indicator (not lagging)
Examples by company type:
Collaboration (Slack): Weekly active teams sending 2000+ messages
Marketplace (Airbnb): Nights booked
SaaS (Datadog): Monthly active hosts monitored
API (Stripe): Weekly active merchants processing payments
Social (Facebook): Daily active users
Developer tool (GitHub): Weekly active developers committing code
Anti-examples (bad NSMs):
❌ Total registered users (vanity, doesn't reflect engagement)
❌ Revenue (lagging, not actionable by product team)
❌ Page views (doesn't measure value)
❌ App downloads (doesn't measure retention)
Growth Accounting SQL
WITH weekly_users AS (
SELECT
DATE_TRUNC('week', created_at) AS cohort_week,
user_id,
MIN(created_at) AS first_seen,
MAX(created_at) AS last_seen
FROM events
GROUP BY 1, 2
),
user_status AS (
SELECT
this_week.cohort_week,
COUNT(DISTINCT CASE WHEN this_week.first_seen >= this_week.cohort_week
THEN this_week.user_id END) AS new_users,
COUNT(DISTINCT CASE WHEN this_week.first_seen < this_week.cohort_week
AND prev_week.user_id IS NOT NULL
THEN this_week.user_id END) AS retained_users,
COUNT(DISTINCT CASE WHEN this_week.first_seen < this_week.cohort_week
AND prev_week.user_id IS NULL
THEN this_week.user_id END) AS resurrected_users,
COUNT(DISTINCT CASE WHEN prev_week.user_id IS NOT NULL
AND this_week.user_id IS NULL
THEN prev_week.user_id END) AS churned_users
FROM weekly_users this_week
LEFT JOIN weekly_users prev_week
ON this_week.user_id = prev_week.user_id
AND prev_week.cohort_week = this_week.cohort_week - INTERVAL '1 week'
GROUP BY 1
)
SELECT
cohort_week,
new_users,
retained_users,
resurrected_users,
churned_users,
(new_users + resurrected_users - churned_users) AS net_new,
ROUND((new_users + resurrected_users - churned_users) * 100.0 /
NULLIF(retained_users + resurrected_users, 0), 1) AS growth_rate_pct
FROM user_status
ORDER BY cohort_week;
Step 15: Network Effects & Moats
Types of Network Effects
Direct Network Effects (same-side):
More users → more value for each user
Examples: WhatsApp, Telegram, telephone network
Indirect Network Effects (cross-side):
More users on side A → more value for side B
Examples: Uber (riders ↔ drivers), Airbnb (guests ↔ hosts)
Data Network Effects:
More users → more data → better product → more users
Examples: Google Search, Waze, recommendation engines
Protocol Network Effects:
More adopters → stronger standard → harder to switch
Examples: TCP/IP, HTTP, Bitcoin, Ethereum
Moat Framework (Peter Thiel, Zero to One)
1. Network Effects: Product gets better with more users
2. Economies of Scale: Fixed costs spread over more revenue
3. Brand: Trusted name commands premium pricing
4. Switching Costs: Painful to migrate to competitor
5. IP/Patents: Legal protection for innovations
6. Counter-Positioning: Business model competitor can't copy
7. Cornered Resource: Exclusive access to data, talent, distribution
Step 16: International Growth & Localization
Internationalization Checklist
Product:
□ i18n framework (react-intl, vue-i18n, next-intl)
□ String externalization (no hardcoded strings)
□ RTL support (Arabic, Hebrew, Farsi)
□ Date/time formatting (moment.js, date-fns, Intl)
□ Number formatting (currencies, decimals)
□ Address formats by country
□ Phone number validation (libphonenumber)
Pricing:
□ Multi-currency support
□ Purchasing power parity (PPP) pricing
□ Tax calculation by jurisdiction (Stripe Tax, Avalara)
□ Payment methods by region (iDEAL, SEPA, Alipay, UPI)
Marketing:
□ Localized landing pages
□ Country-specific SEO (hreflang tags)
□ Local social media (WeChat, LINE, VKontakte)
□ Regional case studies and testimonials
Support:
□ Multi-language support team
□ Timezone-appropriate support hours
□ Localized help center
□ Regional community forums
PPP Pricing Strategy
Purchasing Power Parity (PPP) adjusts prices by country GDP:
US: $100/month (base price)
UK: £80/month (≈$100, roughly parity)
India: ₹2,000/month (≈$24, 76% discount)
Brazil: R$200/month (≈$40, 60% discount)
Nigeria: ₦15,000/month (≈$18, 82% discount)
Benefits:
- Higher adoption in price-sensitive markets
- Revenue from markets that can't afford US pricing
- Viral growth in emerging markets
- Positive brand perception (accessibility)
Implementation:
- Detect location via IP (MaxMind, IPinfo)
- Show local currency and adjusted price
- Allow manual override (VPN users, expats)
- Re-evaluate annually (PPP data updates)
Step 17: Product-Led Sales (PLG + Sales Hybrid)
PLG-to-Sales Motion
Self-serve journey (PLG):
Signup → Free/Freemium → Activate → Use → Hit limit → Upgrade
Product-qualified lead (PQL) signals:
- Team workspace created (5+ users)
- API calls exceed free tier
- Admin features accessed
- Integration connected
- Export/download activity
- Billing page visited
Sales touchpoints:
1. In-app prompt: "Need help scaling? Talk to our team"
2. PQL scoring: Auto-flag accounts hitting usage thresholds
3. CSM outreach: Personal email from customer success
4. Demo offer: Tailored demo showing enterprise features
5. Trial extension: Enterprise trial with dedicated support
PQL Definition:
Account has:
- 5+ team members
- 100+ API calls/day
- Used 3+ core features
- Been active for 14+ days
→ Auto-route to sales pipeline
PQL Scoring Model
Score = Σ (action × weight)
Actions:
Team member added: +10 per member
Core feature used: +5 per feature
API calls > 100/day: +15
Integration connected: +20
Admin settings changed: +10
Billing page visited: +25
Export/download: +15
SSO/SAML configured: +30
Custom domain set up: +20
Thresholds:
Score 0-30: Self-serve (no sales touch)
Score 31-60: Light touch (in-app prompts, email nurture)
Score 61-100: Sales outreach (SDR email/call)
Score 100+: Enterprise AE assignment (high-value account)
Step 18: Viral Growth Engineering
Viral Loop Architecture
Viral loop = action → expose → invite → activate → repeat
Types:
1. Collaboration viral: User invites teammate to shared workspace
Example: Slack, Notion, Figma, Google Docs
2. Content viral: User creates public content that exposes product
Example: Canva designs, Linktree, Notion templates
3. Value viral: User must share to get value (gaming, social)
Example: Houseparty, Zoom (meeting host invites others)
4. Incentive viral: Referral rewards for both parties
Example: Dropbox (500MB bonus), Uber (ride credits)
Viral coefficient (K):
K = invites_sent × conversion_rate
K > 1: exponential growth (each user brings >1 new user)
K = 0.5-1: healthy amplification (each user brings 0.5-1)
K < 0.5: growth needs paid channels
Viral cycle time:
Time from user signup → first successful invite
Shorter = faster growth
Dropbox: 30 days → optimized to 14 days = 2x growth rate
Referral Program Design
Dual-sided incentive structure:
Referrer gets: $25 credit per successful referral
Referee gets: 20% off first month
Tracking:
- Unique referral link per user
- Cookie duration: 30 days
- Attribution: last-touch (most recent referrer gets credit)
- Fraud detection: same IP, same payment method, disposable email
Anti-fraud measures:
- Max 50 referrals per account
- Referee must complete onboarding (not just signup)
- 30-day hold on credits (prevent churn-and-burn)
- Manual review for accounts with 10+ referrals in 24h
Leaderboard gamification:
- Monthly top referrers get bonus rewards
- Badges for referral milestones (5, 25, 100 referrals)
- Exclusive access to beta features for top referrers
Step 19: Product Analytics Deep Dive
Event Taxonomy
Naming convention: [noun].[verb]
Examples:
user.signed_up
user.invited_team_member
project.created
project.deployed
billing.upgraded
billing.payment_failed
Event properties (context):
user.signed_up:
- signup_method: google | github | email
- referrer: direct | organic | referral | paid
- utm_source: twitter | google | newsletter
- company_size: 1-10 | 11-50 | 51-200 | 200+
- role: developer | designer | pm | exec
Tools:
- Mixpanel: Event-based analytics
- Amplitude: Product analytics + cohorts
- PostHog: Open-source, self-hostable
- Segment: Event routing (collect once, send everywhere)
Funnel Analysis SQL
WITH funnel AS (
SELECT
u.user_id,
u.created_at AS signup_date,
MIN(CASE WHEN e.event_name = 'project.created' THEN e.created_at END) AS first_project,
MIN(CASE WHEN e.event_name = 'project.deployed' THEN e.created_at END) AS first_deploy,
MIN(CASE WHEN e.event_name = 'invite.sent' THEN e.created_at END) AS first_invite
FROM users u
LEFT JOIN events e ON u.user_id = e.user_id
WHERE u.created_at >= '2024-01-01'
GROUP BY 1, 2
)
SELECT
COUNT(*) AS total_signups,
COUNT(first_project) AS created_project,
COUNT(first_deploy) AS deployed,
COUNT(first_invite) AS invited_team,
ROUND(COUNT(first_project) * 100.0 / COUNT(*), 1) AS signup_to_project_pct,
ROUND(COUNT(first_deploy) * 100.0 / COUNT(*), 1) AS signup_to_deploy_pct,
ROUND(COUNT(first_invite) * 100.0 / COUNT(*), 1) AS signup_to_invite_pct
FROM funnel;
Step 20: Pricing Strategy Deep Dive
Pricing Page Anatomy
Above the fold:
- Clear value prop headline
- 3-4 pricing tiers side by side
- Monthly/Annual toggle (show savings)
- Highlighted "Most Popular" tier
Tier structure:
Free: Limited features, usage caps, no support
Pro: Full features, higher limits, email support
Business: Team features, SSO, priority support, SLA
Enterprise: Custom pricing, dedicated CSM, custom SLA
Anchoring psychology:
- Show Enterprise tier first (sets high anchor)
- Highlight Pro as "Most Popular" (social proof)
- Show annual savings prominently (30% off)
- Use charm pricing ($49 not $50)
- Remove $ sign for enterprise (contact sales)
Pricing table CSS framework:
- Responsive grid (4 columns desktop, 1 mobile)
- Feature comparison rows with checkmarks
- Expandable "See all features" section
- Trust badges below (SOC 2, GDPR, uptime SLA)
A/B Testing Pricing Changes
Hypothesis: "Increasing Pro tier from $49 to $59 will decrease
conversion by 5% but increase ARPU by 20%, net positive revenue"
Test setup:
Control: Current pricing ($49/month)
Variant: New pricing ($59/month)
Metric: Revenue per visitor (RPV)
Duration: 2-4 weeks minimum
Sample size: 1000+ conversions per variant
Statistical significance:
- Use Bayesian A/B testing for faster decisions
- Tools: VWO, Optimizely, PostHog Experiments
- Guardrail metrics: signup rate, activation rate, NPS
Rollback plan:
- Grandfather existing users at old price
- 30-day notice for price increases (legal requirement)
- Offer annual lock-in at current price before increase
- Reforge: https://www.reforge.com/blog
- Teresa Torres, Continuous Discovery Habits: https://www.producttalk.org/
- Lenny Rachitsky Newsletter: https://www.lennysnewsletter.com/
- OpenView Partners PLG: https://openviewpartners.com/blog/
- Bessemer Cloud Index: https://www.bvp.com/atlas
- a16z Growth: https://a16z.com/growth/
- Dave McClure Pirate Metrics: https://500.co/
- Stripe engineering: https://stripe.com/blog/engineering
- Slack growth story: https://slack.com/blog
- Notion growth: https://www.notion.so/blog
## Step 21: Experimentation and A/B Testing
### Experiment Design Framework
Hypothesis format:
"If we [change], then [metric] will [direction] by [amount],
because [reasoning]."
Example: "If we add social proof to the pricing page, then
conversion rate will increase by 15%, because seeing other
companies using the product reduces purchase anxiety."
Sample size calculation:
Baseline conversion rate: 3%
Minimum detectable effect (MDE): 15% relative (0.45% absolute)
Statistical significance: 95% (alpha = 0.05)
Statistical power: 80% (beta = 0.20)
Formula: n = (Z_alpha/2 + Z_beta)^2 * (p1*(1-p1) + p2*(1-p2)) / (p1-p2)^2
Where:
Z_alpha/2 = 1.96 (for 95% confidence)
Z_beta = 0.84 (for 80% power)
p1 = 0.03 (baseline)
p2 = 0.0345 (baseline + 15% relative)
n = (1.96 + 0.84)^2 * (0.030.97 + 0.03450.9655) / (0.0045)^2
n = 7.84 * 0.0623 / 0.00002025
n = ~24,000 per variant
At 10,000 visitors/day: Test runs for ~5 days per variant
Tools:
- Optimizely: Enterprise A/B testing
- VWO: Mid-market A/B testing
- PostHog: Open-source, self-hostable
- LaunchDarkly: Feature flags + experiments
- Statsig: Statistical engine, feature gates
### Statistical Analysis
Frequentist approach:
- Null hypothesis (H0): No difference between variants
- Alternative hypothesis (H1): Difference exists
- P-value: Probability of observing result if H0 is true
- Reject H0 if p-value < 0.05 (95% confidence)
Example results:
Control: 3.0% conversion (240/8000)
Variant: 3.5% conversion (280/8000)
P-value: 0.042
Conclusion: Statistically significant (p < 0.05)
Lift: 16.7% relative improvement
Bayesian approach:
- Prior: Belief before experiment
- Posterior: Updated belief after data
- Credible interval: 95% probability range
- Probability of being better: P(variant > control)
Example:
P(variant beats control) = 97.3%
Expected lift: 15.2% (95% CI: 2.1% to 28.3%)
Decision: Ship variant with high confidence
Common pitfalls:
- Peeking at results too early (inflated false positive rate)
- Stopping test when significant (optional stopping problem)
- Multiple comparisons without correction (Bonferroni)
- Novelty effect (new design always wins initially)
- Simpson's paradox (aggregate vs segment differences)
### Experiment Prioritization
ICE Score (1-10 each):
Impact: How much will this move the needle?
Confidence: How sure are we it will work?
Ease: How easy is it to implement?
Score = (Impact + Confidence + Ease) / 3
Example experiments:
| Experiment | Impact | Confidence | Ease | ICE |
|---|
| Add social proof | 8 | 7 | 9 | 8.0 |
| Simplify signup | 9 | 6 | 4 | 6.3 |
| Price anchoring | 7 | 8 | 8 | 7.7 |
| Reduce form fields | 6 | 9 | 9 | 8.0 |
RICE Score:
Reach: # users affected per quarter
Impact: 0.25 (minimal) to 3 (massive)
Confidence: 50% (low) to 100% (high)
Effort: person-weeks
Score = (Reach * Impact * Confidence) / Effort
## Step 22: Customer Journey Mapping
### Journey Stage Framework
Stage 1: Awareness
Touchpoints: Google search, social media, blog, ads, referral
Questions: "What is this? Do I need it?"
Content: Blog posts, social content, ads
Metrics: Impressions, clicks, brand awareness
Stage 2: Consideration
Touchpoints: Website, pricing page, docs, reviews, demos
Questions: "Is this right for me? How does it compare?"
Content: Comparison pages, case studies, webinars
Metrics: Time on site, pages per session, demo requests
Stage 3: Decision
Touchpoints: Sales call, trial, proposal, reference calls
Questions: "Can I justify this? What's the ROI?"
Content: ROI calculator, proposal template, customer stories
Metrics: Trial-to-paid, proposal-to-close, deal velocity
Stage 4: Onboarding
Touchpoints: Welcome email, setup wizard, docs, support
Questions: "How do I get started? When will I see value?"
Content: Quickstart guide, video tutorials, onboarding emails
Metrics: Time to first value, activation rate, setup completion
Stage 5: Adoption
Touchpoints: Product, feature announcements, training
Questions: "How do I get more value? What else can I do?"
Content: Feature guides, best practices, advanced tutorials
Metrics: DAU/MAU, feature adoption, engagement score
Stage 6: Expansion
Touchpoints: Upgrade prompts, account reviews, new features
Questions: "Should I upgrade? What's the next tier?"
Content: Upgrade comparison, ROI of expansion, new feature demos
Metrics: Expansion revenue, upgrade rate, NRR
Stage 7: Advocacy
Touchpoints: Referral program, reviews, case studies, events
Questions: "Would I recommend this? Can I share my story?"
Content: Referral program, review requests, speaking opportunities
Metrics: NPS, referral rate, review count, case studies published
### Journey Map Template
Customer: VP Engineering at Series B startup
Goal: Evaluate and adopt CI/CD platform
Awareness (2-4 weeks):
- Sees colleague post about faster deploys on LinkedIn
- Googles "CI/CD platform comparison"
- Reads blog post comparing top 5 platforms
- Emotional state: Curious, overwhelmed by options
Consideration (1-2 weeks):
- Visits website, reads docs
- Watches 10-min demo video
- Checks G2 reviews (4.5 stars, 200 reviews)
- Compares pricing with current tool
- Emotional state: Interested, needs validation
Decision (1-2 weeks):
- Signs up for free trial
- Deploys first project (takes 15 minutes)
- Invites 3 team members
- Gets approval from CTO
- Emotional state: Excited, slightly anxious about migration
Onboarding (2-4 weeks):
- Migrates first 5 projects
- Sets up team permissions
- Configures notifications
- First successful production deploy
- Emotional state: Relieved, confident
Adoption (1-3 months):
- All 20 projects migrated
- Team uses daily
- Discovers advanced features (canary, rollback)
- Emotional state: Satisfied, productive
Expansion (3-6 months):
- Hits free tier limits
- Evaluates enterprise features (SSO, audit logs)
- Proposes upgrade to management
- Emotional state: Justified, growing trust
## Step 23: Product Analytics SQL
### Cohort Retention Analysis
```sql
-- Monthly cohort retention
WITH cohorts AS (
SELECT
user_id,
DATE_TRUNC('month', MIN(created_at)) AS cohort_month
FROM users
GROUP BY 1
),
activity AS (
SELECT
c.cohort_month,
DATE_TRUNC('month', e.created_at) AS activity_month,
COUNT(DISTINCT c.user_id) AS active_users
FROM cohorts c
JOIN events e ON c.user_id = e.user_id
GROUP BY 1, 2
),
cohort_sizes AS (
SELECT
cohort_month,
COUNT(*) AS cohort_size
FROM cohorts
GROUP BY 1
)
SELECT
a.cohort_month,
cs.cohort_size,
a.activity_month,
a.active_users,
ROUND(a.active_users * 100.0 / cs.cohort_size, 1) AS retention_pct,
EXTRACT(MONTH FROM AGE(a.activity_month, a.cohort_month)) AS months_since_signup
FROM activity a
JOIN cohort_sizes cs ON a.cohort_month = cs.cohort_month
ORDER BY 1, 3;
Feature Adoption Query
WITH user_segments AS (
SELECT
user_id,
CASE
WHEN company_size > 100 THEN 'Enterprise'
WHEN company_size > 10 THEN 'Mid-market'
ELSE 'SMB'
END AS segment,
DATE_TRUNC('month', created_at) AS signup_month
FROM users
),
feature_usage AS (
SELECT
s.segment,
s.signup_month,
COUNT(DISTINCT s.user_id) AS total_users,
COUNT(DISTINCT CASE WHEN e.event_name = 'feature.used'
AND e.feature_name = 'canary_deploy' THEN s.user_id END) AS canary_users,
COUNT(DISTINCT CASE WHEN e.event_name = 'feature.used'
AND e.feature_name = 'auto_rollback' THEN s.user_id END) AS rollback_users,
COUNT(DISTINCT CASE WHEN e.event_name = 'feature.used'
AND e.feature_name = 'monitoring' THEN s.user_id END) AS monitoring_users
FROM user_segments s
LEFT JOIN events e ON s.user_id = e.user_id
GROUP BY 1, 2
)
SELECT
segment,
signup_month,
total_users,
ROUND(canary_users * 100.0 / total_users, 1) AS canary_pct,
ROUND(rollback_users * 100.0 / total_users, 1) AS rollback_pct,
ROUND(monitoring_users * 100.0 / total_users, 1) AS monitoring_pct
FROM feature_usage
ORDER BY 1, 2;
Step 24: Retention Engineering
Churn Prediction Model
Features for churn prediction:
1. Usage frequency (weekly active days)
2. Feature adoption breadth (# features used)
3. Support ticket sentiment (negative = churn risk)
4. Login recency (days since last login)
5. Contract value trend (declining = risk)
6. Team size change (shrinking = risk)
7. Integration activity (less = risk)
8. NPS score (detractor = risk)
Scoring:
Low risk (0-30): Regular engagement, expanding usage
Medium risk (31-60): Declining engagement, flat usage
High risk (61-100): Minimal usage, negative sentiment, shrinking team
Intervention playbook:
Low risk: Quarterly business review, expansion opportunities
Medium risk: Proactive outreach, training offer, executive sponsor
High risk: Immediate CSM call, retention offer, product roadmap preview
Tools:
- ChurnZero: Customer success platform
- Gainsight: Enterprise CS platform
- Totango: CS automation
- Pecan AI: Predictive churn modeling
Re-engagement Campaigns
Trigger: User inactive for 7 days
Email 1 (Day 7): "We miss you" + recent product updates
Email 2 (Day 14): "What you're missing" + usage stats
Email 3 (Day 21): "Special offer" + discount or feature unlock
Email 4 (Day 30): "Last chance" + direct CSM outreach
Trigger: Feature not used after 30 days
In-app prompt: "Did you know?" tooltip
Email: "Unlock [feature]" tutorial + video
CSM: Personal outreach for enterprise accounts
Trigger: Contract renewal in 90 days
Month 3: Usage report + ROI summary
Month 2: Executive business review
Month 1: Renewal proposal + expansion offer
Step 25: Expansion Revenue
Upsell Trigger Framework
Usage-based triggers:
- API calls > 80% of plan limit
- Storage > 75% of plan limit
- Team members > included seats
- Projects > plan limit
Feature-based triggers:
- Attempted to access premium feature
- Viewed enterprise features page
- Asked about SSO/SAML in support ticket
- Requested audit logs or compliance features
Timing triggers:
- 90 days before contract renewal
- After successful product milestone (100th deploy)
- After positive NPS response
- After team size increase
Cross-sell opportunities:
- API user -> Developer tools upgrade
- Individual user -> Team plan
- Team plan -> Enterprise plan
- Self-serve -> Managed service
Usage-Based Pricing Implementation
Components:
1. Metering: Track usage events (API calls, storage, compute)
2. Rating: Apply pricing tiers to usage
3. Billing: Generate invoice based on usage
4. Alerting: Notify users of usage thresholds
Pricing tiers example:
0-1,000 API calls/day: Free
1,001-10,000: $0.001 per call
10,001-100,000: $0.0005 per call
100,001+: $0.0002 per call (volume discount)
Implementation:
- Event streaming: Kafka, Kinesis, Pub/Sub
- Metering: Segment, Amplitude, custom
- Billing: Stripe Usage Records, Lago, Amberflo
- Dashboard: Real-time usage visibility for customers
Best practices:
- Show real-time usage in product
- Alert at 50%, 75%, 90% of limits
- Offer annual commit for predictable spend
- Provide usage forecasts
- Grace periods for overages
## Step 26: Product-Led Onboarding
### Onboarding Flow Design
First-run experience:
- Welcome screen (value prop, 3 key benefits)
- Account setup (minimal fields, progressive disclosure)
- Quick win (achieve something meaningful in <5 min)
- Feature discovery (guided tour of key features)
- Next steps (clear path to deeper engagement)
Progressive onboarding:
Day 1: Core feature (create first project)
Day 3: Collaboration (invite team member)
Day 7: Advanced feature (set up automation)
Day 14: Integration (connect to existing tools)
Day 30: Full adoption (use all key features)
Email sequence:
Day 0: Welcome + quickstart guide
Day 1: "Did you try [feature]?" + tutorial
Day 3: "Your team is waiting" + invite prompt
Day 7: "Pro tip" + advanced feature
Day 14: "Success story" + case study
Day 21: "Upgrade" + premium features
Day 30: "Check-in" + support offer
Metrics:
- Time to first value (TTFV)
- Activation rate (% completing onboarding)
- Day 1, 7, 30 retention
- Feature adoption rate
- Upgrade rate from free to paid
### Activation Metrics
Define activation based on your product:
Collaboration tool:
- Created workspace
- Invited 3+ team members
- Created 5+ items
- Used 2+ core features
Developer tool:
- Generated API key
- Made first API call
- Deployed to production
- Integrated with CI/CD
Analytics tool:
- Connected data source
- Created first dashboard
- Shared dashboard with team
- Set up automated reports
Measurement:
Track activation events in product analytics
Calculate activation rate by cohort
Identify drop-off points
A/B test onboarding variations
Monitor activation by acquisition channel
## Step 27: Product Feedback Loops
### Feedback Collection Methods
In-product:
- NPS surveys (quarterly)
- Feature feedback widgets
- Bug report button
- Feature request form
- Usage analytics (implicit feedback)
External:
- Customer interviews (monthly)
- Support ticket analysis
- Community forums
- Social media monitoring
- Review sites (G2, Capterra)
- Sales team feedback
Feedback processing:
- Collect (multiple channels)
- Categorize (bug, feature, UX, docs)
- Quantify (frequency, impact, effort)
- Prioritize (RICE score)
- Close loop (notify reporter)
- Measure (did the fix help?)
### Feature Request Prioritization
RICE framework:
Reach: # users affected per quarter
Impact: 0.25 (minimal) to 3 (massive)
Confidence: 50% (low) to 100% (high)
Effort: person-weeks
Score = (Reach * Impact * Confidence) / Effort
Example:
Feature A: Reach=1000, Impact=2, Confidence=80%, Effort=4
Score = (1000 * 2 * 0.8) / 4 = 400
Feature B: Reach=500, Impact=3, Confidence=90%, Effort=2
Score = (500 * 3 * 0.9) / 2 = 675
Feature B wins (higher score)
Prioritization matrix:
| Feature | RICE Score | Strategic Fit | Priority |
|---|
| Feature B | 675 | High | P1 |
| Feature A | 400 | Medium | P2 |
| Feature C | 200 | Low | P3 |
## Step 28: Growth Team Structure
### Growth Team Models
Embedded model:
- Growth engineers embedded in product teams
- Each team runs own experiments
- Centralized analytics support
- Best for: Small companies (<50 engineers)
Centralized model:
- Dedicated growth team
- Owns activation, retention, monetization experiments
- Works across all product areas
- Best for: Mid-size companies (50-200 engineers)
Hybrid model:
- Core growth team (strategy, analytics, experimentation)
- Growth engineers in product teams
- Shared experimentation platform
- Best for: Large companies (200+ engineers)
Growth team roles:
- Growth PM: Strategy, prioritization, metrics
- Growth engineers: Build and run experiments
- Data analyst: Analysis, insights, reporting
- Designer: Experiment design, UX optimization
- Marketer: Channel optimization, content
### Experimentation Culture
Principles:
- Data over opinions
- Test everything (assumptions are hypotheses)
- Ship fast, learn fast
- Celebrate learnings (not just wins)
- Document everything (experiment log)
Experiment log template:
| ID | Hypothesis | Metric | Result | Learning |
|---|
| EXP-001 | Social proof increases conversion | CVR | +12% | Social proof works on pricing page |
| EXP-002 | Shorter form increases signups | Signups | -5% | Form length less important than clarity |
| EXP-003 | Video tutorial improves activation | Activation | +18% | Video significantly helps onboarding |
Cadence:
- Weekly: Experiment review meeting
- Monthly: Experiment planning
- Quarterly: Growth strategy review
- Annually: Growth OKR setting
Step 29: Product Analytics Tools
Analytics Stack
Data collection:
- Segment: Event routing (collect once, send everywhere)
- Rudderstack: Open-source alternative to Segment
- Snowplow: Event data pipeline
- Mixpanel SDK: Direct event tracking
Analysis:
- Mixpanel: Event-based analytics, funnels, retention
- Amplitude: Product analytics, behavioral cohorts
- PostHog: Open-source, self-hostable
- Heap: Auto-capture analytics
Visualization:
- Looker: Enterprise BI
- Tableau: Data visualization
- Metabase: Open-source BI
- Grafana: Time-series dashboards
Data warehouse:
- Snowflake: Cloud data warehouse
- BigQuery: Google Cloud data warehouse
- Redshift: AWS data warehouse
- ClickHouse: Open-source OLAP
Event Tracking Plan
Event naming convention:
[noun].[verb]
Examples:
user.signed_up
project.created
feature.used
billing.upgraded
Event properties:
user.signed_up:
- signup_method: google | github | email
- referrer: direct | organic | referral | paid
- utm_source: twitter | google | newsletter
- company_size: 1-10 | 11-50 | 51-200 | 200+
Implementation:
1. Define tracking plan (spreadsheet)
2. Review with product and engineering
3. Implement in code
4. QA in staging
5. Monitor for data quality
6. Update plan as product evolves
Tools:
- Avo: Tracking plan management
- Iteratively: Data governance
- Schema validation in Segment/Rudderstack
Step 30: Growth Experimentation
Experiment Framework
Hypothesis:
"If we [change], then [metric] will [direction] by [amount],
because [reasoning]."
ICE Score (1-10 each):
Impact: How much will this move the needle?
Confidence: How sure are we it will work?
Ease: How easy is it to implement?
Score = (Impact + Confidence + Ease) / 3
Experiment log:
| ID | Hypothesis | ICE | Status | Result | Learning |
|----|------------|-----|--------|--------|----------|
| EXP-001 | Social proof increases conversion | 8.0 | Complete | +12% | Works on pricing page |
| EXP-002 | Shorter form increases signups | 7.3 | Complete | -5% | Length less important |
| EXP-003 | Video improves activation | 8.7 | Running | TBD | |
Cadence:
- Weekly: Experiment review
- Monthly: Experiment planning
- Quarterly: Growth strategy review
Step 31: Product Metrics Hierarchy
Metrics Stack
North Star Metric:
- Single metric that best captures value delivered
- Examples:
- Slack: Weekly active teams sending 2000+ messages
- Airbnb: Nights booked
- Stripe: Weekly active merchants
Input metrics (leading indicators):
- New users (acquisition)
- Activation rate (onboarding)
- Feature adoption (engagement)
- Retention rate (stickiness)
- Expansion revenue (monetization)
Output metrics (lagging indicators):
- Revenue
- Profit
- Market share
- Customer satisfaction
Metric hierarchy:
Company: North Star Metric
Department: Team-specific metrics
Individual: Personal KPIs
Metrics Review Process
Daily:
- Key metrics dashboard (automated)
- Anomaly alerts
- Incident monitoring
Weekly:
- Metrics review meeting (30 min)
- Top movers analysis
- Experiment results
- Action items
Monthly:
- Deep dive on trends
- Cohort analysis
- Funnel optimization
- Strategy adjustments
Quarterly:
- OKR review
- Strategic planning
- Resource allocation
- Roadmap updates
## Related Skills
- [sdlc-developer-relations](sdlc-developer-relations): Developer Relations (DevRel) program design: advocacy, community, marketing, enablement. Developer e
- [sdlc-gtm-strategy](sdlc-gtm-strategy): Go-to-market strategy: market positioning, pricing, packaging, sales enablement, competitive analysi
- [sdlc-finance-ops](sdlc-finance-ops): Software company finance and operations: unit economics, SaaS metrics, fundraising (seed to IPO), fi
## Step 34: Growth Metrics Glossary
### Key Terms
Acquisition:
- Visitor: Anonymous user visiting your site
- Lead: User who provided contact info
- Signup: User who created account
- Activation: User who completed key action
Revenue:
- MRR: Monthly Recurring Revenue
- ARR: Annual Recurring Revenue
- ARPU: Average Revenue Per User
- LTV: Lifetime Value (ARPU / churn rate)
Retention:
- Churn: % of customers lost per period
- Retention: % of customers kept per period
- NRR: Net Revenue Retention (expansion - contraction - churn)
- Cohort: Group of users who started at same time
Engagement:
- DAU: Daily Active Users
- MAU: Monthly Active Users
- DAU/MAU: Stickiness ratio
- Session duration: Average time per visit
