When Engineers Join Growth Teams

Now let us talk about experiments that do not drag the whole release train. A feature flag with remote config lets you turn flows on for a cohort, tweak copy, or switch pricing without a new build. If your team is smaller or you prefer control, you can roll a tiny flag service and keep it close to your codebase. The point is not the brand name. The point is having a dial you can turn while watching metrics.

# flags.py
# Minimal remote flags with sticky bucketing
import hashlib
from typing import Dict

FLAGS: Dict[str, Dict] = {
  "paywall_copy_test": {
    "enabled": True,
    "percent": 50,
    "params": { "variant_a": "Start your free trial", "variant_b": "Get started today" }
  }
}

def bucket(user_id: str, flag: str) -> bool:
    h = hashlib.sha1(f"{user_id}:{flag}".encode()).hexdigest()
    roll = int(h[:4], 16) % 100
    return roll < FLAGS[flag]["percent"]

def variant(user_id: str, flag: str) -> str:
    return "B" if bucket(user_id, flag) else "A"

Once flags are in place, retention analysis becomes the steady heartbeat of the team. You do not need a giant model to answer the first set of questions. Which action predicts day seven return. Which content or feature bumps the first week count from one visit to three. Which email subject gets people back to the product rather than to the unsubscribe link. Keep the queries simple and repeatable, then move to deeper cuts only when the win rate slows down.

-- Retention by key action within first 24h
WITH first_session AS (
  SELECT user_id, MIN(event_time) AS first_ts
  FROM events
  WHERE name = 'Signup Completed'
  GROUP BY 1
),
did_action AS (
  SELECT e.user_id
  FROM events e
  JOIN first_session f USING (user_id)
  WHERE e.name = 'Feature Used'
    AND e.props:feature = 'ai_writer'
    AND e.event_time <= f.first_ts + INTERVAL '24 hours'
  GROUP BY 1
),
d7_return AS (
  SELECT e.user_id
  FROM events e
  JOIN first_session f USING (user_id)
  WHERE e.event_time BETWEEN f.first_ts + INTERVAL '7 days'
                         AND f.first_ts + INTERVAL '8 days'
  GROUP BY 1
)
SELECT
  CASE WHEN da.user_id IS NOT NULL THEN 'Used AI Writer' ELSE 'Did Not Use' END AS cohort,
  COUNT(DISTINCT f.user_id) AS users,
  COUNT(DISTINCT d7.user_id) AS d7_returned,
  ROUND(COUNT(DISTINCT d7.user_id)::numeric / NULLIF(COUNT(DISTINCT f.user_id),0), 4) AS d7_rate
FROM first_session f
LEFT JOIN did_action da ON da.user_id = f.user_id
LEFT JOIN d7_return d7 ON d7.user_id = f.user_id
GROUP BY 1
ORDER BY d7_rate DESC;

The growth engineer also closes the loop with messaging tools so the product talks back when users show intent. If a user reaches pricing three times in a week and has not paid, trigger a chat nudge or a trial extension. If a team invites two coworkers but stops short of connecting data, send a short note with a one click link that finishes setup. The trick is to keep messages tied to product state, not just time since signup. That is where lifecycle marketing stops feeling like spam and starts feeling like help.

// Example serverless handler to trigger Braze/Iterable on intent
import fetch from 'node-fetch';

export async function handleIntent(user) {
  const shouldNudge =
    user.views.pricing_week >= 3 &&
    !user.has_active_plan &&
    user.consent.marketing === true;

  if (!shouldNudge) return;

  await fetch('https://api.example-marketing.com/trigger', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.MKT_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      campaign: 'pricing_intent_nudge',
      userId: user.id,
      traits: { plan_interest: user.last_pricing_plan_viewed }
    })
  });
}

Now to the touchy part that stops many experiments before they start. Consent. A growth engineer working with a marketer can make the consent wall both honest and friendly, while keeping analytics useful. Ask for analytics separately from marketing messages, store the grants clearly, and route events based on those choices. You get to stay out of trouble and still learn. The last mile is to expose those consent states so data folks can filter properly without guessing.

// consent.ts
type Consent = {
  analytics: boolean;
  marketing: boolean;
  ads: boolean;
  ts: string;
};

export function saveConsent(c: Consent) {
  localStorage.setItem('consent', JSON.stringify(c));
  // Attach consent to session and event headers
  window.consent = c;
}

export function shouldSendEvent(name: string): boolean {
  const c: Consent = JSON.parse(localStorage.getItem('consent') || '{"analytics":false}');
  // Always allow strictly necessary events sent to first party endpoints
  const necessary = ['Session Started', 'Consent Updated'];
  if (necessary.includes(name)) return true;
  return c.analytics === true;
}

There is also the AI layer that is sneaking into every backlog now. Not because it is trendy, but because it shortens the loop between idea and shipped test. LLMs can draft subject lines, write first pass onboarding copy, build a messy SQL that a human then cleans, and even review events for naming mistakes. The payoff is not magic. It is ten percent faster in a dozen places that add up to a lot over a quarter. Keep it grounded with clear prompts, a review checklist, and guardrails for PII and you will get real wins without drama.If you are a developer thinking about joining or starting a growth team, you will feel an itch at first. Tickets are not purely about new features. Metrics are not perfect and will never be. Marketing asks can sound soft until you see the cohort chart move. The good news is your skills transfer directly. Event schema design is just API design. Experiment setup is just careful config and monitoring. Funnel math is just counting. Once you taste that shared rhythm, it is hard to go back.On the management side, set three rails so the team does not spin. First, a weekly bet review that keeps a scoreboard of shipped ideas, with a simple win or learn label. Second, a source of truth doc that shows event names, where they land, and who owns them. Third, a release path that lets you turn tests on and off without waiting on a full release cycle. You will be amazed how much less debate you need when those rails are in place.Before wrapping, let me give you a simple checklist to start tomorrow. Create a shared event map with three must have stages: signup, aha, and first value. Drop a single feature flag around your paywall or first run flow. Ship one messaging trigger that fires on strong intent. Pick one retention query and post it every week with the same buckets so trends are obvious. And add a small bold note in your PR template that says what metric you expect to move. That tiny habit builds a culture.Search engines love the phrase growth engineering but the practice is not a buzzword. It is simply engineers and marketers building the product together with a scoreboard that everyone respects. The stack will change, the channels will change, privacy rules will keep moving, and cookies will keep fading. What does not change is the loop. Ask a sharp question, instrument the moment, ship a small test, and learn fast with the whole team watching the same chart. If that sounds fun to you, welcome to the workbench.