Growth Strategy Pack

We built the Growth Strategy Pack so you don't have to treat growth like a black box. If you're a working engineer, you know that shipping features doesn't automatically move revenue. You optimize for latency, throughput, and correctness, but the dashboard stays flat. That's because growth isn't a feature; it's a system. And systems break when you try to run them on intuition.

This skill gives you the infrastructure to treat acquisition, activation, retention, and monetization as programmable loops. You get executable scripts, YAML schemas, and validators that enforce discipline. No slide decks. No vague "growth hacks." Just the frameworks and tooling to catch leaks, calculate unit economics, and run experiments that actually prove value.

The Growth Gap: Why Feature Velocity Doesn't Move Revenue

You've seen it. Your engineering team ships a backlog of features at breakneck speed. The PRs merge, the CI passes, and the deployment succeeds. Then you check the metrics. DAU is flat. CAC is creeping up. Churn is ticking. You're building faster, but the business isn't growing.

The problem is a misalignment of incentives and a lack of feedback loops. Engineering optimizes for delivery; growth optimizes for compounding revenue. When these silos collide, you get a product that's technically sound but commercially leaky. You might be activating users, but if your retention curve drops off at D7, you're pouring water into a bucket with a hole. Or worse, you're monetizing too early, killing activation before users find value.

Real growth is a system: Acquisition brings customers in, Activation gets them hooked, Retention keeps them, and Monetization makes it sustainable ^[4]. When you treat these as separate departments rather than interconnected mechanics, you lose the signal. You don't know if a drop in revenue came from a broken checkout flow or a spike in churn from a bad cohort. Without a structured system for designing, sequencing, and compounding revenue growth through acquisition, conversion, retention, and expansion, you're just guessing ^[8].

Engineers hate guessing. We want deterministic outcomes. That's why this pack moves growth from "marketing magic" to engineering rigor. You get the same tooling you use for code reviews and CI pipelines, applied to your growth stack. If you're also designing the underlying business logic, check the Business Model Canvas Pack to ensure your value proposition matches the growth loops you're building.

The Cost of Guesswork: Burn Rate, Churn, and Invisible Leaks

Ignoring the growth system costs you more than just missed targets. It burns cash, erodes trust, and creates technical debt in your product strategy. When you run experiments without proper hypothesis structure, you waste engineering cycles on changes that do nothing. When you don't track cohort retention, you miss the window to fix activation before users leave.

The financial math is unforgiving. If your LTV:CAC ratio drops below 3, you're spending too much to acquire customers relative to their lifetime value. If your payback period exceeds 12 months, your cash flow is under severe strain. These aren't abstract metrics; they're alarms. A team that ignores these thresholds will eventually run out of runway, regardless of how good the code is.

Consider the downstream impact of bad growth ops. You launch a pricing change without validating the impact on expansion revenue. Churn spikes. Support tickets flood in. Your engineers have to hotfix the billing logic while the growth team scrambles to rollback. This isn't just a revenue hit; it's a reliability incident. You've degraded the user experience to fix a strategy error that a structured framework would have caught.

Scaling without unit economics discipline is like adding load to a system without stress testing. You might handle the traffic for a week, but the architecture will collapse under sustained pressure. You need to understand the constraints before you pull the lever. A world-class guide to business models must include unit economics, competitive moats, and strategic acumen grounded in data, not hope ^[6].

If your growth metrics are unhealthy, you might need to rethink your entire approach. The Pivot Strategy Pack helps you detect market signals, validate pivot necessity, and reallocate resources when the current growth model is broken.

How a SaaS Team Fixed D30 Retention with Cohort Analysis

Imagine a B2B SaaS team scaling from $1M to $5M ARR. They had a solid acquisition channel via content marketing, but their retention curve was a cliff. D1 retention was 85%, but D30 dropped to 20%. The leadership team assumed the product was too complex. They ordered more training videos. Engagement dropped further.

The team stopped guessing and applied a systematic growth framework. They segmented users by acquisition date and channel, calculating retention curves to identify the exact drop-off point. The cohort analysis revealed that users who didn't complete a specific onboarding workflow within 48 hours churned at 70%. The problem wasn't complexity; it was a missing activation trigger.

They designed an experiment using a structured protocol. The hypothesis was clear: "Adding an in-app guided tour for the core workflow will increase D7 activation by 15%." They defined primary and secondary metrics, calculated the required sample size, and set prediction bounds. They ran the experiment for two weeks, monitoring the cohort behavior.

The results were decisive. The guided tour group showed a 12% lift in D7 activation and a measurable improvement in D30 retention. The experiment validated the hypothesis, and the team rolled out the change globally. Revenue stabilized, and the churn rate dropped. This wasn't luck. It was a structured approach to experimentation that aligned the team around data ^[3].

This story illustrates why you need templates that enforce rigor. A growth framework is a structured mental model that aligns your strategy around the customer journey and business goals, ensuring everyone ships to the same target ^[5]. Without that alignment, you get feature factories, not growth engines.

What Changes When Your Growth Stack Is Programmatic

Once you install the Growth Strategy Pack, your workflow shifts from reactive to proactive. You stop chasing vanity metrics and start optimizing for unit economics. You get a stack that catches errors before they hit production, just like your linter catches syntax errors.

Here's what the after-state looks like:

Experiments are RFC-compliant in structure. Every test starts with a hypothesis, prediction bounds, and sample size calculation. The experiment-protocol.yaml template enforces this, so you never run a test without a clear success criterion. The validate_experiment.sh script parses your protocol and exits with diagnostic output if fields are missing or sample size is invalid. Unit economics are calculated, not estimated. You feed CSV or JSON data into calculate_unit_economics.py, and it outputs LTV, CAC, payback period, and gross margin-adjusted metrics. The script uses real formulas and exits non-zero on invalid data, so you can't ship a pricing model based on broken math. KPI baselines are validated automatically. The growth-kpi-baseline.json schema defines thresholds for CAC, LTV, retention, and activation. The check_metrics_thresholds.py validator reads your actual metrics and flags unhealthy ratios, like LTV:CAC < 3 or payback > 12 months. You get a CI-style gate for your growth health. Retention is analyzed with cohort methodology. The retention-cohort-analysis.md template gives you a step-by-step framework for segmenting users, calculating retention curves, and prescribing experiments. You identify drop-off points and fix them systematically. Scaling is planned with automation levers. The scaling-and-automation.md reference covers team structure for growth pods, feedback loop design, and automation levers like email, in-app, and webhooks. You understand the constraints before you scale.

This pack integrates with your existing GTM workflow. If you're managing a launch, the Product Launch Pack covers GTM strategy, execution, PR outreach, and post-launch analysis, ensuring your growth loops are ready when you go live.

What's in the Growth Strategy Pack

The pack is a multi-file deliverable designed for engineers who want executable, validated, and structured growth tooling. Every file serves a purpose. There are no fluff documents.

skill.md — Orchestrator: defines the growth specialist persona, maps the full acquisition-retention-monetization-experimentation workflow, and explicitly references all relative paths for templates, references, scripts, validators, and examples. references/funnel-and-loop-frameworks.md — Canonical knowledge: AARRR/Pirate Metrics, product-led growth loops, retention cohort theory, and monetization levers (pricing tiers, expansion revenue, cross-sell). Embeds real frameworks instead of links. templates/experiment-protocol.yaml — Production-grade experiment tracking template: enforces hypothesis structure, prediction bounds, primary/secondary metrics, sample size calculation, and risk/mitigation fields. Uses real growth ops schema. templates/growth-kpi-baseline.json — KPI baseline schema: defines real thresholds for CAC, LTV, payback period, D1/D7/D30 retention, activation rate, and conversion funnels. Includes validation rules for healthy vs. unhealthy baselines. scripts/calculate_unit_economics.py — Executable script: calculates LTV, CAC, payback period, and gross margin-adjusted unit economics from CSV/JSON input. Uses argparse, real formulas, and exits non-zero on invalid data. validators/validate_experiment.sh — Programmatic validator: parses experiment-protocol.yaml, checks required fields, validates metric types, ensures sample size > 0, and exits 1 with diagnostic output on failure. examples/full-funnel-strategy.yaml — Worked example: complete filled-out experiment protocol + funnel strategy mapping acquisition channels, activation triggers, retention hooks, and monetization steps to a SaaS product. references/scaling-and-automation.md — Canonical knowledge: team structure for growth pods, feedback loop design, automation levers (email, in-app, webhooks), and scaling constraints. Grounded in startup OS and agency growth playbooks. templates/retention-cohort-analysis.md — Cohort analysis framework: step-by-step methodology for segmenting users by acquisition date/channel, calculating retention curves, identifying drop-off points, and prescribing retention experiments. validators/check_metrics_thresholds.py — Programmatic validator: reads growth-kpi-baseline.json, compares actual metrics against thresholds, flags unhealthy ratios (e.g., LTV:CAC < 3, payback > 12mo), and exits non-zero on failure.

This is the infrastructure you need to build a scalable business growth strategy with a template that actually works ^[1]. You get the frameworks, the scripts, and the validators. You just plug in your data.

Install the Pack and Ship with Confidence

Stop treating growth like a mystery. Start treating it like a system you can measure, validate, and optimize. Upgrade to Pro to install the Growth Strategy Pack and get the tooling that turns your growth stack into a deterministic engine.

You have the engineering discipline. Now you have the growth frameworks to match. Install the pack, run the validators, calculate your unit economics, and ship with confidence.

The growth gap is closing. Your move.

**