diff --git a/apps/docs/anonymous-analytics.mdx b/apps/docs/anonymous-analytics.mdx
index b2053d7c2..e1bfbf7d7 100644
--- a/apps/docs/anonymous-analytics.mdx
+++ b/apps/docs/anonymous-analytics.mdx
@@ -15,8 +15,13 @@ When anonymous telemetry is enabled, your deployment sends:
 
 - **Usage events** — page views (as route patterns like `/task/[taskId]`,
   never actual URLs or IDs) and product events such as tasks being created
-  or settling as completed, failed, or canceled, with non-identifying facts
-  like the harness, model, source surface, and sandbox provider used.
+  or settling as completed, failed, or canceled, plus setup progress such as
+  reaching authenticated setup and configuring or connecting communications,
+  source-control, inference, and sandbox providers. Setup events include only
+  the provider type and, where Roomote can determine it from deployment state,
+  whether it was configured before the wizard. Other events include
+  non-identifying facts like the harness, model, source surface, and sandbox
+  provider used.
 - **A daily instance report** — aggregate deployment metadata and usage:
   setup timestamps; counts of users, environments, and connected repositories;
   task, model, token, and cost totals for the past day; pull-request statistics
diff --git a/apps/web/src/app/(onboarding)/setup/SetupBootstrapFlow.tsx b/apps/web/src/app/(onboarding)/setup/SetupBootstrapFlow.tsx
index 464d1a279..f023ac2e5 100644
--- a/apps/web/src/app/(onboarding)/setup/SetupBootstrapFlow.tsx
+++ b/apps/web/src/app/(onboarding)/setup/SetupBootstrapFlow.tsx
@@ -2,7 +2,7 @@
 
 import { AnimatePresence, motion, type Variants } from 'motion/react';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
+import { useMutation, useQuery } from '@tanstack/react-query';
 import { useRouter } from 'next/navigation';
 
 import { useRedirectToSignIn } from '@/hooks/useSignInRedirect';
@@ -94,6 +94,9 @@ export function SetupBootstrapFlow() {
       },
     ),
   );
+  const trackWelcomeSeen = useMutation(
+    trpc.setupBootstrap.trackWelcomeSeen.mutationOptions(),
+  );
   const bootstrapAuthProvider = getBootstrapAuthProvider(
     bootstrapStatus?.authSetup,
     pendingSetupAuthProvider,
@@ -225,11 +228,14 @@ export function SetupBootstrapFlow() {
         >
           {bootstrapStep === 'welcome' && (
             <StepWelcome
-              onContinue={() =>
+              onContinue={() => {
+                trackWelcomeSeen.mutate(
+                  setupToken ? { setupToken } : undefined,
+                );
                 setBootstrapStepWithTransition(
                   getBootstrapStepAfterWelcome(bootstrapStatus.authSetup),
-                )
-              }
+                );
+              }}
             />
           )}
           {bootstrapStep === 'email-account' && (
diff --git a/apps/web/src/app/(onboarding)/setup/SetupSignedInFlow.tsx b/apps/web/src/app/(onboarding)/setup/SetupSignedInFlow.tsx
index cb536f36c..1494b14ab 100644
--- a/apps/web/src/app/(onboarding)/setup/SetupSignedInFlow.tsx
+++ b/apps/web/src/app/(onboarding)/setup/SetupSignedInFlow.tsx
@@ -80,6 +80,9 @@ export function SetupSignedInFlow() {
     useState<ComputeProvider | null>(null);
   const [pendingModelProvider, setPendingModelProvider] =
     useState<SetupModelProviderId | null>(null);
+  const trackWelcomeSeen = useMutation(
+    trpc.setupNew.trackWelcomeSeen.mutationOptions(),
+  );
   const {
     data: setupStatus,
     isLoading: isSetupStatusLoading,
@@ -291,7 +294,14 @@ export function SetupSignedInFlow() {
           animate="center"
           exit="exit"
         >
-          {step === 'welcome' && <StepWelcome onContinue={goToNextStep} />}
+          {step === 'welcome' && (
+            <StepWelcome
+              onContinue={() => {
+                trackWelcomeSeen.mutate();
+                goToNextStep();
+              }}
+            />
+          )}
           {step === 'auth-provider' && (
             <StepAuthProvider
               additionalProviders={['telegram', 'discord']}
diff --git a/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.client.test.tsx b/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.client.test.tsx
index c85730b21..978003e97 100644
--- a/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.client.test.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.client.test.tsx
@@ -8,25 +8,39 @@ import type {
 import { fireEvent, render, screen } from '@testing-library/react';
 import type { SetupAuthProviderId, SetupAuthStatus } from '@roomote/types';
 
-const { connectSlackMutateMock, teamsStatusState } = vi.hoisted(() => ({
-  connectSlackMutateMock: vi.fn(),
-  teamsStatusState: {
-    data: {
-      botConfigured: true,
-      botUsesTenantSpecificTokenFlow: false,
-      microsoftAuthConfigured: true,
-      webhookUrl: 'https://roomote.example.com/api/webhooks/teams',
-      openInTeamsUrl:
-        'https://teams.microsoft.com/l/chat/0/0?users=28%3Abot-app-id' as
-          | string
-          | null,
-      botName: 'Roomote',
-      primaryConversationReady: true,
-      primaryConversationType: 'channel' as string | null,
+const { connectSlackMutateMock, trackMilestoneMock, teamsStatusState } =
+  vi.hoisted(() => ({
+    connectSlackMutateMock: vi.fn(),
+    trackMilestoneMock: vi.fn(),
+    teamsStatusState: {
+      data: {
+        botConfigured: true,
+        botUsesTenantSpecificTokenFlow: false,
+        microsoftAuthConfigured: true,
+        webhookUrl: 'https://roomote.example.com/api/webhooks/teams',
+        openInTeamsUrl:
+          'https://teams.microsoft.com/l/chat/0/0?users=28%3Abot-app-id' as
+            | string
+            | null,
+        botName: 'Roomote',
+        primaryConversationReady: true,
+        primaryConversationType: 'channel' as string | null,
+      },
+      isPending: false,
+      isError: false,
     },
-    isPending: false,
-    isError: false,
-  },
+  }));
+
+vi.mock('@tanstack/react-query', () => ({
+  useMutation: () => ({ mutate: trackMilestoneMock }),
+}));
+
+vi.mock('@/trpc/client', () => ({
+  useTRPC: () => ({
+    setupNew: {
+      trackCommsState: { mutationOptions: () => ({}) },
+    },
+  }),
 }));
 
 vi.mock('@/hooks/slack', () => ({
diff --git a/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.tsx b/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.tsx
index 8bc4f825a..34b232425 100644
--- a/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepCommunicationConnect.tsx
@@ -1,10 +1,13 @@
 'use client';
 
+import { useEffect, useRef } from 'react';
+import { useMutation } from '@tanstack/react-query';
 import type { SetupAuthStatus } from '@roomote/types';
 import { toast } from 'sonner';
 
 import { useConnectSlack } from '@/hooks/slack';
 import { useTeamsIntegrationStatus } from '@/hooks/teams';
+import { useTRPC } from '@/trpc/client';
 import { TaskStatusIndicator } from '@/components/sandbox';
 import {
   ArrowRight,
@@ -41,6 +44,7 @@ export function StepCommunicationConnect({
   onBack?: () => void;
   returnPath?: string;
 }) {
+  const trpc = useTRPC();
   const provider = getCommunicationProvider(authSetup);
   const connectSlack = useConnectSlack(returnPath, {
     onSuccess: (url) => {
@@ -49,6 +53,41 @@ export function StepCommunicationConnect({
     onError: () => toast.error('Failed to connect Slack. Please try again.'),
   });
   const teamsIntegrationStatus = useTeamsIntegrationStatus();
+  const configuredTrackedRef = useRef(false);
+  const authedTrackedRef = useRef(false);
+  const trackCommsState = useMutation(
+    trpc.setupNew.trackCommsState.mutationOptions(),
+  );
+  const teamsStatus = teamsIntegrationStatus.data;
+  const teamsConfigured =
+    teamsStatus?.botConfigured === true && teamsStatus.microsoftAuthConfigured;
+  const primaryConversationReady = Boolean(
+    teamsStatus?.primaryConversationReady,
+  );
+  useEffect(() => {
+    if (
+      provider === 'microsoft' &&
+      teamsConfigured &&
+      !configuredTrackedRef.current
+    ) {
+      configuredTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'microsoft',
+      });
+    }
+  }, [provider, teamsConfigured, trackCommsState]);
+  useEffect(() => {
+    if (
+      provider === 'microsoft' &&
+      primaryConversationReady &&
+      !authedTrackedRef.current
+    ) {
+      authedTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'microsoft',
+      });
+    }
+  }, [primaryConversationReady, provider, trackCommsState]);
   const skipLink = (
     <button
       type="button"
@@ -59,16 +98,9 @@ export function StepCommunicationConnect({
     </button>
   );
   if (provider === 'microsoft') {
-    const teamsStatus = teamsIntegrationStatus.data;
     const openInTeamsUrl = teamsStatus?.openInTeamsUrl ?? null;
     const teamsBotName = teamsStatus?.botName?.trim() || 'Roomote';
-    const teamsReady =
-      teamsStatus?.botConfigured === true &&
-      teamsStatus.microsoftAuthConfigured &&
-      openInTeamsUrl !== null;
-    const primaryConversationReady = Boolean(
-      teamsStatus?.primaryConversationReady,
-    );
+    const teamsReady = teamsConfigured && openInTeamsUrl !== null;
 
     return (
       <div className="relative w-full max-w-xl space-y-6 py-2 md:py-0">
diff --git a/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.client.test.tsx b/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.client.test.tsx
index d4353fe82..db17706eb 100644
--- a/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.client.test.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.client.test.tsx
@@ -47,14 +47,17 @@ vi.mock('@tanstack/react-query', () => ({
     isError: false,
   }),
   useMutation: (options: {
-    onSuccess: (result: unknown) => Promise<void>;
+    onSuccess?: (result: unknown) => Promise<void>;
   }) => ({
     isPending: false,
-    mutate: () =>
-      void options.onSuccess({
-        telegramWebhook: null,
-        discord: { registered: false, error: 'gateway unavailable' },
-      }),
+    mutate: () => {
+      if (options.onSuccess) {
+        void options.onSuccess({
+          telegramWebhook: null,
+          discord: { registered: false, error: 'gateway unavailable' },
+        });
+      }
+    },
   }),
   useQueryClient: () => ({ invalidateQueries: invalidateQueriesMock }),
 }));
@@ -71,6 +74,9 @@ vi.mock('@/trpc/client', () => ({
     linkedAccounts: {
       discord: { queryKey: () => ['linkedAccounts.discord'] },
     },
+    setupNew: {
+      trackCommsState: { mutationOptions: () => ({}) },
+    },
   }),
 }));
 
diff --git a/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.tsx b/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.tsx
index d778d54e3..fbef92ca2 100644
--- a/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepDiscordSetup.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { toast } from 'sonner';
 
@@ -37,6 +37,11 @@ export function StepDiscordSetup({
   const [clearedSavedValues, setClearedSavedValues] = useState<
     Record<string, boolean>
   >({});
+  const configuredTrackedRef = useRef(false);
+  const authedTrackedRef = useRef(false);
+  const trackCommsState = useMutation(
+    trpc.setupNew.trackCommsState.mutationOptions(),
+  );
   const provider = useMemo(
     () => status.data?.providers.find((item) => item.id === 'discord') ?? null,
     [status.data?.providers],
@@ -45,6 +50,11 @@ export function StepDiscordSetup({
   const save = useMutation(
     trpc.comms.saveAuthConfig.mutationOptions({
       onSuccess: async (result) => {
+        setCredentialsSaved(true);
+        configuredTrackedRef.current = true;
+        trackCommsState.mutate({
+          provider: 'discord',
+        });
         await Promise.all([
           queryClient.invalidateQueries({
             queryKey: trpc.comms.status.queryKey(),
@@ -58,12 +68,31 @@ export function StepDiscordSetup({
             `Discord was saved, but Roomote could not finish connecting: ${result.discord.error ?? 'unknown error'}`,
           );
         }
-        setCredentialsSaved(true);
       },
       onError: (error) => toast.error(error.message),
     }),
   );
   const isConfigured = credentialsSaved || provider?.setupSatisfied === true;
+  useEffect(() => {
+    if (
+      provider?.setupSatisfied === true &&
+      !credentialsSaved &&
+      !configuredTrackedRef.current
+    ) {
+      configuredTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'discord',
+      });
+    }
+  }, [credentialsSaved, provider?.setupSatisfied, trackCommsState]);
+  useEffect(() => {
+    if (discordAccount.data?.mapping && !authedTrackedRef.current) {
+      authedTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'discord',
+      });
+    }
+  }, [discordAccount.data?.mapping, trackCommsState]);
   const isActionDisabled =
     save.isPending ||
     status.isLoading ||
diff --git a/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.client.test.tsx b/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.client.test.tsx
index 69d4a8507..23ad595b2 100644
--- a/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.client.test.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.client.test.tsx
@@ -37,13 +37,16 @@ vi.mock('@tanstack/react-query', () => ({
     isError: false,
   }),
   useMutation: (options: {
-    onSuccess: (result: unknown) => Promise<void>;
+    onSuccess?: (result: unknown) => Promise<void>;
   }) => ({
     isPending: false,
-    mutate: () =>
-      void options.onSuccess({
-        telegramWebhook: { registered: false, error: 'network unavailable' },
-      }),
+    mutate: () => {
+      if (options.onSuccess) {
+        void options.onSuccess({
+          telegramWebhook: { registered: false, error: 'network unavailable' },
+        });
+      }
+    },
   }),
   useQueryClient: () => ({ invalidateQueries: invalidateQueriesMock }),
 }));
@@ -60,6 +63,9 @@ vi.mock('@/trpc/client', () => ({
     linkedAccounts: {
       telegram: { queryKey: () => ['linkedAccounts.telegram'] },
     },
+    setupNew: {
+      trackCommsState: { mutationOptions: () => ({}) },
+    },
   }),
 }));
 
diff --git a/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.tsx b/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.tsx
index 1e03176b1..023594e78 100644
--- a/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.tsx
+++ b/apps/web/src/app/(onboarding)/setup/StepTelegramSetup.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { toast } from 'sonner';
 
@@ -37,6 +37,11 @@ export function StepTelegramSetup({
   const [clearedSavedValues, setClearedSavedValues] = useState<
     Record<string, boolean>
   >({});
+  const configuredTrackedRef = useRef(false);
+  const authedTrackedRef = useRef(false);
+  const trackCommsState = useMutation(
+    trpc.setupNew.trackCommsState.mutationOptions(),
+  );
   const provider = useMemo(
     () => status.data?.providers.find((item) => item.id === 'telegram') ?? null,
     [status.data?.providers],
@@ -45,6 +50,11 @@ export function StepTelegramSetup({
   const save = useMutation(
     trpc.comms.saveAuthConfig.mutationOptions({
       onSuccess: async (result) => {
+        setCredentialsSaved(true);
+        configuredTrackedRef.current = true;
+        trackCommsState.mutate({
+          provider: 'telegram',
+        });
         await Promise.all([
           queryClient.invalidateQueries({
             queryKey: trpc.comms.status.queryKey(),
@@ -58,12 +68,31 @@ export function StepTelegramSetup({
             `Telegram was saved, but Roomote could not connect the bot: ${result.telegramWebhook.error ?? 'unknown error'}`,
           );
         }
-        setCredentialsSaved(true);
       },
       onError: (error) => toast.error(error.message),
     }),
   );
   const isConfigured = credentialsSaved || provider?.setupSatisfied === true;
+  useEffect(() => {
+    if (
+      provider?.setupSatisfied === true &&
+      !credentialsSaved &&
+      !configuredTrackedRef.current
+    ) {
+      configuredTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'telegram',
+      });
+    }
+  }, [credentialsSaved, provider?.setupSatisfied, trackCommsState]);
+  useEffect(() => {
+    if (telegramAccount.data?.mapping && !authedTrackedRef.current) {
+      authedTrackedRef.current = true;
+      trackCommsState.mutate({
+        provider: 'telegram',
+      });
+    }
+  }, [telegramAccount.data?.mapping, trackCommsState]);
   const isActionDisabled =
     save.isPending ||
     status.isLoading ||
diff --git a/apps/web/src/lib/server/setup-funnel-telemetry.test.ts b/apps/web/src/lib/server/setup-funnel-telemetry.test.ts
new file mode 100644
index 000000000..f0a5b94b0
--- /dev/null
+++ b/apps/web/src/lib/server/setup-funnel-telemetry.test.ts
@@ -0,0 +1,192 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  createEmptySetupNewState,
+  type SetupAuthStatus,
+  type SetupComputeStatus,
+  type SetupModelStatus,
+  type SetupSourceControlStatus,
+} from '@roomote/types';
+
+import {
+  evaluateSetupFunnelMilestones,
+  mergeSetupFunnelMilestones,
+} from './setup-funnel-telemetry';
+
+describe('setup funnel telemetry', () => {
+  it('records each deployment milestone only once', () => {
+    const result = mergeSetupFunnelMilestones(
+      {
+        authed: { at: '2026-08-01T00:00:00.000Z' },
+      },
+      [
+        { milestone: 'authed' },
+        {
+          milestone: 'comms_configured',
+          provider: 'slack',
+          preexisting: false,
+        },
+        {
+          milestone: 'comms_configured',
+          provider: 'microsoft',
+          preexisting: false,
+        },
+      ],
+      '2026-08-02T00:00:00.000Z',
+    );
+
+    expect(result.inserted).toEqual([
+      {
+        milestone: 'comms_configured',
+        provider: 'slack',
+        preexisting: false,
+      },
+    ]);
+    expect(result.milestones.comms_configured).toEqual({
+      at: '2026-08-02T00:00:00.000Z',
+      provider: 'slack',
+      preexisting: false,
+    });
+  });
+
+  it('derives achieved milestones from the setup status contracts', () => {
+    const setupNewState = {
+      ...createEmptySetupNewState(),
+      authProvider: 'slack' as const,
+      modelProvider: 'openai' as const,
+      sourceControlProvider: 'github' as const,
+      computeProvider: 'modal' as const,
+    };
+    const authSetup = {
+      selectedProvider: 'slack',
+      runtimeConfiguredProvider: null,
+      providers: [{ id: 'slack', setupSatisfied: true }],
+    } as unknown as SetupAuthStatus;
+    const modelSetup = {
+      setupSatisfied: true,
+      persistedProviderId: 'openai',
+      runtimeProviderId: null,
+      preselectedProvider: 'openai',
+    } as unknown as SetupModelStatus;
+    const sourceControlSetup = {
+      selectedProvider: 'github',
+      runtimeConfiguredProvider: null,
+      connectedProvider: 'github',
+      setupSatisfied: true,
+      providers: [
+        { provider: 'github', configStepSatisfied: true, connected: true },
+      ],
+    } as unknown as SetupSourceControlStatus;
+    const computeSetup = {
+      selectedProvider: 'modal',
+      runtimeDefaultProvider: null,
+      persistedDefaultProvider: 'modal',
+      providers: [{ provider: 'modal', configSatisfied: true }],
+    } as unknown as SetupComputeStatus;
+
+    expect(
+      evaluateSetupFunnelMilestones({
+        setupNewState,
+        hasSlack: true,
+        authSetup,
+        modelSetup,
+        sourceControlSetup,
+        computeSetup,
+      }),
+    ).toEqual([
+      { milestone: 'authed' },
+      {
+        milestone: 'comms_configured',
+        provider: 'slack',
+        preexisting: false,
+      },
+      {
+        milestone: 'comms_authed',
+        provider: 'slack',
+        preexisting: false,
+      },
+      {
+        milestone: 'inference_configured',
+        provider: 'openai',
+        preexisting: false,
+      },
+      {
+        milestone: 'source_control_configured',
+        provider: 'github',
+        preexisting: false,
+      },
+      {
+        milestone: 'source_control_authed',
+        provider: 'github',
+        preexisting: false,
+      },
+      {
+        milestone: 'sandbox_configured',
+        provider: 'modal',
+        preexisting: false,
+      },
+    ]);
+  });
+
+  it('tags provider state discovered before a wizard choice as preexisting', () => {
+    const setupNewState = createEmptySetupNewState();
+    const authSetup = {
+      selectedProvider: null,
+      runtimeConfiguredProvider: null,
+      preselectedProvider: 'microsoft',
+      providers: [{ id: 'microsoft', setupSatisfied: true }],
+    } as unknown as SetupAuthStatus;
+    const modelSetup = {
+      setupSatisfied: true,
+      persistedProviderId: null,
+      runtimeProviderId: 'anthropic',
+      preselectedProvider: 'anthropic',
+    } as unknown as SetupModelStatus;
+    const sourceControlSetup = {
+      selectedProvider: null,
+      runtimeConfiguredProvider: null,
+      connectedProvider: null,
+      preselectedProvider: 'gitlab',
+      setupSatisfied: false,
+      providers: [{ provider: 'gitlab', configStepSatisfied: true }],
+    } as unknown as SetupSourceControlStatus;
+    const computeSetup = {
+      selectedProvider: 'docker',
+      runtimeDefaultProvider: 'docker',
+      persistedDefaultProvider: null,
+      providers: [{ provider: 'docker', configSatisfied: true }],
+    } as unknown as SetupComputeStatus;
+
+    const milestones = evaluateSetupFunnelMilestones({
+      setupNewState,
+      hasSlack: false,
+      authSetup,
+      modelSetup,
+      sourceControlSetup,
+      computeSetup,
+    });
+
+    expect(milestones.slice(1)).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          milestone: 'comms_configured',
+          provider: 'microsoft',
+          preexisting: true,
+        }),
+        expect.objectContaining({
+          milestone: 'source_control_configured',
+          provider: 'gitlab',
+          preexisting: true,
+        }),
+        expect.objectContaining({
+          milestone: 'inference_configured',
+          preexisting: true,
+        }),
+        expect.objectContaining({
+          milestone: 'sandbox_configured',
+          preexisting: true,
+        }),
+      ]),
+    );
+  });
+});
diff --git a/apps/web/src/lib/server/setup-funnel-telemetry.ts b/apps/web/src/lib/server/setup-funnel-telemetry.ts
new file mode 100644
index 000000000..c2aa41fc2
--- /dev/null
+++ b/apps/web/src/lib/server/setup-funnel-telemetry.ts
@@ -0,0 +1,227 @@
+import { db, deploymentSettings, eq, sql } from '@roomote/db/server';
+import {
+  captureActivationSetupMilestone,
+  isAnonymousAnalyticsEnabled,
+} from '@roomote/telemetry/server';
+import type {
+  ActivationSetupMilestone,
+  ActivationSetupMilestoneProperties,
+} from '@roomote/telemetry';
+import type {
+  SetupAuthStatus,
+  SetupComputeStatus,
+  SetupModelStatus,
+  SetupNewState,
+  SetupSourceControlStatus,
+} from '@roomote/types';
+
+const METADATA_KEY = 'setup_funnel_milestones';
+
+type SetupFunnelMilestoneInput = ActivationSetupMilestoneProperties & {
+  milestone: ActivationSetupMilestone;
+};
+
+type RecordedSetupFunnelMilestone = ActivationSetupMilestoneProperties & {
+  at: string;
+};
+
+type RecordedSetupFunnelMilestones = Partial<
+  Record<ActivationSetupMilestone, RecordedSetupFunnelMilestone>
+>;
+
+function normalizeMetadata(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function normalizeRecordedMilestones(
+  value: unknown,
+): RecordedSetupFunnelMilestones {
+  return normalizeMetadata(value) as RecordedSetupFunnelMilestones;
+}
+
+export function mergeSetupFunnelMilestones(
+  current: RecordedSetupFunnelMilestones,
+  candidates: SetupFunnelMilestoneInput[],
+  recordedAt: string,
+): {
+  milestones: RecordedSetupFunnelMilestones;
+  inserted: SetupFunnelMilestoneInput[];
+} {
+  const milestones = { ...current };
+  const inserted: SetupFunnelMilestoneInput[] = [];
+
+  for (const candidate of candidates) {
+    if (milestones[candidate.milestone]) {
+      continue;
+    }
+
+    milestones[candidate.milestone] = {
+      at: recordedAt,
+      ...(candidate.provider === undefined
+        ? {}
+        : { provider: candidate.provider }),
+      ...(candidate.preexisting === undefined
+        ? {}
+        : { preexisting: candidate.preexisting }),
+    };
+    inserted.push(candidate);
+  }
+
+  return { milestones, inserted };
+}
+
+export function evaluateSetupFunnelMilestones(input: {
+  setupNewState: SetupNewState;
+  hasSlack: boolean;
+  authSetup: SetupAuthStatus;
+  modelSetup: SetupModelStatus;
+  computeSetup: SetupComputeStatus;
+  sourceControlSetup: SetupSourceControlStatus;
+}): SetupFunnelMilestoneInput[] {
+  const candidates: SetupFunnelMilestoneInput[] = [{ milestone: 'authed' }];
+  const authProvider =
+    input.setupNewState.authProvider ??
+    input.authSetup.runtimeConfiguredProvider ??
+    input.authSetup.selectedProvider ??
+    input.authSetup.preselectedProvider;
+  const authProviderStatus = input.authSetup.providers.find(
+    (provider) => provider.id === authProvider,
+  );
+  const authPreexisting = input.setupNewState.authProvider === null;
+
+  if (authProvider && authProviderStatus?.setupSatisfied) {
+    candidates.push({
+      milestone: 'comms_configured',
+      provider: authProvider,
+      preexisting: authPreexisting,
+    });
+  }
+  if (authProvider === 'slack' && input.hasSlack) {
+    candidates.push({
+      milestone: 'comms_authed',
+      provider: authProvider,
+      preexisting: authPreexisting,
+    });
+  }
+
+  const modelProvider =
+    input.setupNewState.modelProvider ??
+    input.modelSetup.persistedProviderId ??
+    input.modelSetup.runtimeProviderId ??
+    input.modelSetup.preselectedProvider;
+  if (input.modelSetup.setupSatisfied) {
+    candidates.push({
+      milestone: 'inference_configured',
+      provider: modelProvider,
+      preexisting: input.setupNewState.modelProvider === null,
+    });
+  }
+
+  const sourceControlProvider =
+    input.setupNewState.sourceControlProvider ??
+    input.sourceControlSetup.runtimeConfiguredProvider ??
+    input.sourceControlSetup.connectedProvider ??
+    input.sourceControlSetup.selectedProvider ??
+    input.sourceControlSetup.preselectedProvider;
+  const sourceControlProviderStatus = input.sourceControlSetup.providers.find(
+    (provider) => provider.provider === sourceControlProvider,
+  );
+  const sourceControlPreexisting =
+    input.setupNewState.sourceControlProvider === null;
+  if (
+    sourceControlProvider &&
+    sourceControlProviderStatus?.configStepSatisfied
+  ) {
+    candidates.push({
+      milestone: 'source_control_configured',
+      provider: sourceControlProvider,
+      preexisting: sourceControlPreexisting,
+    });
+  }
+  if (sourceControlProvider && input.sourceControlSetup.setupSatisfied) {
+    candidates.push({
+      milestone: 'source_control_authed',
+      provider: sourceControlProvider,
+      preexisting: sourceControlPreexisting,
+    });
+  }
+
+  const computeProvider =
+    input.setupNewState.computeProvider ??
+    input.computeSetup.selectedProvider ??
+    input.computeSetup.runtimeDefaultProvider ??
+    input.computeSetup.persistedDefaultProvider;
+  const computeProviderStatus = input.computeSetup.providers.find(
+    (provider) => provider.provider === computeProvider,
+  );
+  if (computeProvider && computeProviderStatus?.configSatisfied) {
+    candidates.push({
+      milestone: 'sandbox_configured',
+      provider: computeProvider,
+      preexisting: input.setupNewState.computeProvider === null,
+    });
+  }
+
+  return candidates;
+}
+
+export async function recordSetupFunnelMilestones(
+  candidates: SetupFunnelMilestoneInput[],
+): Promise<void> {
+  if (candidates.length === 0 || !(await isAnonymousAnalyticsEnabled())) {
+    return;
+  }
+
+  try {
+    const inserted = await db.transaction(async (tx) => {
+      await tx.execute(
+        sql`SELECT pg_advisory_xact_lock(hashtext('setup-funnel-milestones'))`,
+      );
+      await tx
+        .insert(deploymentSettings)
+        .values({ id: 'default' })
+        .onConflictDoNothing();
+
+      const settings = await tx.query.deploymentSettings.findFirst({
+        where: eq(deploymentSettings.id, 'default'),
+        columns: { metadata: true, setupCompletedAt: true },
+      });
+      if (!settings || settings.setupCompletedAt !== null) {
+        return [];
+      }
+
+      const metadata = normalizeMetadata(settings.metadata);
+      const result = mergeSetupFunnelMilestones(
+        normalizeRecordedMilestones(metadata[METADATA_KEY]),
+        candidates,
+        new Date().toISOString(),
+      );
+      if (result.inserted.length === 0) {
+        return [];
+      }
+
+      await tx
+        .update(deploymentSettings)
+        .set({
+          metadata: sql`jsonb_set(coalesce(${deploymentSettings.metadata}, '{}'::jsonb), ARRAY[${METADATA_KEY}]::text[], ${JSON.stringify(result.milestones)}::jsonb, true)`,
+        })
+        .where(eq(deploymentSettings.id, 'default'));
+
+      return result.inserted;
+    });
+
+    for (const { milestone, provider, preexisting } of inserted) {
+      await captureActivationSetupMilestone(milestone, {
+        ...(provider === undefined ? {} : { provider }),
+        ...(preexisting === undefined ? {} : { preexisting }),
+      });
+    }
+  } catch (error) {
+    console.warn(
+      '[setup-funnel-telemetry] failed to record milestones:',
+      error instanceof Error ? error.message : error,
+    );
+  }
+}
diff --git a/apps/web/src/trpc/commands/setup-new/index.test.ts b/apps/web/src/trpc/commands/setup-new/index.test.ts
index 1ac0123b6..bd0e22c15 100644
--- a/apps/web/src/trpc/commands/setup-new/index.test.ts
+++ b/apps/web/src/trpc/commands/setup-new/index.test.ts
@@ -14,6 +14,11 @@ const {
   mockResolveSavedWorkerImage,
   mockResolveGiteaBaseUrl,
   mockResolveDeploymentEnvVar,
+  mockRecordSetupFunnelMilestones,
+  mockGetLinkedTelegramAccount,
+  mockGetLinkedDiscordAccount,
+  mockGetTeamsIntegrationStatus,
+  mockInvalidateTelegramRuntimeCredentialsCache,
 } = vi.hoisted(() => ({
   mockValidateTeamsBotCredentials: vi.fn(async () => undefined),
   mockTxSelect: vi.fn(),
@@ -33,6 +38,25 @@ const {
     .fn()
     .mockResolvedValue('https://gitea.example.com'),
   mockResolveDeploymentEnvVar: vi.fn().mockResolvedValue(null),
+  mockRecordSetupFunnelMilestones: vi.fn().mockResolvedValue(undefined),
+  mockGetLinkedTelegramAccount: vi.fn(),
+  mockGetLinkedDiscordAccount: vi.fn(),
+  mockGetTeamsIntegrationStatus: vi.fn(),
+  mockInvalidateTelegramRuntimeCredentialsCache: vi.fn(),
+}));
+
+vi.mock('@/lib/server/setup-funnel-telemetry', () => ({
+  evaluateSetupFunnelMilestones: vi.fn(() => []),
+  recordSetupFunnelMilestones: mockRecordSetupFunnelMilestones,
+}));
+
+vi.mock('../linked-accounts', () => ({
+  getLinkedTelegramAccountCommand: mockGetLinkedTelegramAccount,
+  getLinkedDiscordAccountCommand: mockGetLinkedDiscordAccount,
+}));
+
+vi.mock('../teams', () => ({
+  getTeamsIntegrationStatusCommand: mockGetTeamsIntegrationStatus,
 }));
 
 vi.mock('../compute/compute-provisioning', async (importOriginal) => {
@@ -123,6 +147,8 @@ vi.mock('@roomote/db/server', () => ({
     identityErrorCode: null,
   })),
   invalidateTeamsBotRuntimeCredentialsCache: vi.fn(),
+  invalidateTelegramRuntimeCredentialsCache:
+    mockInvalidateTelegramRuntimeCredentialsCache,
   slackInstallations: {},
   slackUserMappings: {},
   sql: vi.fn(),
@@ -226,6 +252,9 @@ import {
   saveSetupNewSourceControlConfigCommand,
   saveSetupNewSourceControlProviderChoiceCommand,
   startSetupNewOnboardingTaskCommand,
+  trackSetupBootstrapWelcomeSeenCommand,
+  trackSetupCommsStateCommand,
+  trackSetupWelcomeSeenCommand,
 } from './index';
 import {
   TaskPayloadKind,
@@ -440,6 +469,64 @@ describe('setup-new auth config commands', () => {
   });
 });
 
+describe('setup funnel milestone commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSetupTokenState.requiredToken = undefined;
+    mockSetupTokenState.inviteCookieToken = null;
+    mockGetLinkedTelegramAccount.mockResolvedValue({
+      configured: false,
+      mapping: null,
+    });
+    mockGetLinkedDiscordAccount.mockResolvedValue({
+      configured: false,
+      mapping: null,
+    });
+  });
+
+  it('records welcome after an admin reaches signed-in setup', async () => {
+    await trackSetupWelcomeSeenCommand(buildMockAuth());
+
+    expect(mockRecordSetupFunnelMilestones).toHaveBeenCalledWith([
+      { milestone: 'welcome' },
+    ]);
+  });
+
+  it('requires a valid bootstrap token before recording welcome', async () => {
+    mockSetupTokenState.requiredToken = 'expected-token';
+
+    await expect(
+      trackSetupBootstrapWelcomeSeenCommand({ setupToken: 'wrong-token' }),
+    ).rejects.toThrow('A valid setup token is required.');
+    expect(mockRecordSetupFunnelMilestones).not.toHaveBeenCalled();
+  });
+
+  it('derives communications milestones from authoritative account state', async () => {
+    mockGetLinkedTelegramAccount.mockResolvedValue({
+      configured: true,
+      mapping: { telegramUserId: '42' },
+    });
+
+    await trackSetupCommsStateCommand(buildMockAuth(), {
+      provider: 'telegram',
+    });
+
+    expect(mockRecordSetupFunnelMilestones).toHaveBeenCalledWith([
+      {
+        milestone: 'comms_configured',
+        provider: 'telegram',
+      },
+      {
+        milestone: 'comms_authed',
+        provider: 'telegram',
+      },
+    ]);
+    expect(
+      mockInvalidateTelegramRuntimeCredentialsCache,
+    ).toHaveBeenCalledOnce();
+  });
+});
+
 describe('setup bootstrap token gating', () => {
   beforeEach(() => {
     vi.clearAllMocks();
diff --git a/apps/web/src/trpc/commands/setup-new/index.ts b/apps/web/src/trpc/commands/setup-new/index.ts
index 120e0488d..903e9235a 100644
--- a/apps/web/src/trpc/commands/setup-new/index.ts
+++ b/apps/web/src/trpc/commands/setup-new/index.ts
@@ -34,6 +34,7 @@ import {
   resolveDeploymentEnvVar,
   purgeSavedDeploymentWorkerImage,
   resolveTelegramRuntimeCredentials,
+  invalidateTelegramRuntimeCredentialsCache,
   resolveDiscordRuntimeCredentials,
   invalidateTeamsBotRuntimeCredentialsCache,
   isChatGptSubscriptionConnected,
@@ -109,6 +110,10 @@ import {
 } from '@roomote/types';
 
 import type { UserAuthSuccess } from '@/types';
+import {
+  evaluateSetupFunnelMilestones,
+  recordSetupFunnelMilestones,
+} from '@/lib/server/setup-funnel-telemetry';
 import {
   assertSetupTokenValid,
   getLatestTaskRunsByTaskId,
@@ -130,6 +135,11 @@ import {
   normalizeRepositorySelection,
 } from '@/lib/setup-new';
 import type { QueuedOnboardingTask } from './types';
+import {
+  getLinkedDiscordAccountCommand,
+  getLinkedTelegramAccountCommand,
+} from '../linked-accounts';
+import { getTeamsIntegrationStatusCommand } from '../teams';
 
 import {
   assertAdmin,
@@ -1448,7 +1458,7 @@ export async function getSetupNewStatusCommand(auth: UserAuthSuccess) {
     gitlabBaseUrl,
   });
 
-  return {
+  const status = {
     hasGitHub: baseStatus.hasGitHub,
     hasSlack: slackAccessStatus.hasSlackUserMapping,
     hasSlackInstallation: slackAccessStatus.hasSlackInstallation,
@@ -1468,6 +1478,12 @@ export async function getSetupNewStatusCommand(auth: UserAuthSuccess) {
     computeSetup,
     sourceControlSetup,
   };
+
+  if (baseStatus.setupCompletedAt === null) {
+    await recordSetupFunnelMilestones(evaluateSetupFunnelMilestones(status));
+  }
+
+  return status;
 }
 
 export async function saveSetupNewModelConfigCommand(
@@ -2340,6 +2356,66 @@ export async function getSetupBootstrapStatusCommand(input?: {
   };
 }
 
+export async function trackSetupWelcomeSeenCommand(auth: UserAuthSuccess) {
+  assertAdmin(auth);
+  await recordSetupFunnelMilestones([{ milestone: 'welcome' }]);
+}
+
+export async function trackSetupCommsStateCommand(
+  auth: UserAuthSuccess,
+  input: {
+    provider: 'microsoft' | 'telegram' | 'discord';
+  },
+) {
+  assertAdmin(auth);
+  const candidates = [];
+
+  if (input.provider === 'microsoft') {
+    const status = await getTeamsIntegrationStatusCommand(auth);
+    if (status.botConfigured && status.microsoftAuthConfigured) {
+      candidates.push({
+        milestone: 'comms_configured' as const,
+        provider: input.provider,
+      });
+    }
+    if (status.primaryConversationReady) {
+      candidates.push({
+        milestone: 'comms_authed' as const,
+        provider: input.provider,
+      });
+    }
+  } else {
+    if (input.provider === 'telegram') {
+      invalidateTelegramRuntimeCredentialsCache();
+    }
+    const status =
+      input.provider === 'telegram'
+        ? await getLinkedTelegramAccountCommand(auth)
+        : await getLinkedDiscordAccountCommand(auth);
+    if (status.configured) {
+      candidates.push({
+        milestone: 'comms_configured' as const,
+        provider: input.provider,
+      });
+    }
+    if (status.mapping) {
+      candidates.push({
+        milestone: 'comms_authed' as const,
+        provider: input.provider,
+      });
+    }
+  }
+
+  await recordSetupFunnelMilestones(candidates);
+}
+
+export async function trackSetupBootstrapWelcomeSeenCommand(input?: {
+  setupToken?: string;
+}) {
+  assertSetupTokenValid(await resolveSetupTokenInput(input?.setupToken));
+  await recordSetupFunnelMilestones([{ milestone: 'welcome' }]);
+}
+
 export async function saveSetupBootstrapAuthProviderChoiceCommand(input: {
   provider: SetupAuthProviderId;
   setupToken?: string;
diff --git a/apps/web/src/trpc/routers/_app.ts b/apps/web/src/trpc/routers/_app.ts
index c996e37b8..f47dd2914 100644
--- a/apps/web/src/trpc/routers/_app.ts
+++ b/apps/web/src/trpc/routers/_app.ts
@@ -252,6 +252,9 @@ import {
   cancelSetupNewOnboardingTaskCommand,
   resetSetupNewSelectionCommand,
   ensureSetupNewDefaultAgentsCommand,
+  trackSetupBootstrapWelcomeSeenCommand,
+  trackSetupCommsStateCommand,
+  trackSetupWelcomeSeenCommand,
 } from '../commands/setup-new';
 import {
   getOnboardingStatusCommand,
@@ -2251,6 +2254,20 @@ export const appRouter = createRouter({
       getSetupNewStatusCommand(auth),
     ),
 
+    trackWelcomeSeen: protectedProcedure.mutation(({ ctx: { auth } }) =>
+      trackSetupWelcomeSeenCommand(auth),
+    ),
+
+    trackCommsState: protectedProcedure
+      .input(
+        z.object({
+          provider: z.enum(['microsoft', 'telegram', 'discord']),
+        }),
+      )
+      .mutation(({ ctx: { auth }, input }) =>
+        trackSetupCommsStateCommand(auth, input),
+      ),
+
     saveAuthProviderChoice: protectedProcedure
       .input(
         z.object({
@@ -2389,6 +2406,16 @@ export const appRouter = createRouter({
       )
       .query(({ input }) => getSetupBootstrapStatusCommand(input)),
 
+    trackWelcomeSeen: publicProcedure
+      .input(
+        z
+          .object({
+            setupToken: z.string().optional(),
+          })
+          .optional(),
+      )
+      .mutation(({ input }) => trackSetupBootstrapWelcomeSeenCommand(input)),
+
     saveAuthProviderChoice: publicProcedure
       .input(
         z.object({
diff --git a/packages/telemetry/src/__tests__/telemetry.test.ts b/packages/telemetry/src/__tests__/telemetry.test.ts
index 1026e2299..c858c29dc 100644
--- a/packages/telemetry/src/__tests__/telemetry.test.ts
+++ b/packages/telemetry/src/__tests__/telemetry.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from 'vitest';
 
 import {
   buildActivationPrMergedProperties,
+  buildActivationSetupMilestoneProperties,
   buildActivationTaskProperties,
   PAGEVIEW_EVENT,
   TELEMETRY_EVENT_NAME_PATTERN,
@@ -186,6 +187,16 @@ describe('TELEMETRY_EVENT_NAME_PATTERN', () => {
 });
 
 describe('activation event properties', () => {
+  it('allows only provider classifications on setup milestones', () => {
+    expect(
+      buildActivationSetupMilestoneProperties({
+        provider: 'slack',
+        preexisting: true,
+      }),
+    ).toEqual({ provider: 'slack', preexisting: true });
+    expect(buildActivationSetupMilestoneProperties({})).toBeUndefined();
+  });
+
   it('allows only safe task routing classifications', () => {
     expect(
       buildActivationTaskProperties({
diff --git a/packages/telemetry/src/index.ts b/packages/telemetry/src/index.ts
index ae82ebd40..5afea2d51 100644
--- a/packages/telemetry/src/index.ts
+++ b/packages/telemetry/src/index.ts
@@ -44,6 +44,45 @@ export const ACTIVATION_ENVIRONMENT_SOURCES = [
 export type ActivationEnvironmentSource =
   (typeof ACTIVATION_ENVIRONMENT_SOURCES)[number];
 
+export const ACTIVATION_SETUP_MILESTONES = [
+  'welcome',
+  'authed',
+  'comms_configured',
+  'comms_authed',
+  'source_control_configured',
+  'source_control_authed',
+  'inference_configured',
+  'sandbox_configured',
+] as const;
+
+export type ActivationSetupMilestone =
+  (typeof ACTIVATION_SETUP_MILESTONES)[number];
+
+export type ActivationSetupMilestoneProperties = {
+  provider?: string;
+  preexisting?: boolean;
+};
+
+export function buildActivationSetupMilestoneProperties(
+  properties: ActivationSetupMilestoneProperties,
+): TelemetryEventProperties | undefined {
+  if (
+    properties.provider === undefined &&
+    properties.preexisting === undefined
+  ) {
+    return undefined;
+  }
+
+  return {
+    ...(properties.provider === undefined
+      ? {}
+      : { provider: properties.provider }),
+    ...(properties.preexisting === undefined
+      ? {}
+      : { preexisting: properties.preexisting }),
+  };
+}
+
 export type ActivationTaskProperties = {
   workflow: string;
   surface: string;
diff --git a/packages/telemetry/src/server/index.ts b/packages/telemetry/src/server/index.ts
index f5951a1c4..b33cfeeac 100644
--- a/packages/telemetry/src/server/index.ts
+++ b/packages/telemetry/src/server/index.ts
@@ -30,8 +30,11 @@ import {
   type PingVersionCheckResponse,
   type TelemetryEventProperties,
   type ActivationEnvironmentSource,
+  type ActivationSetupMilestone,
+  type ActivationSetupMilestoneProperties,
   type ActivationTaskProperties,
   buildActivationPrMergedProperties,
+  buildActivationSetupMilestoneProperties,
   buildActivationTaskProperties,
 } from '../index';
 
@@ -319,6 +322,16 @@ export async function captureActivationEnvironmentSaved(
   return captureInstanceEvent('activation_environment_saved', { source });
 }
 
+export async function captureActivationSetupMilestone(
+  milestone: ActivationSetupMilestone,
+  properties: ActivationSetupMilestoneProperties = {},
+): Promise<void> {
+  return captureInstanceEvent(
+    `activation_setup_${milestone}`,
+    buildActivationSetupMilestoneProperties(properties),
+  );
+}
+
 export async function captureActivationTaskCreated(
   properties: ActivationTaskProperties,
 ): Promise<void> {