Growth Engine

Growth Engine

When to Use

Trigger phrases:

• "growth engine"
• "Help me with growth engine"

Use cases:

• When the task matches this skill's domain expertise

When NOT to use:

• For tasks outside this skill's scope

hypothesis = growth_hypothesis( insight="Users who view demo video convert 3x higher", design="Add prominent demo CTA on homepage", expected="+25% demo views, +15% trial signups", assumption="Demo video quality resonates with target audience" )

2. Design experiment

experiment = design_ab_test( hypothesis=hypothesis, variants=["demo_cta_v1", "demo_cta_v2"], primary_metric="trial_signup_rate", secondary_metrics=["demo_view_rate", "time_on_page"], traffic_split=[0.34, 0.33, 0.33] # Control + 2 variants )

3. Launch and monitor

experiment.launch()

while experiment.status == "RUNNING": daily_report = experiment.generate_report()

# Check pacing alerts
if daily_report.sample_size_alert:
    notify("Sample size behind pace")

if daily_report.conversion_drop:
    experiment.pause()
    notify("Conversion rate anomaly detected")

time.sleep(86400)  # Daily check

4. Analyze results

results = experiment.final_analysis()

if results.winner and results.confidence >= 0.95: implement_winner(results.winner) document_learning(results) else: document_learning(results) # Document negative result too

### Example 2: Rapid Experiment Pipeline

```python
# Run multiple micro-experiments in parallel
experiments = [
    {"type": "email_subject", "n_variants": 5, "traffic": "10%"},
    {"type": "cta_color", "n_variants": 4, "traffic": "20%"},
    {"type": "pricing_display", "n_variants": 3, "traffic": "30%"}
]

for exp_config in experiments:
    exp = create_micro_experiment(exp_config)
    exp.launch()
    
# Weekly review
candidates = []
for exp in running_experiments:
    results = exp.get_results()
    if results.confidence >= 0.90:
        candidates.append(results)
        
# Promote winners
for winner in candidates:
    rollout_gradually(winner.variant, [0.10, 0.50, 1.0])

Example 3: Growth Scorecard

# Generate weekly growth report
scorecard = {
    "experiments": {
        "running": 8,
        "completed_this_week": 3,
        "winners": 1,
        "inconclusive": 2
    },
    "metrics": {
        "activation_rate": {"current": 0.35, "lift": "+5%"},
        "retention_d7": {"current": 0.42, "lift": "+3%"},
        "referral_rate": {"current": 0.18, "lift": "+12%"}
    },
    "velocity": {
        "experiments_per_week": 2.5,
        "win_rate": 0.33,
        "avg_lift": "8.5%"
    }
}

generate_weekly_scorecard(scorecard)

When NOT to Use

• When the audience is too small to justify the effort
• For regulated industries without compliance review
• When the campaign budget does not support the channel

Overview

Growth Engine drives growth marketing with data-driven strategies.

Workflow

1. Research — Analyze market, competitors, and audience
2. Strategy — Define goals, channels, and messaging
3. Create — Develop content and creative assets
4. Launch — Deploy campaigns across channels
5. Optimize — A/B test and iterate based on data
6. Report — Track KPIs and ROI

Key Metrics

• Reach and impressions
• Engagement rate (likes, shares, comments)
• Conversion rate (clicks → leads → customers)
• Customer acquisition cost (CAC)
• Return on ad spend (ROAS)

Best Practices

• Test everything — headlines, images, CTAs, timing
• Focus on one channel at a time, then expand
• Build organic before scaling paid
• Track attribution across the full funnel

Anti-Rationalization Table

Money-Making Overview

Run automated growth experiments that compound revenue. Each completed experiment with statistically significant winner generates 10-50% lift on the tested metric.

Revenue Streams

• Conversion optimization — $1,000-$10,000/month per client
• Growth consulting — $200-$500/hour
• Experiment-as-a-Service — $2,000-$10,000/month
• Own product experiments — $5,000-$50,000/month

First Action in 60 Minutes

#!/usr/bin/env python3
"""ICE hypothesis scoring framework — analyze metrics and rank experiment backlog."""

import json
import sys
from dataclasses import dataclass, field
from typing import List, Optional


@dataclass
class ExperimentHypothesis:
    name: str
    description: str
    impact: int      # 1-10
    confidence: int  # 1-10
    ease: int        # 1-10

    def ice_score(self) -> float:
        return (self.impact + self.confidence + self.ease) / 3.0

    def expected_revenue_impact(self, monthly_revenue: float, metric_share: float = 0.1) -> float:
        lift = self.impact * 0.05  # Each impact point ≈ 5% estimated lift
        return monthly_revenue * metric_share * lift


def load_hypotheses(path: str) -> List[ExperimentHypothesis]:
    with open(path) as f:
        data = json.load(f)
    return [ExperimentHypothesis(**h) for h in data]


def rank_experiments(hypotheses: List[ExperimentHypothesis], monthly_revenue: float) -> List[dict]:
    scored = []
    for h in hypotheses:
        scored.append({
            "name": h.name,
            "description": h.description,
            "ice_score": round(h.ice_score(), 2),
            "impact": h.impact,
            "confidence": h.confidence,
            "ease": h.ease,
            "expected_monthly_revenue_impact": round(h.expected_revenue_impact(monthly_revenue), 2)
        })
    scored.sort(key=lambda x: x["ice_score"], reverse=True)
    return scored


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python ice_scorer.py <hypotheses.json> [monthly_revenue]")
        sys.exit(1)

    revenue = float(sys.argv[2]) if len(sys.argv) > 2 else 50000.0
    hypotheses = load_hypotheses(sys.argv[1])
    ranked = rank_experiments(hypotheses, revenue)

    print("=" * 72)
    print("ICE SCORE RANKING — Experiment Backlog (by priority)")
    print("=" * 72)
    for i, exp in enumerate(ranked, 1):
        print(f"\n  {i}. {exp['name']}")
        print(f"     ICE: {exp['ice_score']:.1f}  (Impact={exp['impact']}  Confidence={exp['confidence']}  Ease={exp['ease']})")
        print(f"     Expected monthly impact: ${exp['expected_monthly_revenue_impact']:,.2f}")
        print(f"     {exp['description']}")

    total = sum(e['expected_monthly_revenue_impact'] for e in ranked)
    print(f"\n{'─' * 72}")
    print(f"  Total expected lift from backlog: ${total:,.2f}/month")
    print(f"{'─' * 72}")
    print("\nRun order: top ICE score first. Re-score weekly as data accumulates.")

Output Format

experiment_backlog:
  total_hypotheses: 12
  top_ice_score: 8.3
  total_expected_lift_monthly: "$12,500"
  top_3:
    - name: "Homepage demo CTA"
      ice: 8.3
      expected_impact: "$3,750/mo"
    - name: "Email subject line A/B"
      ice: 7.7
      expected_impact: "$2,500/mo"
    - name: "Pricing page redesign"
      ice: 7.0
      expected_impact: "$1,875/mo"
  money_metric: "lift_on_target_kpi"

Process

1. Prepare — Gather requirements, verify prerequisites, set up environment
2. Execute — Run growth engine workflow with configured parameters
3. Verify — Validate output meets requirements, document results

Verification

• All steps executed successfully
• Results validated against acceptance criteria
• Error handling tested with edge cases
• Documentation updated with findings