Run a Free JavaScript A/B Test

You are working in REPLACE_WITH_REPOSITORY.

Your task is to determine whether this JavaScript application has one valid,
decision-relevant A/B test that fits the guide. If it does, implement the
non-production foundation and prove the assignment-to-outcome data path. If it
does not, reject the experiment and explain which smaller rollout or research
method fits better.

Read REPLACE_WITH_GUIDE_URL in full before editing. Also read the repository's
local agent instructions. Treat the operator's instructions, repository truth,
and current official product/framework documentation as authoritative when they
conflict with the guide. Revalidate the guide's tested versions, plan boundaries,
and volatile surfaces before copying an executable step.

Do not invent a hypothesis, business metric, minimum detectable effect, consent
basis, stable identifier, or warehouse schema. Adapt the reference files to the
existing analytics and identity contracts. Complete phase 0 and the safe,
non-production parts of phase 1. Do not start production traffic, create or alter
a live experiment, or make another external write unless I explicitly authorize
that exact action.

Return: the fit or reject decision; assumptions; files changed; commands and
tests run; assignment, exposure, outcome-join, SRM, multiple-exposure, failure,
and rollback receipts; deviations from the guide; and the remaining manual or
production steps. If you cannot fetch the guide URL, stop and ask me for its
Markdown version. Do not proceed from the TL;DR alone.

.env.example
src/
  analytics/
    best-effort.ts
    signup-events.ts
  experimentation/
    device-id.ts
    growthbook.ts
  features/
    signup/
      SignupExperiment.tsx
  App.tsx
  main.tsx
  vite-env.d.ts
tests/
  best-effort.test.ts
  growthbook-assignment.test.ts
  signup-events.test.ts

Managed Warehouse data source (or one existing BYOW data source)
JavaScript/React SDK connection
String feature: signup-flow
Experiment tracking key: signup-flow-v1
Proportion metric: Signup completed
Experiment: Streamlined signup flow

eligible unit
  -> stable identifier
  -> deterministic assignment
  -> real treatment exposure
  -> outcome event
  -> identifier join
  -> metric aggregation
  -> health checks
  -> predeclared decision
  -> rollout and cleanup

Browser on /signup
  |-- device_id in a first-party cookie
  |-- GrowthBook SDK fetches feature definitions
  |-- local SDK evaluation returns control or streamlined
  |-- tracking plug-in sends Experiment Viewed
  |-- form sends Signup Started / Signup Completed
  v
GrowthBook regional event ingestor
  v
Managed ClickHouse warehouse
  |-- experiment_views
  |-- events
  v
GrowthBook assignment query + proportion metric
  v
Health checks, effect estimate, and decision record

node --version
npm --version
npm pkg get dependencies devDependencies scripts
rg -n "analytics|track\(|identify\(|user_id|device_id|anonymous_id|experiment|feature.?flag" src
rg -n "signup|register|create.?account|onboarding" src tests
rg -n "cookie|consent|privacy|localStorage" src

Framework and rendering mode:
Signup route and entry component:
Existing analytics client:
Existing anonymous identifier:
Authenticated user identifier:
Consent gate:
Current signup-start event:
Current signup-complete event:
Current baseline completion rate:
Eligible units per day:
Known bots, QA traffic, or internal traffic filters:

For first-time visitors who render the signup page, replacing the 3-step signup
flow with a 1-page flow will increase 24-hour signup completion from 10.0% to at
least 11.5% without increasing client-side signup errors by more than 0.5
percentage points; if the experiment is healthy and the 95% interval excludes
effects worse than -0.5 points at the fixed sample horizon, ship the streamlined
flow, otherwise retain control or iterate.

const baseline = 0.1;
const relativeMde = 0.15;
const treatment = baseline * (1 + relativeMde);

// z critical values for two-sided alpha=0.05 and power=0.80
const zAlpha = 1.95996398454;
const zPower = 0.84162123357;
const pooled = (baseline + treatment) / 2;
const absoluteDifference = Math.abs(treatment - baseline);

const numerator = Math.pow(
  zAlpha * Math.sqrt(2 * pooled * (1 - pooled)) +
    zPower * Math.sqrt(baseline * (1 - baseline) + treatment * (1 - treatment)),
  2,
);

const perVariation = Math.ceil(numerator / Math.pow(absoluteDifference, 2));

const total = perVariation * 2;
const eligibleUnitsPerDay = 500;

console.log({
  baseline,
  treatment,
  perVariation,
  total,
  estimatedDays: Math.ceil(total / eligibleUnitsPerDay),
});

{
  baseline: 0.1,
  treatment: 0.115,
  perVariation: 6693,
  total: 13386,
  estimatedDays: 27
}

npm install @growthbook/growthbook@1.7.0 @growthbook/growthbook-react@1.7.0
npm install --save-dev vitest@4 jsdom @testing-library/react @testing-library/jest-dom

npm ls @growthbook/growthbook @growthbook/growthbook-react

@growthbook/growthbook@1.7.0
@growthbook/growthbook-react@1.7.0

VITE_GROWTHBOOK_CLIENT_KEY=sdk_REPLACE_WITH_PUBLIC_CLIENT_KEY
VITE_GROWTHBOOK_API_HOST=https://cdn.growthbook.io
VITE_GROWTHBOOK_INGESTOR_HOST=https://us1.gb-ingest.com
VITE_APP_ENVIRONMENT=development
VITE_APP_VERSION=local

VITE_GROWTHBOOK_INGESTOR_HOST=https://eu-west-1.gb-ingest.com

/// <reference types="vite/client" />

interface ImportMetaEnv {
  readonly VITE_GROWTHBOOK_CLIENT_KEY: string;
  readonly VITE_GROWTHBOOK_API_HOST?: string;
  readonly VITE_GROWTHBOOK_INGESTOR_HOST?: string;
  readonly VITE_APP_ENVIRONMENT: string;
  readonly VITE_APP_VERSION: string;
}

interface ImportMeta {
  readonly env: ImportMetaEnv;
}

const COOKIE_NAME = "app_device_id";
const MAX_AGE_SECONDS = 60 * 60 * 24 * 180;

function readCookie(name: string): string | null {
  const encodedName = `${encodeURIComponent(name)}=`;
  const match = document.cookie
    .split(";")
    .map((part) => part.trim())
    .find((part) => part.startsWith(encodedName));

  if (!match) return null;
  return decodeURIComponent(match.slice(encodedName.length));
}

function writeCookie(name: string, value: string): void {
  const secure = window.location.protocol === "https:" ? "; Secure" : "";
  document.cookie = [
    `${encodeURIComponent(name)}=${encodeURIComponent(value)}`,
    "Path=/",
    `Max-Age=${MAX_AGE_SECONDS}`,
    "SameSite=Lax",
    secure,
  ].join("; ");
}

export function getOrCreateDeviceId(): string {
  const existing = readCookie(COOKIE_NAME);
  if (existing) return existing;

  const created = window.crypto.randomUUID();
  writeCookie(COOKIE_NAME, created);
  return created;
}

import { GrowthBook } from "@growthbook/growthbook-react";
import { growthbookTrackingPlugin } from "@growthbook/growthbook/plugins";
import { getOrCreateDeviceId } from "./device-id";

const ALLOWED_EVENT_NAMES = new Set([
  "Experiment Viewed",
  "Feature Evaluated",
  "Signup Started",
  "Signup Completed",
  "Signup Failed",
]);

function required(name: keyof ImportMetaEnv): string {
  const value = import.meta.env[name];
  if (!value) throw new Error(`Missing required environment variable: ${name}`);
  return value;
}

function cleanPageUrl(): string {
  const url = new URL(window.location.href);
  return `${url.origin}${url.pathname}`;
}

function getIngestorHost(): string {
  const configured =
    import.meta.env.VITE_GROWTHBOOK_INGESTOR_HOST ??
    "https://us1.gb-ingest.com";

  const allowed = new Set([
    "https://us1.gb-ingest.com",
    "https://eu-west-1.gb-ingest.com",
  ]);

  if (!allowed.has(configured)) {
    throw new Error(`Unsupported GrowthBook ingestor host: ${configured}`);
  }

  return configured;
}

export const growthbook = new GrowthBook({
  apiHost:
    import.meta.env.VITE_GROWTHBOOK_API_HOST ?? "https://cdn.growthbook.io",
  clientKey: required("VITE_GROWTHBOOK_CLIENT_KEY"),
  attributes: {
    device_id: getOrCreateDeviceId(),
    app_environment: required("VITE_APP_ENVIRONMENT"),
    app_version: required("VITE_APP_VERSION"),
  },
  url: cleanPageUrl(),
  plugins: [
    growthbookTrackingPlugin({
      ingestorHost: getIngestorHost(),
      eventFilter: ({ eventName }) => ALLOWED_EVENT_NAMES.has(eventName),
      transport: "auto",
    }),
  ],
});

export async function initializeGrowthBook(): Promise<void> {
  const result = await growthbook.init({
    timeout: 1_500,
    streaming: false,
  });

  if (!result.success) {
    console.warn("GrowthBook initialized without a fresh feature payload", {
      source: result.source,
      message: result.error?.message,
    });
  }
}

export function setAuthenticatedUser(userId: string): void {
  growthbook.updateAttributes({ user_id: userId });
}

import { growthbook } from "../experimentation/growthbook";

export type SignupFlow = "control" | "streamlined";
export type SignupMethod = "email" | "google" | "github";
export type SignupFailureCode =
  | "validation"
  | "duplicate_account"
  | "rate_limited"
  | "server_error"
  | "network_error";

const SCHEMA_VERSION = 1;

export function trackSignupStarted(flow: SignupFlow): Promise<void> {
  return growthbook.logEvent("Signup Started", {
    schema_version: SCHEMA_VERSION,
    flow,
  });
}

export function trackSignupCompleted(input: {
  flow: SignupFlow;
  method: SignupMethod;
}): Promise<void> {
  return growthbook.logEvent("Signup Completed", {
    schema_version: SCHEMA_VERSION,
    flow: input.flow,
    method: input.method,
  });
}

export function trackSignupFailed(input: {
  flow: SignupFlow;
  code: SignupFailureCode;
}): Promise<void> {
  return growthbook.logEvent("Signup Failed", {
    schema_version: SCHEMA_VERSION,
    flow: input.flow,
    code: input.code,
  });
}

import { FormEvent, useRef, useState } from "react";
import { useFeatureValue } from "@growthbook/growthbook-react";
import {
  SignupFailureCode,
  SignupFlow,
  SignupMethod,
  trackSignupCompleted,
  trackSignupFailed,
  trackSignupStarted,
} from "../../analytics/signup-events";
import { setAuthenticatedUser } from "../../experimentation/growthbook";
import { runBestEffort } from "../../analytics/best-effort";

type SignupResponse = {
  userId: string;
  redirectTo: string;
};

class SignupRequestError extends Error {
  constructor(public readonly code: SignupFailureCode) {
    super(code);
  }
}

async function createAccount(input: {
  email: string;
  password: string;
  method: SignupMethod;
}): Promise<SignupResponse> {
  const response = await fetch("/api/signup", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    credentials: "same-origin",
    body: JSON.stringify(input),
  });

  if (response.status === 409) {
    throw new SignupRequestError("duplicate_account");
  }
  if (response.status === 422) {
    throw new SignupRequestError("validation");
  }
  if (response.status === 429) {
    throw new SignupRequestError("rate_limited");
  }
  if (!response.ok) {
    throw new SignupRequestError("server_error");
  }

  const value = (await response.json()) as Partial<SignupResponse>;
  if (!value.userId || !value.redirectTo) {
    throw new SignupRequestError("server_error");
  }

  return {
    userId: value.userId,
    redirectTo: value.redirectTo,
  };
}

function normalizeFlow(value: unknown): SignupFlow {
  return value === "streamlined" ? "streamlined" : "control";
}

function toFailureCode(error: unknown): SignupFailureCode {
  if (error instanceof SignupRequestError) return error.code;
  if (error instanceof TypeError) return "network_error";
  return "server_error";
}

export function SignupExperiment() {
  // Evaluating a feature backed by an experiment rule emits the exposure.
  // The explicit fallback keeps the known-good flow during config failure.
  const flow = normalizeFlow(
    useFeatureValue("signup-flow", "control"),
  );

  const started = useRef(false);
  const [submitting, setSubmitting] = useState(false);
  const [error, setError] = useState<string | null>(null);

  function recordFirstInteraction(): void {
    if (started.current) return;
    started.current = true;
    runBestEffort(() => trackSignupStarted(flow));
  }

  async function submit(event: FormEvent<HTMLFormElement>): Promise<void> {
    event.preventDefault();
    setSubmitting(true);
    setError(null);

    const form = new FormData(event.currentTarget);
    const email = String(form.get("email") ?? "");
    const password = String(form.get("password") ?? "");
    const method: SignupMethod = "email";

    try {
      const account = await createAccount({ email, password, method });

      // Analytics must not block navigation after the account exists.
      runBestEffort(() => {
        setAuthenticatedUser(account.userId);
        return trackSignupCompleted({ flow, method });
      });
      window.location.assign(account.redirectTo);
    } catch (caught) {
      const code = toFailureCode(caught);
      runBestEffort(() => trackSignupFailed({ flow, code }));
      setError("We could not create the account. Check the form and try again.");
      setSubmitting(false);
    }
  }

  if (flow === "streamlined") {
    return (
      <main>
        <h1>Create your account</h1>
        <p>Enter your details once to start.</p>
        <form onFocus={recordFirstInteraction} onSubmit={submit}>
          <label>
            Work email
            <input name="email" type="email" autoComplete="email" required />
          </label>
          <label>
            Password
            <input
              name="password"
              type="password"
              autoComplete="new-password"
              minLength={12}
              required
            />
          </label>
          {error ? <p role="alert">{error}</p> : null}
          <button disabled={submitting} type="submit">
            {submitting ? "Creating account…" : "Create account"}
          </button>
        </form>
      </main>
    );
  }

  return (
    <main>
      <h1>Start your account setup</h1>
      <p>Step 1 of 3: Create your login.</p>
      <form onFocus={recordFirstInteraction} onSubmit={submit}>
        <label>
          Work email
          <input name="email" type="email" autoComplete="email" required />
        </label>
        <label>
          Password
          <input
            name="password"
            type="password"
            autoComplete="new-password"
            minLength={12}
            required
          />
        </label>
        {error ? <p role="alert">{error}</p> : null}
        <button disabled={submitting} type="submit">
          {submitting ? "Saving…" : "Continue"}
        </button>
      </form>
    </main>
  );
}

import { SignupExperiment } from "./features/signup/SignupExperiment";

export default function App() {
  if (window.location.pathname === "/signup") {
    return <SignupExperiment />;
  }

  return (
    <main>
      <h1>Example application</h1>
      <a href="/signup">Create an account</a>
    </main>
  );
}

import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { GrowthBookProvider } from "@growthbook/growthbook-react";
import App from "./App";
import {
  growthbook,
  initializeGrowthBook,
} from "./experimentation/growthbook";

async function bootstrap(): Promise<void> {
  await initializeGrowthBook();

  const root = document.getElementById("root");
  if (!root) throw new Error("Missing #root element");

  createRoot(root).render(
    <StrictMode>
      <GrowthBookProvider growthbook={growthbook}>
        <App />
      </GrowthBookProvider>
    </StrictMode>,
  );
}

void bootstrap();

npm run typecheck
npm test -- --run
npm run build

1. The app renders one complete signup flow.
2. Reloading preserves the same flow.
3. The app_device_id cookie remains unchanged.
4. The SDK payload request succeeds or the control fallback renders.
5. A request reaches the configured gb-ingest.com regional host.
6. The request body contains Experiment Viewed with signup-flow-v1.
7. The request body contains device_id but no email or password.

SELECT
  experimentId,
  variationId,
  count() AS exposure_events,
  uniqExact(device_id) AS exposed_devices
FROM experiment_views
WHERE timestamp >= now() - INTERVAL 1 HOUR
  AND experimentId = 'signup-flow-v1'
GROUP BY experimentId, variationId
ORDER BY variationId

experimentId     variationId  exposure_events  exposed_devices
signup-flow-v1   0            >= 1             >= 1
signup-flow-v1   1            >= 1             >= 1

SELECT
  event_name,
  count() AS event_count,
  uniqExact(device_id) AS devices,
  countIf(isNull(device_id) OR device_id = '') AS missing_device_id
FROM events
WHERE timestamp >= now() - INTERVAL 1 HOUR
  AND event_name IN ('Signup Started', 'Signup Completed', 'Signup Failed')
GROUP BY event_name
ORDER BY event_name

WITH first_exposure AS (
  SELECT
    device_id,
    argMin(variationId, timestamp) AS variation_id,
    min(timestamp) AS exposed_at
  FROM experiment_views
  WHERE experimentId = 'signup-flow-v1'
    AND timestamp >= now() - INTERVAL 7 DAY
    AND NOT isNull(device_id)
    AND device_id != ''
  GROUP BY device_id
), completion AS (
  SELECT
    e.device_id,
    min(e.timestamp) AS completed_at
  FROM events AS e
  WHERE e.event_name = 'Signup Completed'
    AND e.timestamp >= now() - INTERVAL 7 DAY
    AND NOT isNull(e.device_id)
    AND e.device_id != ''
  GROUP BY e.device_id
)
SELECT
  x.variation_id,
  count() AS exposed_devices,
  countIf(
    c.completed_at >= x.exposed_at
    AND c.completed_at < x.exposed_at + INTERVAL 24 HOUR
  ) AS completed_devices
FROM first_exposure AS x
LEFT JOIN completion AS c ON c.device_id = x.device_id
GROUP BY x.variation_id
ORDER BY x.variation_id

SELECT
  device_id,
  groupUniqArray(variationId) AS variations,
  min(timestamp) AS first_seen,
  max(timestamp) AS last_seen
FROM experiment_views
WHERE experimentId = 'signup-flow-v1'
  AND timestamp >= now() - INTERVAL 7 DAY
  AND NOT isNull(device_id)
  AND device_id != ''
GROUP BY device_id
HAVING uniqExact(variationId) > 1
ORDER BY first_seen
LIMIT 100

SELECT
  event_name,
  properties.schema_version::Nullable(Int64) AS schema_version,
  properties.flow::Nullable(String) AS flow,
  properties.method::Nullable(String) AS method,
  properties.code::Nullable(String) AS failure_code,
  count() AS events
FROM events
WHERE timestamp >= now() - INTERVAL 1 HOUR
  AND event_name IN ('Signup Started', 'Signup Completed', 'Signup Failed')
GROUP BY event_name, schema_version, flow, method, failure_code
ORDER BY event_name, flow

export type AnalyticsContext = {
  device_id: string;
  user_id?: string;
  app_environment: string;
  app_version: string;
};

export type AnalyticsEvent = {
  event_name: string;
  occurred_at: string;
  properties: Record<string, string | number | boolean | null>;
  context: AnalyticsContext;
};

export interface ProductAnalytics {
  track(event: AnalyticsEvent): void | Promise<void>;
}

event_id       unique and idempotent event identifier
occurred_at    timestamp in UTC
event_name     stable event name
device_id      anonymous assignment identifier
user_id        nullable authenticated identifier
properties     typed columns or JSON

import { GrowthBook } from "@growthbook/growthbook-react";
import { analytics } from "../analytics/client";
import { getOrCreateDeviceId } from "./device-id";

const deviceId = getOrCreateDeviceId();

function context(userId?: string) {
  return {
    device_id: deviceId,
    user_id: userId,
    app_environment: import.meta.env.VITE_APP_ENVIRONMENT,
    app_version: import.meta.env.VITE_APP_VERSION,
  };
}

export const growthbook = new GrowthBook({
  apiHost: "https://cdn.growthbook.io",
  clientKey: import.meta.env.VITE_GROWTHBOOK_CLIENT_KEY,
  attributes: {
    device_id: deviceId,
    app_environment: import.meta.env.VITE_APP_ENVIRONMENT,
    app_version: import.meta.env.VITE_APP_VERSION,
  },
  trackingCallback: (experiment, result, user) => {
    const rawUserId = user.attributes.user_id;
    const userId = typeof rawUserId === "string" ? rawUserId : undefined;

    return analytics.track({
      event_name: "Experiment Viewed",
      occurred_at: new Date().toISOString(),
      properties: {
        experiment_id: experiment.key,
        variation_id: result.key,
        feature_id: result.featureId ?? null,
        hash_attribute: result.hashAttribute,
        hash_value: result.hashValue ?? null,
      },
      context: context(userId),
    });
  },
});

export async function initializeGrowthBook(): Promise<void> {
  const result = await growthbook.init({ timeout: 1_500 });
  if (!result.success) {
    console.warn("GrowthBook feature payload unavailable", {
      source: result.source,
      message: result.error?.message,
    });
  }
}

export function setAuthenticatedUser(userId: string): void {
  growthbook.updateAttributes({ user_id: userId });
}

SELECT
  device_id,
  occurred_at AS timestamp,
  properties:experiment_id::STRING AS experiment_id,
  properties:variation_id::STRING AS variation_id
FROM analytics.product_events
WHERE event_name = 'Experiment Viewed'
  AND device_id IS NOT NULL

SELECT
  occurred_at AS timestamp,
  device_id,
  user_id,
  event_name,
  properties:method::STRING AS signup_method,
  properties:code::STRING AS failure_code
FROM analytics.product_events
WHERE device_id IS NOT NULL

-- Every exposure has one assignment identifier.
SELECT
  COUNT(*) AS exposures,
  COUNT_IF(device_id IS NULL OR device_id = '') AS missing_device_id
FROM analytics.product_events
WHERE event_name = 'Experiment Viewed'
  AND properties:experiment_id::STRING = 'signup-flow-v1';

-- No device has both variations.
SELECT
  device_id,
  COUNT(DISTINCT properties:variation_id::STRING) AS variation_count
FROM analytics.product_events
WHERE event_name = 'Experiment Viewed'
  AND properties:experiment_id::STRING = 'signup-flow-v1'
GROUP BY device_id
HAVING variation_count > 1;

import { describe, expect, it, vi } from "vitest";
import { GrowthBook } from "@growthbook/growthbook";

const features = {
  "signup-flow": {
    defaultValue: "control",
    rules: [
      {
        key: "signup-flow-v1",
        variations: ["control", "streamlined"],
        weights: [0.5, 0.5],
        coverage: 1,
        hashAttribute: "device_id",
      },
    ],
  },
};

describe("signup-flow assignment", () => {
  it("returns the same variation for repeated evaluation", () => {
    const trackingCallback = vi.fn();
    const gb = new GrowthBook({
      features,
      attributes: { device_id: "test-device-001" },
      trackingCallback,
    });

    const first = gb.getFeatureValue("signup-flow", "control");
    const second = gb.getFeatureValue("signup-flow", "control");

    expect(["control", "streamlined"]).toContain(first);
    expect(second).toBe(first);
    expect(trackingCallback).toHaveBeenCalledTimes(1);
    expect(trackingCallback.mock.calls[0][0].key).toBe("signup-flow-v1");
    expect(trackingCallback.mock.calls[0][2].attributes.device_id).toBe(
      "test-device-001",
    );

    gb.destroy();
  });

  it("returns the code fallback when the assignment ID is absent", () => {
    const trackingCallback = vi.fn();
    const gb = new GrowthBook({
      features,
      attributes: {},
      trackingCallback,
    });

    expect(gb.getFeatureValue("signup-flow", "control")).toBe("control");
    expect(trackingCallback).not.toHaveBeenCalled();

    gb.destroy();
  });

  it("can reach both variations across many independent IDs", () => {
    const values = new Set<string>();

    for (let index = 0; index < 200; index += 1) {
      const gb = new GrowthBook({
        features,
        attributes: { device_id: `test-device-${index}` },
      });
      values.add(gb.getFeatureValue("signup-flow", "control"));
      gb.destroy();
    }

    expect(values).toEqual(new Set(["control", "streamlined"]));
  });
});

import { beforeEach, describe, expect, it, vi } from "vitest";

const { logEvent } = vi.hoisted(() => ({
  logEvent: vi.fn(() => Promise.resolve()),
}));

vi.mock("../src/experimentation/growthbook", () => ({
  growthbook: { logEvent },
}));

import {
  trackSignupCompleted,
  trackSignupFailed,
  trackSignupStarted,
} from "../src/analytics/signup-events";

describe("signup event contract", () => {
  beforeEach(() => logEvent.mockClear());

  it("records start with a versioned, non-PII payload", async () => {
    await trackSignupStarted("control");
    expect(logEvent).toHaveBeenCalledWith("Signup Started", {
      schema_version: 1,
      flow: "control",
    });
  });

  it("records completion without accepting form fields", async () => {
    await trackSignupCompleted({
      flow: "streamlined",
      method: "email",
    });

    expect(logEvent).toHaveBeenCalledWith("Signup Completed", {
      schema_version: 1,
      flow: "streamlined",
      method: "email",
    });

    const payload = JSON.stringify(logEvent.mock.calls[0]);
    expect(payload).not.toMatch(/password|@example\.com|access_token/i);
  });

  it("uses allowlisted failure codes instead of raw errors", async () => {
    await trackSignupFailed({
      flow: "control",
      code: "rate_limited",
    });
    expect(logEvent).toHaveBeenCalledWith("Signup Failed", {
      schema_version: 1,
      flow: "control",
      code: "rate_limited",
    });
  });
});

same context + same app_device_id + reload -> same visible flow
missing or timed-out SDK payload -> control flow
control flow -> successful /api/signup -> one completion call -> redirect
streamlined flow -> successful /api/signup -> one completion call -> redirect
failed /api/signup -> no completion event + one allowlisted failure event
password and email -> absent from ingestion request
new browser context -> new app_device_id
consent denied -> no experiment cookie, exposure, or custom event

monthly events ≈ eligible SDK sessions ×
  (experiment exposure + feature usage + signup started probability +
   signup completion probability + signup failure probability)

experiment_key: signup-flow-v1
feature_key: signup-flow
hypothesis: >-
  A one-page signup flow increases 24-hour completion from 10.0% to at
  least 11.5% for first-time signup-page visitors.
unit: device_id
population: first-time visitors who render /signup
variations:
  "0": control
  "1": streamlined
allocation: 50/50
primary_metric: Signup completed
metric_window: 24 hours after first exposure
baseline_rate: 0.10
minimum_worthwhile_effect:
  absolute: 0.015
  relative: 0.15
planned_sample:
  per_variation: 6693
  total: 13386
minimum_runtime_days: 14
maximum_runtime_days: 42
frequentist_alpha: 0.05
planned_power: 0.80
operational_guardrails:
  - signup API 5xx rate
  - client exception rate on /signup
  - p95 signup API latency
  - account-creation duplication rate
decision_owner: product-owner@example.invalid
cleanup_owner: engineering-owner@example.invalid

Signup route rendered before either signup variant is selected

Visitor focused the signup form

decision: ship_streamlined
decided_at: 2026-09-30T18:00:00Z
analysis_window:
  start: 2026-09-01T16:00:00Z
  end: 2026-09-29T16:00:00Z
units:
  control: 6842
  streamlined: 6799
primary_metric:
  name: Signup completed
  control: 0.101
  streamlined: 0.117
  relative_effect: 0.158
  interval: "REPLACE_WITH_EXPORTED_INTERVAL"
health:
  srm: pass
  multiple_exposure: pass
  identifier_coverage: pass
guardrails:
  signup_api_5xx: pass
  client_exceptions: pass
  duplicate_accounts: pass
decision_reason: >-
  The experiment reached its fixed sample and minimum runtime, passed health
  checks, cleared the predeclared primary-metric threshold, and did not cross
  operational harm limits.
follow_up:
  remove_control_path_by: 2026-10-14

[ ] Feature key and tracking key
[ ] Control fallback
[ ] Experimental unit and assignment attribute
[ ] Exact exposure boundary
[ ] Primary metric and window
[ ] Minimum worthwhile effect and sample estimate
[ ] Consent and PII review
[ ] SQL or analytics receipts
[ ] Unit, browser, and failure tests
[ ] Rollback owner
[ ] Expected end date and cleanup owner

const flow = Math.random() < 0.5 ? "control" : "streamlined";

guide: free-ab-test-javascript
depends_on:
  - docs/docs/lib/js.mdx
  - docs/docs/lib/react.mdx
  - docs/docs/features/feature-flag-experiments.mdx
  - docs/docs/features/rules.mdx
  - docs/docs/experimentation-analysis/managed-warehouse.mdx
  - docs/docs/experimentation-analysis/choose-your-data-path.mdx
  - docs/docs/experimentation-analysis/experiment-configuration.mdx
  - docs/docs/experimentation-analysis/experiment-results.mdx
  - docs/docs/metrics/metrics.mdx
  - packages/sdk-js/src/core.ts
  - packages/sdk-js/src/GrowthBook.ts
  - packages/sdk-js/src/plugins/growthbook-tracking.ts
  - packages/sdk-react/src/**
volatile:
  - npm package versions
  - pricing and plan availability
  - managed event allowance
  - ingestion hosts
verification:
  - type-check fixture
  - run Vitest suite
  - build Vite application
  - inspect SDK payload
  - run Managed Warehouse SQL receipts
  - recheck pricing page