const allowedNames = [
  'report_created',
  'report_published',
] as const;

type ProductEventName = typeof allowedNames[number];

@Injectable()
export class ProductMetricsService {
  capture(
    actorId: string,
    name: ProductEventName,
    properties: Record<string, string | number>,
  ) {
    return this.events.insert({
      eventId: randomUUID(),
      actorId,
      name,
      properties,
      schemaVersion: 1,
    });
  }
}

• as const preserves string literals instead of widening to string.
• ProductEventName becomes a union of allowed names.
• Actor arrives separately from authenticated context.
• A compile-time type does not replace runtime validation of external JSON.

WITH first_steps AS (
  SELECT user_id,
    min(occurred_at) FILTER (
      WHERE event_name = 'signup_completed'
    ) AS signed_up_at,
    min(occurred_at) FILTER (
      WHERE event_name = 'project_created'
    ) AS project_at,
    min(occurred_at) FILTER (
      WHERE event_name = 'project_published'
    ) AS published_at
  FROM product_events
  GROUP BY user_id
)
SELECT
  count(*) FILTER (WHERE signed_up_at IS NOT NULL) AS signup,
  count(*) FILTER (WHERE project_at >= signed_up_at) AS project,
  count(*) FILTER (
    WHERE published_at >= project_at
      AND published_at < signed_up_at + interval '7 days'
  ) AS published
FROM first_steps;

• WITH creates the intermediate first_steps relation.
• min finds each user's first event of a type.
• FILTER limits rows entering one aggregate.
• Conditions preserve funnel order and its time window.

WITH activated AS (
  SELECT user_id,
         date_trunc('week', min(occurred_at)) AS cohort_week
  FROM product_events
  WHERE event_name = 'project_published'
  GROUP BY user_id
), returned AS (
  SELECT DISTINCT a.user_id, a.cohort_week
  FROM activated a
  JOIN product_events e ON e.user_id = a.user_id
   AND e.event_name = 'project_published'
   AND e.occurred_at >= a.cohort_week + interval '1 week'
   AND e.occurred_at <  a.cohort_week + interval '2 weeks'
)
SELECT a.cohort_week,
       count(*) AS activated_users,
       count(r.user_id) AS retained_users,
       count(r.user_id)::numeric / count(*) AS week_1_retention
FROM activated a
LEFT JOIN returned r USING (user_id, cohort_week)
GROUP BY a.cohort_week
ORDER BY a.cohort_week;

• A user joins a cohort at their first publication.
• DISTINCT prevents frequent publishers from inflating the numerator.
• LEFT JOIN keeps non-retained users in the denominator.
• This definition is calendar week-1, not rolling retention.

SELECT
  date_trunc('month', cancelled_at) AS month,
  count(*) AS cancelled,
  count(*)::numeric /
    nullif(max(active_at_month_start), 0) AS user_churn
FROM subscription_cancellations
GROUP BY date_trunc('month', cancelled_at)
ORDER BY month;

• The denominator is active subscriptions at the start of that period.
• nullif prevents division by zero.
• Revenue churn sums lost recurring revenue instead of users.

function assignVariant(
  experimentKey: string,
  userId: string,
) {
  const bucket = createHash('sha256')
    .update(experimentKey + ':' + userId)
    .digest()
    .readUInt32BE(0) % 10_000;

  return bucket < 5_000 ? 'control' : 'treatment';
}

• Experiment key separates independent tests.
• A deterministic hash repeats assignment on another Nest instance.
• A production implementation versions allocation and stores exposure.
• Use accountId for an account-level feature.

SELECT variant, count(DISTINCT user_id) AS participants
FROM experiment_exposures
WHERE experiment_key = $1
GROUP BY variant;

-- A 50/50 plan expects similar counts.
-- The experiment service runs a statistical SRM check
-- before evaluating the primary metric.

• DISTINCT matches the user randomization unit.
• A material mismatch needs investigation, not manual result correction.
• The threshold depends on sample and allocation; visual inspection alone is insufficient.

const checkoutExperiment = {
  hypothesis:
    'Shorter form increases completed purchases',
  unit: 'user',
  population: 'authenticated users entering checkout',
  primaryMetric: 'purchase within 24h of exposure',
  guardrails: ['payment_error_rate', 'refund_rate'],
  allocation: { control: 0.5, treatment: 0.5 },
  mde: 0.02,
  stoppingRule: 'planned sample and full business weeks',
};

• Clarify whether MDE 0.02 means absolute percentage points or relative uplift.
• Guardrails need acceptable limits, not names alone.
• A frozen plan reduces freedom to select a convenient post-hoc result.