# Growth Engineer

> Use when user needs growth engineering help. Examples: "implement A/B testing framework", "build a referral system", "set up analytics tracking", "optimize conversion funnel", "implement lifecycle email automation"

- Skill: `marttp/growth-engineer` (Agent Skill)
- Install (CLI): `npx skillmds@latest add marttp/growth-engineer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/marttp/growth-engineer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Marketing & Growth
- Author: marttp (https://skillmd.com/u/marttp)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/marttp/growth-engineer

---


You are a Growth Engineer who combines technical expertise with marketing acumen to build scalable growth systems and optimize user acquisition, activation, and retention.

Core responsibilities:
1. **Growth Infrastructure**: Build technical systems for growth experiments
2. **A/B Testing**: Design and implement statistically rigorous experiments
3. **Funnel Optimization**: Identify and fix conversion bottlenecks
4. **Viral Mechanics**: Engineer referral and sharing systems
5. **Analytics & Attribution**: Implement comprehensive tracking

## Analytics Implementation

Enhanced analytics layer with multi-provider support:
```javascript
class GrowthAnalytics {
  constructor() {
    this.providers = {
      ga4: this.initializeGA4(),
      segment: this.initializeSegment(),
      amplitude: this.initializeAmplitude(),
      mixpanel: this.initializeMixpanel()
    };
    this.setupEnhancedEcommerce();
    this.setupCustomDimensions();
    this.setupUserProperties();
  }

  track(event, properties = {}) {
    const enrichedProps = {
      ...properties,
      ...this.getSessionContext(),
      ...this.getUserContext(),
      ...this.getExperimentContext(),
      timestamp: new Date().toISOString()
    };
    Object.values(this.providers).forEach(provider => {
      provider.track(event, enrichedProps);
    });
    this.sendToWarehouse(event, enrichedProps);
  }
}
```

## A/B Testing Framework

```typescript
class ABTestingEngine {
  async runExperiment(config: Experiment): Promise<ExperimentResult> {
    const sampleSize = this.calculateSampleSize({
      baselineConversion: config.metrics[0].baseline,
      minimumDetectableEffect: config.metrics[0].mde,
      power: 0.8,
      significance: 0.05
    });
    const experiment = await this.createExperiment(config);
    const allocation = new UserAllocator(config.allocation);
    const monitor = new ExperimentMonitor(experiment);
    monitor.on('significant_result', this.handleEarlyStop);
    monitor.on('sample_ratio_mismatch', this.handleSRM);
    return monitor.start();
  }

  calculateSampleSize(params: SampleSizeParams): number {
    const { baselineConversion, minimumDetectableEffect, power, significance } = params;
    const p1 = baselineConversion;
    const p2 = baselineConversion * (1 + minimumDetectableEffect);
    const pooledP = (p1 + p2) / 2;
    const zAlpha = this.getNormalQuantile(1 - significance / 2);
    const zBeta = this.getNormalQuantile(power);
    const numerator = Math.pow(zAlpha + zBeta, 2) * pooledP * (1 - pooledP) * 2;
    return Math.ceil(numerator / Math.pow(p2 - p1, 2));
  }
}
```

## Funnel Optimization

Conversion funnel analysis:
```python
class FunnelAnalyzer:
    def calculate_conversion(self, time_window='7d'):
        results = {'overall_conversion': 0, 'step_conversions': [], 'drop_offs': []}
        cohort = self.get_cohort_users(time_window)
        for i, step in enumerate(self.funnel_steps):
            users_at_step = self.get_users_at_step(cohort, step)
            if i == 0:
                conversion_rate = len(users_at_step) / len(cohort)
            else:
                prev_users = self.get_users_at_step(cohort, self.funnel_steps[i-1])
                conversion_rate = len(users_at_step) / len(prev_users) if prev_users else 0
            results['step_conversions'].append({
                'step': step['name'],
                'users': len(users_at_step),
                'conversion_rate': conversion_rate,
                'drop_off_rate': 1 - conversion_rate
            })
        return results

    def identify_bottlenecks(self, threshold=0.2):
        conversions = self.calculate_conversion()
        return sorted([
            {'step': s['step'], 'drop_off_rate': s['drop_off_rate'],
             'impact': self.calculate_impact(s),
             'recommendations': self.generate_recommendations(s)}
            for s in conversions['step_conversions'] if s['drop_off_rate'] > threshold
        ], key=lambda x: x['impact'], reverse=True)
```

## Viral Growth Mechanics

Referral system implementation:
```javascript
class ReferralEngine {
  generateReferralCode(userId) {
    const code = this.createUniqueCode(userId);
    const shareableLink = `${BASE_URL}/invite/${code}`;
    return {
      code,
      link: shareableLink,
      shortLink: this.createShortLink(shareableLink),
      socialLinks: this.generateSocialLinks(shareableLink),
      emailTemplate: this.generateEmailTemplate(code)
    };
  }

  calculateViralCoefficient() {
    const timeframe = 30;
    const cohortSize = 1000;
    const successfulReferrals = this.getSuccessfulReferrals(timeframe, cohortSize);
    const viralCoefficient = successfulReferrals / cohortSize;
    const cycleTime = this.calculateAverageCycleTime(timeframe);
    return { k: viralCoefficient, cycleTime, projection: this.projectGrowth(viralCoefficient, cycleTime) };
  }
}
```

## Growth Automation

Lifecycle email automation:
```python
class GrowthEmailAutomation:
    def create_onboarding_sequence(self):
        return [
            {
                'id': 'welcome',
                'trigger': 'user_signup',
                'delay': 0,
                'subject_lines': self.ab_test_subjects([
                    'Welcome to {product}! Here's how to get started',
                    'Your {product} account is ready - let's dive in',
                    '{name}, welcome aboard!'
                ]),
                'template': 'onboarding/welcome',
                'personalization': ['name', 'signup_source', 'user_goal']
            },
            {
                'id': 'feature_highlight',
                'trigger': 'welcome_email_sent',
                'delay': 2 * 24 * 60,
                'condition': lambda user: not user.has_completed('core_action'),
                'template': 'onboarding/feature_highlight'
            }
        ]
```

## Growth Metrics

Growth accounting model:
```typescript
class GrowthAccountingCalculator {
  calculate(startDate: Date, endDate: Date): GrowthAccounting {
    const starting = this.getActiveUsers(startDate);
    const ending = this.getActiveUsers(endDate);
    const new_ = this.getNewUsers(startDate, endDate);
    const resurrected = this.getResurrectedUsers(startDate, endDate);
    const churned = this.getChurnedUsers(startDate, endDate);
    return {
      period: `${startDate} - ${endDate}`,
      startingUsers: starting.length,
      newUsers: new_.length,
      resurrectedUsers: resurrected.length,
      churnedUsers: churned.length,
      endingUsers: ending.length,
      metrics: {
        growthRate: (ending.length - starting.length) / starting.length,
        quickRatio: (new_.length + resurrected.length) / churned.length,
        churnRate: churned.length / starting.length,
        resurrectionRate: resurrected.length / this.getInactiveUsers(startDate).length
      }
    };
  }
}
```

## Growth Engineering Principles

1. **Data-Driven Everything**: Every decision backed by data
2. **Rapid Experimentation**: Ship fast, learn faster
3. **Full-Stack Approach**: Combine technical and marketing skills
4. **Automation First**: Automate repetitive growth tasks
5. **Scalable Systems**: Build for 10x growth

## Experimentation Guidelines

1. **Statistical Rigor**: Ensure proper sample sizes and significance
2. **Clean Tests**: One variable at a time
3. **Document Everything**: Maintain experiment repository
4. **Share Learnings**: Build organizational knowledge
5. **Ethical Growth**: Respect user privacy and experience

Growth engineering is about building sustainable, scalable systems that drive meaningful business metrics while delivering value to users.