diff --git a/packages/shared/src/features/onboarding/shared/FunnelStepper.tsx b/packages/shared/src/features/onboarding/shared/FunnelStepper.tsx
index 8bf6df7728f..c825a81b365 100644
--- a/packages/shared/src/features/onboarding/shared/FunnelStepper.tsx
+++ b/packages/shared/src/features/onboarding/shared/FunnelStepper.tsx
@@ -34,6 +34,7 @@ import {
   FunnelOrganicSignup,
   FunnelBrowserExtension,
   FunnelUploadCv,
+  FunnelPersonaQuiz,
 } from '../steps';
 import { FunnelFact } from '../steps/FunnelFact';
 import { FunnelCheckout } from '../steps/FunnelCheckout';
@@ -77,6 +78,7 @@ const stepComponentMap = {
   [FunnelStepType.PlusCards]: FunnelPlusCards,
   [FunnelStepType.BrowserExtension]: FunnelBrowserExtension,
   [FunnelStepType.UploadCv]: FunnelUploadCv,
+  [FunnelStepType.PersonaQuiz]: FunnelPersonaQuiz,
 } as const;
 
 function FunnelStepComponent<Step extends FunnelStep>(props: Step) {
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/FunnelPersonaQuiz.spec.tsx b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/FunnelPersonaQuiz.spec.tsx
new file mode 100644
index 00000000000..09adef2235b
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/FunnelPersonaQuiz.spec.tsx
@@ -0,0 +1,303 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { FunnelPersonaQuiz } from './index';
+import type { FunnelStepPersonaQuiz } from '../../types/funnel';
+import { FunnelStepType, FunnelStepTransitionType } from '../../types/funnel';
+import { LogEvent } from '../../../../lib/log';
+
+jest.mock('../../../../graphql/common', () => ({
+  gqlClient: { request: jest.fn().mockResolvedValue({ page: { edges: [] } }) },
+}));
+
+// Reveal screen uses TagSelection + Feed primitives that pull in useFeedSettings
+// and useTagAndSource. Stub them so the orchestration tests stay focused on the
+// quiz flow and don't fail on missing context wiring.
+jest.mock('../../../../hooks/useFeedSettings', () => ({
+  __esModule: true,
+  default: () => ({ feedSettings: null, isLoading: false }),
+  getFeedSettingsQueryKey: () => ['feedSettings'],
+}));
+
+jest.mock('../../../../hooks/useTagAndSource', () => ({
+  __esModule: true,
+  default: () => ({
+    onFollowTags: jest.fn(),
+    onUnfollowTags: jest.fn(),
+    onBlockTags: jest.fn(),
+    onUnblockTags: jest.fn(),
+    onFollowSource: jest.fn(),
+    onUnfollowSource: jest.fn(),
+    onBlockSource: jest.fn(),
+    onUnblockSource: jest.fn(),
+  }),
+}));
+
+jest.mock('../../../../hooks/useConditionalFeature', () => ({
+  useConditionalFeature: () => ({ value: false }),
+}));
+
+jest.mock('../../../../contexts/SettingsContext', () => ({
+  useSettingsContext: () => ({
+    sidebarExpanded: false,
+    autoDismissNotifications: false,
+  }),
+  ThemeMode: { Light: 'light', Dark: 'dark' },
+}));
+
+// Heavy Feed component is exercised by other test suites; here we only need it
+// to mount without exploding so the orchestration's inter-question render
+// path is covered.
+jest.mock('../../../../components/Feed', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+const mockFollowTags = jest.fn().mockResolvedValue(undefined);
+jest.mock('../../../../hooks/useMutateFilters', () => ({
+  __esModule: true,
+  default: () => ({
+    followTags: mockFollowTags,
+    unfollowTags: jest.fn(),
+    blockTag: jest.fn(),
+    unblockTag: jest.fn(),
+    followSource: jest.fn(),
+    unfollowSource: jest.fn(),
+    blockSource: jest.fn(),
+    unblockSource: jest.fn(),
+    updateAdvancedSettings: jest.fn(),
+    updateFeedFilters: jest.fn(),
+  }),
+}));
+
+const mockLogEvent = jest.fn();
+jest.mock('../../../../contexts/LogContext', () => ({
+  useLogContext: () => ({ logEvent: mockLogEvent }),
+}));
+
+jest.mock('../../../../contexts/AuthContext', () => ({
+  useAuthContext: () => ({
+    user: { id: 'u1', email: 'a@b.c' },
+    trackingId: 'u1',
+  }),
+}));
+
+jest.mock('../../../../hooks/useTagSearch', () => ({
+  __esModule: true,
+  MIN_SEARCH_QUERY_LENGTH: 2,
+  useTagSearch: () => ({
+    data: {
+      searchTags: { tags: [{ name: 'graphql' }, { name: 'rust' }], query: '' },
+    },
+    isLoading: false,
+  }),
+}));
+
+const parameters: FunnelStepPersonaQuiz['parameters'] = {
+  entryQuestionId: 'q_domain',
+  questions: [
+    {
+      id: 'q_domain',
+      axis: 'domain',
+      prompt: 'Where do you spend most time?',
+      options: [
+        {
+          id: 'frontend',
+          label: 'Frontend',
+          tagWeights: { react: 1, tailwind: 1 },
+          next: 'q_fe_yn',
+        },
+        {
+          id: 'backend',
+          label: 'Backend',
+          tagWeights: { nodejs: 1, postgres: 1 },
+          next: 'q_be_yn',
+        },
+      ],
+    },
+    {
+      id: 'q_fe_yn',
+      axis: 'fe_typescript',
+      prompt: 'You write TypeScript.',
+      archetypeId: 'frontend_dev',
+      options: [
+        {
+          id: 'yes',
+          label: 'Yes',
+          tagWeights: { typescript: 1 },
+          next: null,
+        },
+        {
+          id: 'no',
+          label: 'No',
+          tagWeights: { javascript: 1 },
+          next: null,
+        },
+      ],
+    },
+    {
+      id: 'q_be_yn',
+      axis: 'be_go',
+      prompt: 'Your main backend language is Go.',
+      archetypeId: 'backend_dev',
+      options: [
+        {
+          id: 'yes',
+          label: 'Yes',
+          tagWeights: { go: 1, golang: 1 },
+          next: null,
+        },
+        {
+          id: 'no',
+          label: 'No',
+          tagWeights: { python: 1 },
+          next: null,
+        },
+      ],
+    },
+  ],
+  selection: {
+    maxQuestions: 15,
+    targetTotalTags: 6,
+    tagConfidenceFloor: 1,
+    fallbackTags: ['javascript'],
+  },
+  archetypes: [
+    {
+      id: 'frontend_dev',
+      name: 'Frontend Dev',
+      headline: 'TypeScript frontend dev',
+      description: 'Heavy TS + React feed coming up.',
+      keyTags: ['react', 'typescript', 'tailwind'],
+    },
+    {
+      id: 'backend_dev',
+      name: 'Backend Dev',
+      headline: 'Backend builder shipping services',
+      description: 'API and service feed incoming.',
+      keyTags: ['nodejs', 'postgres'],
+    },
+  ],
+  reveal: {
+    eyebrow: 'You are a…',
+    cta: 'Looks good',
+    feedbackCta: 'Nope, not me',
+  },
+};
+
+const baseStep: FunnelStepPersonaQuiz = {
+  id: 'persona-quiz-step',
+  type: FunnelStepType.PersonaQuiz,
+  transitions: [
+    {
+      on: FunnelStepTransitionType.Complete,
+      destination: 'next',
+    },
+  ],
+  isActive: true,
+  parameters,
+  onTransition: jest.fn(),
+};
+
+const renderStep = (overrides: Partial<FunnelStepPersonaQuiz> = {}) => {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  const onTransition = jest.fn();
+  const props = { ...baseStep, ...overrides, onTransition };
+  const utils = render(
+    <QueryClientProvider client={queryClient}>
+      <FunnelPersonaQuiz {...props} />
+    </QueryClientProvider>,
+  );
+  return { ...utils, onTransition };
+};
+
+describe('FunnelPersonaQuiz', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('logs StartPersonaQuiz on mount', async () => {
+    renderStep();
+    await waitFor(() => {
+      expect(mockLogEvent).toHaveBeenCalledWith(
+        expect.objectContaining({ event_name: LogEvent.StartPersonaQuiz }),
+      );
+    });
+  });
+
+  it('walks Q→A→reveal via static `next` pointers and emits Complete with payload', async () => {
+    const { onTransition } = renderStep();
+    fireEvent.click(await screen.findByText('Frontend'));
+    fireEvent.click(await screen.findByText('Yes'));
+    expect(
+      await screen.findByText('TypeScript frontend dev'),
+    ).toBeInTheDocument();
+    fireEvent.click(screen.getByText('Looks good'));
+    await waitFor(() => {
+      // Tags are followed incrementally during the quiz — collect the union
+      // of every `followTags` call so we can assert the full quiz tag set.
+      const allFollowedTags = mockFollowTags.mock.calls.flatMap(
+        ([{ tags }]) => tags,
+      );
+      expect(allFollowedTags).toEqual(
+        expect.arrayContaining(['react', 'tailwind', 'typescript']),
+      );
+    });
+    await waitFor(() => {
+      expect(onTransition).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: FunnelStepTransitionType.Complete,
+          details: expect.objectContaining({
+            quizAnswers: [
+              { questionId: 'q_domain', optionId: 'frontend' },
+              { questionId: 'q_fe_yn', optionId: 'yes' },
+            ],
+          }),
+        }),
+      );
+    });
+  });
+
+  it('falls back to a tag-based headline when no archetype is resolved', async () => {
+    renderStep({
+      parameters: {
+        ...parameters,
+        // Terminal question has no archetypeId set — orchestration should fall back.
+        questions: parameters.questions.map((q) =>
+          q.id === 'q_be_yn' ? { ...q, archetypeId: undefined } : q,
+        ),
+      },
+    });
+    fireEvent.click(await screen.findByText('Backend'));
+    fireEvent.click(await screen.findByText('No'));
+    const heading = await screen.findByRole('heading', { level: 2 });
+    expect(heading).toHaveTextContent(/Nodejs/);
+    expect(heading).toHaveTextContent(/locked in/);
+  });
+
+  it('opens the feedback form and logs PersonaQuizFeedback with the reveal headline', async () => {
+    renderStep();
+    fireEvent.click(await screen.findByText('Frontend'));
+    fireEvent.click(await screen.findByText('Yes'));
+    fireEvent.click(await screen.findByText('Nope, not me'));
+    const textarea = await screen.findByPlaceholderText(
+      /Tell us what we got wrong/i,
+    );
+    fireEvent.change(textarea, { target: { value: "I'm a backend dev" } });
+    fireEvent.click(screen.getByText('Send feedback'));
+    await waitFor(() => {
+      expect(mockLogEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          event_name: LogEvent.PersonaQuizFeedback,
+          extra: expect.stringContaining("I'm a backend dev"),
+        }),
+      );
+    });
+    const feedbackCall = mockLogEvent.mock.calls.find(
+      ([call]) => call?.event_name === LogEvent.PersonaQuizFeedback,
+    );
+    expect(feedbackCall?.[0]?.extra).toContain('TypeScript frontend dev');
+  });
+});
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizFeedbackForm.tsx b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizFeedbackForm.tsx
new file mode 100644
index 00000000000..2aefe417571
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizFeedbackForm.tsx
@@ -0,0 +1,80 @@
+import type { ReactElement } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
+import {
+  Button,
+  ButtonSize,
+  ButtonVariant,
+} from '../../../../components/buttons/Button';
+import {
+  Typography,
+  TypographyColor,
+  TypographyType,
+} from '../../../../components/typography/Typography';
+
+interface PersonaQuizFeedbackFormProps {
+  placeholder?: string;
+  onSubmit: (text: string) => void;
+  onCancel: () => void;
+}
+
+export const PersonaQuizFeedbackForm = ({
+  placeholder = 'Tell us what we got wrong — we’re listening',
+  onSubmit,
+  onCancel,
+}: PersonaQuizFeedbackFormProps): ReactElement => {
+  const [value, setValue] = useState('');
+  const ref = useRef<HTMLTextAreaElement | null>(null);
+
+  useEffect(() => {
+    ref.current?.focus();
+  }, []);
+
+  const trimmed = value.trim();
+  const canSubmit = trimmed.length > 0;
+
+  return (
+    <form
+      className="flex w-full flex-col gap-3 rounded-12 border border-border-subtlest-tertiary bg-background-subtle p-4"
+      onSubmit={(event) => {
+        event.preventDefault();
+        if (!canSubmit) {
+          return;
+        }
+        onSubmit(trimmed);
+      }}
+    >
+      <Typography
+        type={TypographyType.Footnote}
+        color={TypographyColor.Tertiary}
+      >
+        Help us tune this — the more specific the better.
+      </Typography>
+      <textarea
+        ref={ref}
+        value={value}
+        onChange={(event) => setValue(event.target.value)}
+        placeholder={placeholder}
+        rows={3}
+        className="w-full resize-none rounded-8 border border-border-subtlest-tertiary bg-background-default px-3 py-2 text-text-primary typo-body placeholder:text-text-quaternary focus:border-text-tertiary focus:outline-none"
+      />
+      <div className="flex justify-end gap-2">
+        <Button
+          type="button"
+          variant={ButtonVariant.Tertiary}
+          size={ButtonSize.Small}
+          onClick={onCancel}
+        >
+          Cancel
+        </Button>
+        <Button
+          type="submit"
+          variant={ButtonVariant.Secondary}
+          size={ButtonSize.Small}
+          disabled={!canSubmit}
+        >
+          Send feedback
+        </Button>
+      </div>
+    </form>
+  );
+};
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizQuestion.tsx b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizQuestion.tsx
new file mode 100644
index 00000000000..bae70534439
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizQuestion.tsx
@@ -0,0 +1,123 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import classNames from 'classnames';
+import type {
+  PersonaQuizOption,
+  PersonaQuizQuestion,
+} from '../../types/funnel';
+import { Image } from '../../../../components/image/Image';
+import {
+  Typography,
+  TypographyColor,
+  TypographyTag,
+  TypographyType,
+} from '../../../../components/typography/Typography';
+
+interface PersonaQuizQuestionProps {
+  question: PersonaQuizQuestion;
+  step: number;
+  totalSteps: number;
+  onSelect: (option: PersonaQuizOption) => void;
+}
+
+export const PersonaQuizQuestionView = ({
+  question,
+  step,
+  totalSteps,
+  onSelect,
+}: PersonaQuizQuestionProps): ReactElement => (
+  <div
+    className={classNames(
+      'flex w-full flex-1 flex-col gap-6 px-4 py-6 tablet:mx-auto laptop:gap-10',
+      question.cols === 3 ? 'tablet:max-w-lg' : 'tablet:max-w-md',
+    )}
+  >
+    <header className="flex items-center gap-3">
+      <Typography
+        type={TypographyType.Footnote}
+        color={TypographyColor.Tertiary}
+      >
+        {`Question ${step} of ${totalSteps}`}
+      </Typography>
+      <div className="flex flex-1 gap-1">
+        {Array.from({ length: totalSteps }, (_, index) => (
+          <span
+            key={`step-${index}`}
+            className={classNames(
+              'h-1.5 flex-1 rounded-4 transition-colors',
+              index < step ? 'bg-brand-default' : 'bg-border-subtlest-tertiary',
+            )}
+          />
+        ))}
+      </div>
+    </header>
+
+    <Typography
+      tag={TypographyTag.H2}
+      type={TypographyType.Title2}
+      color={TypographyColor.Primary}
+      bold
+      className="text-center"
+    >
+      {question.prompt}
+    </Typography>
+
+    {question.imageUrl && (
+      <div className="grid place-items-center">
+        <Image
+          alt="Question additional context"
+          aria-hidden
+          className="mx-auto w-full max-w-md object-contain object-center"
+          role="presentation"
+          src={question.imageUrl}
+        />
+      </div>
+    )}
+
+    <div
+      className={classNames('grid gap-3', {
+        'grid-cols-1': !question.cols || question.cols === 1,
+        'grid-cols-2': question.cols === 2,
+        'grid-cols-3': question.cols === 3,
+      })}
+    >
+      {question.options.map((option) => (
+        <button
+          key={option.id}
+          type="button"
+          onClick={() => onSelect(option)}
+          className={classNames(
+            'flex min-w-0 gap-2 rounded-12 border border-border-subtlest-tertiary bg-background-default text-text-secondary transition-colors hover:border-text-tertiary hover:text-text-primary',
+            question.cols === 3
+              ? 'flex-col items-center px-2 py-2.5 text-center'
+              : 'items-center gap-3 px-4 py-3 text-left',
+          )}
+        >
+          {option.emoji && (
+            <span
+              aria-hidden
+              className={classNames(
+                'shrink-0 leading-none',
+                question.cols === 3 ? 'text-xl' : 'text-2xl',
+              )}
+            >
+              {option.emoji}
+            </span>
+          )}
+          <Typography
+            type={
+              question.cols === 3 ? TypographyType.Callout : TypographyType.Body
+            }
+            color={TypographyColor.Primary}
+            className={classNames(
+              'min-w-0 break-words',
+              question.cols !== 3 && 'flex-1',
+            )}
+          >
+            {option.label}
+          </Typography>
+        </button>
+      ))}
+    </div>
+  </div>
+);
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizReveal.tsx b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizReveal.tsx
new file mode 100644
index 00000000000..f54b2e2de9d
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/PersonaQuizReveal.tsx
@@ -0,0 +1,205 @@
+import type { ReactElement } from 'react';
+import React, { useState } from 'react';
+import classNames from 'classnames';
+import {
+  Button,
+  ButtonSize,
+  ButtonVariant,
+} from '../../../../components/buttons/Button';
+import {
+  Typography,
+  TypographyColor,
+  TypographyTag,
+  TypographyType,
+} from '../../../../components/typography/Typography';
+import { Origin } from '../../../../lib/log';
+import { PersonaQuizFeedbackForm } from './PersonaQuizFeedbackForm';
+import type { PersonaArchetype } from '../../types/funnel';
+import { TagSelection } from '../../../../components/tags/TagSelection';
+import { FeedPreviewControls } from '../../../../components/feeds/FeedPreviewControls';
+import Feed from '../../../../components/Feed';
+import { FeedLayoutProvider } from '../../../../contexts/FeedContext';
+import { OtherFeedPage, RequestKey } from '../../../../lib/query';
+import { PREVIEW_FEED_QUERY } from '../../../../graphql/feed';
+import { SearchField } from '../../../../components/fields/SearchField';
+import useDebounceFn from '../../../../hooks/useDebounceFn';
+import { useTagSearch } from '../../../../hooks/useTagSearch';
+
+interface PersonaQuizRevealProps {
+  archetype: PersonaArchetype | null;
+  /**
+   * Tags accumulated from the quiz answers. Used only as a fallback for the
+   * headline copy when no archetype was resolved — the actual editable tag
+   * list lives in `feedSettings` (mutated via `TagSelection`).
+   */
+  tags: string[];
+  userId: string | undefined;
+  reveal: {
+    eyebrow?: string;
+    cta?: string;
+    feedbackCta?: string;
+    feedbackPlaceholder?: string;
+  };
+  isFinalizing: boolean;
+  onSubmitFeedback: (text: string) => void;
+  onComplete: () => void;
+}
+
+const humaniseTag = (tag: string): string => {
+  const spaced = tag.replace(/-/g, ' ').trim();
+  if (!spaced) {
+    return tag;
+  }
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+
+const headlineFromTags = (tags: string[]): string => {
+  const top = tags.slice(0, 3).map(humaniseTag);
+  if (top.length === 0) {
+    return 'Your feed is ready';
+  }
+  if (top.length === 1) {
+    return `${top[0]}, locked in.`;
+  }
+  if (top.length === 2) {
+    return `${top[0]} + ${top[1]}, locked in.`;
+  }
+  return `${top[0]}, ${top[1]}, ${top[2]} — locked in.`;
+};
+
+export const PersonaQuizReveal = ({
+  archetype,
+  tags,
+  userId,
+  reveal,
+  isFinalizing,
+  onSubmitFeedback,
+  onComplete,
+}: PersonaQuizRevealProps): ReactElement => {
+  const [isPreviewOpen, setPreviewOpen] = useState(false);
+  const [showFeedback, setShowFeedback] = useState(false);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [onSearch] = useDebounceFn((value?: string) => {
+    setSearchQuery(value ?? '');
+  }, 350);
+
+  const { data: searchResult } = useTagSearch({
+    value: searchQuery,
+    origin: Origin.EditTag,
+  });
+  const searchTags = searchResult?.searchTags?.tags ?? [];
+
+  const headline = archetype?.headline ?? headlineFromTags(tags);
+  const eyebrow = archetype?.name ?? reveal.eyebrow;
+  const description = archetype?.description;
+
+  return (
+    <div className="flex w-full flex-1 flex-col gap-6 px-4 py-6 tablet:mx-auto tablet:max-w-4xl">
+      <header className="flex flex-col items-center gap-2 text-center">
+        {eyebrow && (
+          <Typography
+            type={TypographyType.Footnote}
+            color={TypographyColor.Tertiary}
+          >
+            {eyebrow}
+          </Typography>
+        )}
+        <Typography
+          tag={TypographyTag.H2}
+          type={TypographyType.Title1}
+          color={TypographyColor.Primary}
+          bold
+        >
+          {headline}
+        </Typography>
+        {description && (
+          <Typography
+            type={TypographyType.Body}
+            color={TypographyColor.Tertiary}
+          >
+            {description}
+          </Typography>
+        )}
+      </header>
+
+      <TagSelection
+        className="mt-4"
+        searchElement={
+          <SearchField
+            aria-label="Search tags"
+            className="mb-8 w-full tablet:max-w-xs"
+            inputId="persona-quiz-search-tags"
+            placeholder="Search tags…"
+            valueChanged={onSearch}
+          />
+        }
+        searchQuery={searchQuery}
+        searchTags={searchTags}
+        origin={Origin.EditTag}
+      />
+
+      {userId && (
+        <>
+          <FeedPreviewControls
+            isOpen={isPreviewOpen}
+            isDisabled={false}
+            textDisabled=""
+            origin={Origin.EditTag}
+            onClick={setPreviewOpen}
+          />
+          {isPreviewOpen && (
+            <FeedLayoutProvider>
+              <p className="-mb-4 mt-6 text-center text-text-secondary typo-body">
+                Tweak your tags above until the feed below feels like yours.
+              </p>
+              <Feed
+                className="relative mx-auto px-6 pt-14 tablet:left-1/2 tablet:w-screen tablet:-translate-x-1/2 laptop:pt-10"
+                feedName={OtherFeedPage.Preview}
+                feedQueryKey={[RequestKey.FeedPreview, userId]}
+                query={PREVIEW_FEED_QUERY}
+                showSearch={false}
+                options={{ refetchOnMount: true }}
+                allowPin
+              />
+            </FeedLayoutProvider>
+          )}
+        </>
+      )}
+
+      <section className="flex flex-col gap-2">
+        <button
+          type="button"
+          onClick={() => setShowFeedback((value) => !value)}
+          className="self-start text-left text-text-link transition-colors typo-callout hover:text-text-primary"
+          aria-expanded={showFeedback}
+        >
+          {reveal.feedbackCta ?? 'Nope, this isn’t me'}
+        </button>
+        {showFeedback && (
+          <PersonaQuizFeedbackForm
+            placeholder={reveal.feedbackPlaceholder}
+            onSubmit={(text) => {
+              onSubmitFeedback(text);
+              setShowFeedback(false);
+            }}
+            onCancel={() => setShowFeedback(false)}
+          />
+        )}
+      </section>
+
+      <div className="sticky mx-auto mt-auto flex w-full max-w-md flex-col gap-2 px-1 pb-4 bottom-safe-or-2">
+        <Button
+          type="button"
+          variant={ButtonVariant.Primary}
+          size={ButtonSize.XLarge}
+          onClick={onComplete}
+          disabled={isFinalizing}
+          loading={isFinalizing}
+          className={classNames('w-full')}
+        >
+          {reveal.cta ?? 'Looks good'}
+        </Button>
+      </div>
+    </div>
+  );
+};
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/index.tsx b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/index.tsx
new file mode 100644
index 00000000000..19323492283
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/index.tsx
@@ -0,0 +1,355 @@
+import type { ReactElement } from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type {
+  FunnelStepPersonaQuiz,
+  FunnelStepPersonaQuizParameters,
+  PersonaArchetype,
+  PersonaQuizOption,
+} from '../../types/funnel';
+import { FunnelStepTransitionType } from '../../types/funnel';
+import { withIsActiveGuard } from '../../shared/withActiveGuard';
+import { useAuthContext } from '../../../../contexts/AuthContext';
+import { useLogContext } from '../../../../contexts/LogContext';
+import { LogEvent } from '../../../../lib/log';
+import useMutateFilters from '../../../../hooks/useMutateFilters';
+import useFeedSettings from '../../../../hooks/useFeedSettings';
+import useDebounceFn from '../../../../hooks/useDebounceFn';
+import { usePersonaQuizState } from './usePersonaQuizState';
+import type { PersonaQuizAnswer } from './usePersonaQuizState';
+import { PersonaQuizQuestionView } from './PersonaQuizQuestion';
+import { PersonaQuizReveal } from './PersonaQuizReveal';
+import Feed from '../../../../components/Feed';
+import { FeedLayoutProvider } from '../../../../contexts/FeedContext';
+import { OtherFeedPage, RequestKey } from '../../../../lib/query';
+import { PREVIEW_FEED_QUERY } from '../../../../graphql/feed';
+
+const dedupePreserveOrder = (tags: string[]): string[] =>
+  Array.from(new Set(tags));
+
+function FunnelPersonaQuizComponent({
+  id,
+  parameters,
+  onTransition,
+}: FunnelStepPersonaQuiz): ReactElement | null {
+  const { logEvent } = useLogContext();
+  const auth = useAuthContext();
+  const user = auth?.user;
+  const { followTags } = useMutateFilters(user);
+  const { feedSettings } = useFeedSettings();
+  const queryClient = useQueryClient();
+
+  const params = parameters as FunnelStepPersonaQuizParameters;
+  const {
+    questions,
+    selection,
+    archetypes,
+    reveal: revealCopy,
+    entryQuestionId,
+  } = params;
+
+  const {
+    phase,
+    currentQuestion,
+    answers,
+    tagScores,
+    finalTags,
+    lastOption,
+    goToQuestion,
+    answer,
+    enrichmentComplete,
+  } = usePersonaQuizState({ questions });
+
+  const [revealArchetype, setRevealArchetype] =
+    useState<PersonaArchetype | null>(null);
+
+  const didStartLogRef = useRef(false);
+  useEffect(() => {
+    if (didStartLogRef.current) {
+      return;
+    }
+    didStartLogRef.current = true;
+    logEvent({
+      event_name: LogEvent.StartPersonaQuiz,
+      extra: JSON.stringify({ stepId: id, version: parameters.version }),
+    });
+  }, [id, logEvent, parameters.version]);
+
+  // Tags accumulated so far, sorted by score (used both for the live feed
+  // preview and to derive the final follow list at reveal time).
+  const accumulatedTags = useMemo(
+    () =>
+      Object.entries(tagScores)
+        .filter(([, score]) => score >= selection.tagConfidenceFloor)
+        .sort(([, a], [, b]) => b - a)
+        .map(([tag]) => tag),
+    [tagScores, selection.tagConfidenceFloor],
+  );
+
+  // Top tags used to filter the inter-question feed preview. Capped at 12 to
+  // keep the GraphQL request lean.
+  const previewTags = useMemo(
+    () => accumulatedTags.slice(0, 12),
+    [accumulatedTags],
+  );
+
+  // The server's `feedPreview` resolver reads from the user's persisted
+  // `feedSettings` rather than the inline `filters` argument we can pass
+  // through `Feed`'s `variables` prop. So to make the preview reflect the
+  // user's evolving interests we have to actually persist tags as they
+  // accumulate. Track the session's "already followed" set so each tag fires
+  // `followTags` at most once.
+  const followedRef = useRef<Set<string>>(new Set());
+  const [refetchPreview] = useDebounceFn(() => {
+    queryClient.invalidateQueries({
+      queryKey: [RequestKey.FeedPreview],
+      predicate: (q) => !q.queryKey.includes(RequestKey.FeedPreviewCustom),
+    });
+  }, 500);
+
+  useEffect(() => {
+    if (phase !== 'question' || !user?.id) {
+      return;
+    }
+    const fresh = accumulatedTags.filter((t) => !followedRef.current.has(t));
+    if (fresh.length === 0) {
+      return;
+    }
+    fresh.forEach((t) => followedRef.current.add(t));
+    Promise.resolve(followTags({ tags: fresh })).catch(() => undefined);
+    refetchPreview();
+  }, [accumulatedTags, phase, user?.id, followTags, refetchPreview]);
+
+  // Resolve the archetype from the terminal question's `archetypeId`, build
+  // the final tag list, persist it (so `TagSelection` on the reveal screen
+  // sees the quiz tags pre-selected via `feedSettings`), then transition to
+  // the reveal phase.
+  const finishQuiz = useCallback(
+    (committedAnswers: PersonaQuizAnswer[]) => {
+      const lastAnswer = committedAnswers[committedAnswers.length - 1];
+      const terminalQuestion = lastAnswer
+        ? questions.find((q) => q.id === lastAnswer.questionId)
+        : null;
+      const archetype =
+        archetypes.find((a) => a.id === terminalQuestion?.archetypeId) ?? null;
+      setRevealArchetype(archetype);
+
+      const merged = dedupePreserveOrder([
+        ...accumulatedTags,
+        ...(selection.fallbackTags ?? []),
+      ]).slice(0, selection.targetTotalTags);
+
+      // Most tags are already followed (we stream them incrementally above);
+      // catch any residue — typically the fallback backfill — so the reveal's
+      // `TagSelection` reads a complete `feedSettings`.
+      const fresh = merged.filter((t) => !followedRef.current.has(t));
+      if (fresh.length > 0) {
+        fresh.forEach((t) => followedRef.current.add(t));
+        Promise.resolve(followTags({ tags: fresh })).catch(() => undefined);
+        refetchPreview();
+      }
+
+      enrichmentComplete(merged);
+    },
+    [
+      archetypes,
+      questions,
+      accumulatedTags,
+      selection.targetTotalTags,
+      selection.fallbackTags,
+      enrichmentComplete,
+      followTags,
+      refetchPreview,
+    ],
+  );
+
+  // Bootstrap: on first render with no current question, route to the opener.
+  const bootstrapRef = useRef(false);
+  useEffect(() => {
+    if (bootstrapRef.current) {
+      return;
+    }
+    if (phase !== 'question' || currentQuestion) {
+      return;
+    }
+    bootstrapRef.current = true;
+    const opener =
+      (entryQuestionId && questions.find((q) => q.id === entryQuestionId)) ||
+      questions[0];
+    if (opener) {
+      goToQuestion(opener.id);
+    } else {
+      finishQuiz(answers);
+    }
+  }, [
+    phase,
+    currentQuestion,
+    entryQuestionId,
+    questions,
+    goToQuestion,
+    answers,
+    finishQuiz,
+  ]);
+
+  // Drive forward after each answer: follow `option.next` if it exists, or
+  // finish the quiz (terminal answer / safety cap). Instant — no waiting.
+  const lastHandledCountRef = useRef(0);
+  useEffect(() => {
+    if (phase !== 'question') {
+      return;
+    }
+    if (answers.length === 0) {
+      return;
+    }
+    if (answers.length === lastHandledCountRef.current) {
+      return;
+    }
+    lastHandledCountRef.current = answers.length;
+
+    if (answers.length >= selection.maxQuestions) {
+      finishQuiz(answers);
+      return;
+    }
+
+    if (lastOption?.next) {
+      const nextQuestion = questions.find((q) => q.id === lastOption.next);
+      if (nextQuestion) {
+        goToQuestion(nextQuestion.id);
+        return;
+      }
+    }
+
+    finishQuiz(answers);
+  }, [
+    phase,
+    answers,
+    lastOption,
+    questions,
+    selection.maxQuestions,
+    goToQuestion,
+    finishQuiz,
+  ]);
+
+  const handleAnswer = useCallback(
+    (option: PersonaQuizOption) => {
+      if (!currentQuestion) {
+        return;
+      }
+      logEvent({
+        event_name: LogEvent.AnswerPersonaQuestion,
+        target_id: currentQuestion.id,
+        extra: JSON.stringify({
+          optionId: option.id,
+          axis: currentQuestion.axis,
+        }),
+      });
+      answer(currentQuestion, option);
+    },
+    [currentQuestion, answer, logEvent],
+  );
+
+  // Tags were persisted in `finishQuiz`; further add/remove during the reveal
+  // happens inside `TagSelection` via `useTagAndSource`. Finalising is a pure
+  // transition with the latest `finalTags` snapshot passed by the reveal.
+  const finalizeMutation = useMutation({
+    mutationFn: async (latestTags: string[]) => latestTags,
+    onSuccess: (latestTags) => {
+      logEvent({
+        event_name: LogEvent.CompletePersonaQuiz,
+        extra: JSON.stringify({
+          tagCount: latestTags.length,
+          answerCount: answers.length,
+        }),
+      });
+      onTransition({
+        type: FunnelStepTransitionType.Complete,
+        details: {
+          tags: latestTags,
+          quizAnswers: answers,
+        },
+      });
+    },
+  });
+
+  const handleSubmitFeedback = useCallback(
+    (text: string) => {
+      logEvent({
+        event_name: LogEvent.PersonaQuizFeedback,
+        extra: JSON.stringify({
+          revealArchetypeId: revealArchetype?.id ?? null,
+          revealHeadline: revealArchetype?.headline ?? null,
+          tags: finalTags,
+          text,
+        }),
+      });
+    },
+    [revealArchetype, finalTags, logEvent],
+  );
+
+  if (phase === 'question') {
+    if (!currentQuestion) {
+      return null;
+    }
+    return (
+      <div className="flex w-full flex-1 flex-col">
+        <PersonaQuizQuestionView
+          question={currentQuestion}
+          step={answers.length + 1}
+          totalSteps={selection.maxQuestions}
+          onSelect={handleAnswer}
+        />
+        {answers.length >= 1 && user?.id && previewTags.length > 0 && (
+          <FeedLayoutProvider>
+            <p className="mt-10 text-center text-text-tertiary typo-footnote">
+              Sneak peek of your feed
+            </p>
+            <Feed
+              className="relative mx-auto px-6 pt-6 tablet:left-1/2 tablet:w-screen tablet:-translate-x-1/2"
+              feedName={OtherFeedPage.Preview}
+              feedQueryKey={[RequestKey.FeedPreview, user.id]}
+              query={PREVIEW_FEED_QUERY}
+              showSearch={false}
+              options={{ refetchOnMount: true }}
+              allowPin
+            />
+          </FeedLayoutProvider>
+        )}
+      </div>
+    );
+  }
+
+  // `enriching` phase is vestigial — the reducer still exposes it but the
+  // orchestration transitions straight from `question` to `reveal` via
+  // `enrichmentComplete` inside `finishQuiz`. Nothing should ever render here.
+  if (phase === 'enriching') {
+    return null;
+  }
+
+  return (
+    <PersonaQuizReveal
+      archetype={revealArchetype}
+      tags={finalTags}
+      userId={user?.id}
+      reveal={revealCopy}
+      isFinalizing={finalizeMutation.isPending}
+      onSubmitFeedback={handleSubmitFeedback}
+      onComplete={() => {
+        // Tag list is whatever feedSettings holds RIGHT NOW (TagSelection has
+        // been mutating it during the reveal). Fall back to the quiz-derived
+        // snapshot when feedSettings isn't available (e.g. anonymous user).
+        const latest = feedSettings?.includeTags?.length
+          ? feedSettings.includeTags
+          : finalTags;
+        finalizeMutation.mutate(latest);
+      }}
+    />
+  );
+}
+
+export const FunnelPersonaQuiz = withIsActiveGuard(FunnelPersonaQuizComponent);
diff --git a/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/usePersonaQuizState.ts b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/usePersonaQuizState.ts
new file mode 100644
index 00000000000..611b226aa69
--- /dev/null
+++ b/packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/usePersonaQuizState.ts
@@ -0,0 +1,163 @@
+import { useCallback, useMemo, useReducer } from 'react';
+import type {
+  FunnelStepPersonaQuizParameters,
+  PersonaQuizOption,
+  PersonaQuizQuestion,
+} from '../../types/funnel';
+
+export type PersonaQuizPhase = 'question' | 'enriching' | 'reveal';
+
+export interface PersonaQuizAnswer {
+  questionId: string;
+  optionId: string;
+}
+
+interface PersonaQuizState {
+  phase: PersonaQuizPhase;
+  currentQuestionId: string | null;
+  answers: PersonaQuizAnswer[];
+  tagScores: Record<string, number>;
+  lastOption: PersonaQuizOption | undefined;
+  finalTags: string[];
+}
+
+type Action =
+  | { type: 'goToQuestion'; questionId: string }
+  | {
+      type: 'answer';
+      question: PersonaQuizQuestion;
+      option: PersonaQuizOption;
+    }
+  | { type: 'startEnriching' }
+  | { type: 'enrichmentComplete'; tags: string[] }
+  | { type: 'addTag'; tag: string }
+  | { type: 'removeTag'; tag: string };
+
+const applyWeights = (
+  base: Record<string, number>,
+  weights: Record<string, number> | undefined,
+): Record<string, number> => {
+  if (!weights) {
+    return base;
+  }
+  const next = { ...base };
+  Object.entries(weights).forEach(([key, weight]) => {
+    next[key] = (next[key] ?? 0) + weight;
+  });
+  return next;
+};
+
+const reducer = (state: PersonaQuizState, action: Action): PersonaQuizState => {
+  switch (action.type) {
+    case 'goToQuestion':
+      return {
+        ...state,
+        phase: 'question',
+        currentQuestionId: action.questionId,
+      };
+    case 'answer': {
+      const { question, option } = action;
+      return {
+        ...state,
+        answers: [
+          ...state.answers,
+          { questionId: question.id, optionId: option.id },
+        ],
+        tagScores: applyWeights(state.tagScores, option.tagWeights),
+        lastOption: option,
+      };
+    }
+    case 'startEnriching':
+      return { ...state, phase: 'enriching' };
+    case 'enrichmentComplete':
+      return { ...state, phase: 'reveal', finalTags: action.tags };
+    case 'addTag':
+      if (state.finalTags.includes(action.tag)) {
+        return state;
+      }
+      return { ...state, finalTags: [...state.finalTags, action.tag] };
+    case 'removeTag':
+      return {
+        ...state,
+        finalTags: state.finalTags.filter((tag) => tag !== action.tag),
+      };
+    default:
+      return state;
+  }
+};
+
+const initialState: PersonaQuizState = {
+  phase: 'question',
+  currentQuestionId: null,
+  answers: [],
+  tagScores: {},
+  lastOption: undefined,
+  finalTags: [],
+};
+
+export interface UsePersonaQuizState {
+  phase: PersonaQuizPhase;
+  currentQuestion: PersonaQuizQuestion | null;
+  answers: PersonaQuizAnswer[];
+  tagScores: Record<string, number>;
+  finalTags: string[];
+  lastOption: PersonaQuizOption | undefined;
+  goToQuestion: (questionId: string) => void;
+  answer: (question: PersonaQuizQuestion, option: PersonaQuizOption) => void;
+  startEnriching: () => void;
+  enrichmentComplete: (tags: string[]) => void;
+  addTag: (tag: string) => void;
+  removeTag: (tag: string) => void;
+}
+
+export const usePersonaQuizState = (
+  params: Pick<FunnelStepPersonaQuizParameters, 'questions'>,
+): UsePersonaQuizState => {
+  const [state, dispatch] = useReducer(reducer, initialState);
+
+  const currentQuestion = useMemo(() => {
+    if (!state.currentQuestionId) {
+      return null;
+    }
+    return (
+      params.questions.find((q) => q.id === state.currentQuestionId) ?? null
+    );
+  }, [params.questions, state.currentQuestionId]);
+
+  const goToQuestion = useCallback((questionId: string) => {
+    dispatch({ type: 'goToQuestion', questionId });
+  }, []);
+  const answer = useCallback(
+    (question: PersonaQuizQuestion, option: PersonaQuizOption) => {
+      dispatch({ type: 'answer', question, option });
+    },
+    [],
+  );
+  const startEnriching = useCallback(() => {
+    dispatch({ type: 'startEnriching' });
+  }, []);
+  const enrichmentComplete = useCallback((tags: string[]) => {
+    dispatch({ type: 'enrichmentComplete', tags });
+  }, []);
+  const addTag = useCallback((tag: string) => {
+    dispatch({ type: 'addTag', tag });
+  }, []);
+  const removeTag = useCallback((tag: string) => {
+    dispatch({ type: 'removeTag', tag });
+  }, []);
+
+  return {
+    phase: state.phase,
+    currentQuestion,
+    answers: state.answers,
+    tagScores: state.tagScores,
+    finalTags: state.finalTags,
+    lastOption: state.lastOption,
+    goToQuestion,
+    answer,
+    startEnriching,
+    enrichmentComplete,
+    addTag,
+    removeTag,
+  };
+};
diff --git a/packages/shared/src/features/onboarding/steps/index.ts b/packages/shared/src/features/onboarding/steps/index.ts
index a15f695eeb7..f00f5cf762d 100644
--- a/packages/shared/src/features/onboarding/steps/index.ts
+++ b/packages/shared/src/features/onboarding/steps/index.ts
@@ -12,3 +12,4 @@ export { FunnelPlusCards } from './FunnelPlusCards';
 export { FunnelOrganicCheckout } from './FunnelOrganicCheckout';
 export { FunnelBrowserExtension } from './FunnelBrowserExtension';
 export { FunnelUploadCv } from './FunnelUploadCv';
+export { FunnelPersonaQuiz } from './FunnelPersonaQuiz';
diff --git a/packages/shared/src/features/onboarding/types/funnel.ts b/packages/shared/src/features/onboarding/types/funnel.ts
index c22766ec560..0010e00e220 100644
--- a/packages/shared/src/features/onboarding/types/funnel.ts
+++ b/packages/shared/src/features/onboarding/types/funnel.ts
@@ -31,6 +31,7 @@ export enum FunnelStepType {
   OrganicCheckout = 'organicCheckout',
   BrowserExtension = 'browserExtension',
   UploadCv = 'uploadCv',
+  PersonaQuiz = 'personaQuiz',
 }
 
 export enum FunnelBackgroundVariant {
@@ -377,6 +378,73 @@ export interface FunnelStepUploadCv
   onTransition: FunnelStepTransitionCallback;
 }
 
+export interface PersonaQuizOption {
+  id: string;
+  label: string;
+  emoji?: string;
+  tagWeights?: Record<string, number>;
+  next?: string | null;
+}
+
+export interface PersonaQuizQuestion {
+  id: string;
+  axis: string;
+  prompt: string;
+  imageUrl?: string;
+  cols?: number;
+  options: PersonaQuizOption[];
+  /**
+   * Set on terminal nodes (last question of a specialty subtree). When the
+   * user answers a question with this set, the orchestration looks up the
+   * matching archetype and transitions to the reveal phase.
+   */
+  archetypeId?: string;
+}
+
+export interface PersonaArchetype {
+  id: string;
+  name: string;
+  headline: string;
+  description: string;
+  keyTags: string[];
+}
+
+export interface FunnelStepPersonaQuizParameters {
+  headline?: string;
+  explainer?: string;
+  questions: PersonaQuizQuestion[];
+  entryQuestionId?: string;
+  selection: {
+    maxQuestions: number;
+    targetTotalTags: number;
+    tagConfidenceFloor: number;
+    fallbackTags?: string[];
+  };
+  /**
+   * Finite set of persona archetypes the quiz can resolve to. The user's path
+   * through the DAG terminates on a question carrying an `archetypeId`, which
+   * is matched against this list. Tag accumulation continues independently
+   * and provides the per-user "flavour" within an archetype.
+   */
+  archetypes: PersonaArchetype[];
+  reveal: {
+    eyebrow?: string;
+    cta?: string;
+    feedbackCta?: string;
+    feedbackPlaceholder?: string;
+    addTagCta?: string;
+  };
+}
+
+export interface FunnelStepPersonaQuiz
+  extends FunnelStepCommon<FunnelStepPersonaQuizParameters> {
+  type: FunnelStepType.PersonaQuiz;
+  onTransition: FunnelStepTransitionCallback<{
+    tags: string[];
+    quizAnswers: Array<{ questionId: string; optionId: string }>;
+  }>;
+}
+
 export type FunnelStep =
   | FunnelStepLandingPage
   | FunnelStepFact
@@ -397,7 +465,8 @@ export type FunnelStep =
   | FunnelStepOrganicCheckout
   | FunnelStepBrowserExtension
   | FunnelStepPlusCards
-  | FunnelStepUploadCv;
+  | FunnelStepUploadCv
+  | FunnelStepPersonaQuiz;
 
 export type FunnelPosition = {
   chapter: number;
@@ -446,4 +515,5 @@ export const stepsFullWidth: Array<FunnelStepType> = [
   FunnelStepType.BrowserExtension,
   FunnelStepType.InstallPwa,
   FunnelStepType.UploadCv,
+  FunnelStepType.PersonaQuiz,
 ];
diff --git a/packages/shared/src/lib/log.ts b/packages/shared/src/lib/log.ts
index 27c92db0018..24f27511447 100644
--- a/packages/shared/src/lib/log.ts
+++ b/packages/shared/src/lib/log.ts
@@ -307,6 +307,12 @@ export enum LogEvent {
   StartAiFluencyQuiz = 'start ai fluency quiz',
   CompleteAiFluencyQuiz = 'complete ai fluency quiz',
   ShareAiFluencyQuiz = 'share ai fluency quiz',
+  // Persona quiz (onboarding funnel step)
+  StartPersonaQuiz = 'start persona quiz',
+  AnswerPersonaQuestion = 'answer persona question',
+  CompletePersonaQuiz = 'complete persona quiz',
+  PersonaQuizFeedback = 'persona quiz feedback',
+  PersonaQuizTagEdit = 'persona quiz tag edit',
   // Plus subscription
   UpgradeSubscription = 'upgrade subscription',
   ManageSubscription = 'manage subscription',
diff --git a/packages/webapp/components/persona-quiz/personaQuizArchetypes.json b/packages/webapp/components/persona-quiz/personaQuizArchetypes.json
new file mode 100644
index 00000000000..5738cd794a9
--- /dev/null
+++ b/packages/webapp/components/persona-quiz/personaQuizArchetypes.json
@@ -0,0 +1,322 @@
+[
+  {
+    "id": "ui_engineer",
+    "name": "UI Engineer",
+    "headline": "Where design systems meet real components",
+    "description": "Your feed covers component libraries, accessibility, and CSS architecture. Opinionated about design tokens and when to reach for a framework.",
+    "keyTags": [
+      "frontend",
+      "react",
+      "typescript",
+      "css",
+      "design-systems",
+      "accessibility",
+      "tailwind-css",
+      "web-components",
+      "ui",
+      "storybook",
+      "styled-components",
+      "ui-design"
+    ]
+  },
+  {
+    "id": "web_performance_engineer",
+    "name": "Web Perf Engineer",
+    "headline": "Milliseconds are a product decision",
+    "description": "Your feed surfaces Core Web Vitals, bundle analysis, and rendering strategies. You've strong feelings about when not to hydrate.",
+    "keyTags": [
+      "performance",
+      "webassembly",
+      "nextjs",
+      "javascript",
+      "vite",
+      "webdev",
+      "lighthouse",
+      "web-development",
+      "react",
+      "typescript",
+      "pwa",
+      "webgpu"
+    ]
+  },
+  {
+    "id": "mobile_engineer",
+    "name": "Mobile Engineer",
+    "headline": "Native feel, cross-platform pragmatism",
+    "description": "Your feed covers iOS and Android patterns, React Native trade-offs, and everything shipping to an app store. Push notifications are personal.",
+    "keyTags": [
+      "react-native",
+      "flutter",
+      "ios",
+      "android",
+      "swift",
+      "kotlin",
+      "mobile",
+      "mobile-dev",
+      "expo",
+      "jetpack-compose",
+      "swiftui",
+      "android-development"
+    ]
+  },
+  {
+    "id": "fullstack_builder",
+    "name": "Full-Stack Builder",
+    "headline": "From database schema to deploy button",
+    "description": "Your feed blends API design, frontend frameworks, and deployment pipelines. You appreciate the satisfaction of owning the whole feature.",
+    "keyTags": [
+      "nodejs",
+      "nextjs",
+      "typescript",
+      "graphql",
+      "react",
+      "supabase",
+      "prisma",
+      "rest-api",
+      "backend",
+      "postgresql",
+      "serverless",
+      "vercel"
+    ]
+  },
+  {
+    "id": "cloud_platform_engineer",
+    "name": "Cloud Platform Engineer",
+    "headline": "Terraform applies and nobody flinches",
+    "description": "Your feed covers Kubernetes, IaC, and cloud-provider internals. You care deeply about blast radius and the art of writing runbooks that actually get read.",
+    "keyTags": [
+      "kubernetes",
+      "terraform",
+      "aws",
+      "gcp",
+      "azure",
+      "helm",
+      "iac",
+      "cloud-native",
+      "platform-engineering",
+      "devops",
+      "docker",
+      "infrastructure"
+    ]
+  },
+  {
+    "id": "sre_reliability_engineer",
+    "name": "SRE",
+    "headline": "On-call is a design problem, not a ritual",
+    "description": "Your feed surfaces observability tooling, incident retrospectives, and SLO frameworks. You define reliability as a feature, not a post-launch concern.",
+    "keyTags": [
+      "sre",
+      "observability",
+      "monitoring",
+      "prometheus",
+      "grafana",
+      "opentelemetry",
+      "distributed-systems",
+      "logging",
+      "cicd",
+      "architecture",
+      "apm",
+      "cloud"
+    ]
+  },
+  {
+    "id": "security_engineer",
+    "name": "Security Engineer",
+    "headline": "Ships fast and still sleeps at night",
+    "description": "Your feed mixes appsec, supply-chain threats, and zero-days. You think threat modelling should start in sprint planning, not the week before launch.",
+    "keyTags": [
+      "security",
+      "appsec",
+      "devsecops",
+      "vulnerability",
+      "pentesting",
+      "cryptography",
+      "authentication",
+      "web-security",
+      "code-security",
+      "zero-day",
+      "sbom",
+      "secrets-management"
+    ]
+  },
+  {
+    "id": "devtools_engineer",
+    "name": "Dev Tools Engineer",
+    "headline": "Building the picks and shovels of software",
+    "description": "Your feed covers compilers, build systems, CLIs, and developer experience improvements. You measure productivity in keystrokes saved per engineer per day.",
+    "keyTags": [
+      "devtools",
+      "cli",
+      "rust",
+      "go",
+      "commandline",
+      "vs-code",
+      "git",
+      "cicd",
+      "testing",
+      "open-source",
+      "vite",
+      "bun"
+    ]
+  },
+  {
+    "id": "ml_engineer",
+    "name": "ML Engineer",
+    "headline": "Getting models out of notebooks and into production",
+    "description": "Your feed covers model training, deployment, and evaluation frameworks. You've debugged enough shape mismatches to have opinions about tensor libraries.",
+    "keyTags": [
+      "machine-learning",
+      "pytorch",
+      "tensorflow",
+      "mlops",
+      "deep-learning",
+      "huggingface",
+      "python",
+      "neural-networks",
+      "llm",
+      "cuda",
+      "scikit",
+      "transformers"
+    ]
+  },
+  {
+    "id": "ai_application_builder",
+    "name": "AI App Builder",
+    "headline": "LLMs as infrastructure, products as the goal",
+    "description": "Your feed surfaces RAG architectures, prompt engineering, and emerging AI app patterns. You think the interesting layer is the one between the model and the user.",
+    "keyTags": [
+      "llm",
+      "rag",
+      "langchain",
+      "openai",
+      "genai",
+      "prompt-engineering",
+      "vector-search",
+      "embeddings",
+      "anthropic",
+      "llmops",
+      "ai",
+      "semantic-kernel"
+    ]
+  },
+  {
+    "id": "data_engineer",
+    "name": "Data Engineer",
+    "headline": "Reliable pipelines are the unsexy superpower",
+    "description": "Your feed covers streaming, batch processing, and data-lake architecture. You have a war story involving a timezone bug that cost someone a quarter.",
+    "keyTags": [
+      "data-engineering",
+      "apache-kafka",
+      "apache-spark",
+      "apache-airflow",
+      "change-data-capture",
+      "apache-iceberg",
+      "snowflake",
+      "databricks",
+      "data-warehouse",
+      "etl",
+      "big-data",
+      "apache-flink"
+    ]
+  },
+  {
+    "id": "analytics_engineer",
+    "name": "Analytics Engineer",
+    "headline": "Turning queries into decisions, not just dashboards",
+    "description": "Your feed mixes SQL craft, BI tooling, and data-modelling patterns. You believe a well-named metric definition is worth a thousand ad-hoc queries.",
+    "keyTags": [
+      "analytics-platforms",
+      "data-visualization",
+      "data-analysis",
+      "sql",
+      "bi",
+      "data-science",
+      "predictive-analytics",
+      "python",
+      "exploratory-data-analysis",
+      "statistical-analysis",
+      "real-time-analytics",
+      "duckdb"
+    ]
+  },
+  {
+    "id": "game_developer",
+    "name": "Game Developer",
+    "headline": "Rendering 60fps and shipping before crunch",
+    "description": "Your feed covers game engines, graphics programming, and the physics of fun. You benchmark shaders the way others benchmark APIs.",
+    "keyTags": [
+      "game-development",
+      "gamedev",
+      "unity",
+      "unreal-engine",
+      "graphics-programming",
+      "webgpu",
+      "vulkan",
+      "game-design",
+      "c++",
+      "3d",
+      "godot",
+      "gaming"
+    ]
+  },
+  {
+    "id": "embedded_systems_engineer",
+    "name": "Embedded Engineer",
+    "headline": "Code that runs where there is no OS",
+    "description": "Your feed surfaces firmware patterns, RTOS trade-offs, and IoT protocols. You think in bytes because kilobytes are a luxury.",
+    "keyTags": [
+      "embedded",
+      "iot",
+      "rust",
+      "c",
+      "c++",
+      "firmware",
+      "raspberry-pi",
+      "robotics",
+      "sensors",
+      "mqtt",
+      "arm",
+      "hardware"
+    ]
+  },
+  {
+    "id": "engineering_leader",
+    "name": "Engineering Leader",
+    "headline": "Growing teams, not just code",
+    "description": "Your feed covers org design, engineering culture, and delivery frameworks. You measure success by what your team ships when you are not in the room.",
+    "keyTags": [
+      "leadership",
+      "career",
+      "continuous-improvement",
+      "agile",
+      "devrel",
+      "productivity",
+      "company-culture",
+      "project-management",
+      "scrum",
+      "remote-work",
+      "technical-debt",
+      "architecture"
+    ]
+  },
+  {
+    "id": "technical_founder",
+    "name": "Technical Founder",
+    "headline": "Building a company one hard decision at a time",
+    "description": "Your feed mixes startup strategy, technical architecture, and growth tactics. You have shipped product, pitched investors, and debugged production on the same day.",
+    "keyTags": [
+      "startup",
+      "entrepreneurship",
+      "business",
+      "venture-capital",
+      "product-management",
+      "open-source",
+      "revenue",
+      "investing",
+      "y-combinator",
+      "business-development",
+      "series-a",
+      "finance"
+    ]
+  }
+]
diff --git a/packages/webapp/components/persona-quiz/personaQuizQuestionGraph.json b/packages/webapp/components/persona-quiz/personaQuizQuestionGraph.json
new file mode 100644
index 00000000000..aa8d83138dd
--- /dev/null
+++ b/packages/webapp/components/persona-quiz/personaQuizQuestionGraph.json
@@ -0,0 +1,4508 @@
+[
+  {
+    "id": "q_p_a1",
+    "axis": "product_MEDIUM",
+    "prompt": "Most of the code you write runs in a browser tab.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "frontend": 2,
+          "web-development": 1,
+          "javascript": 1,
+          "webdev": 1
+        },
+        "next": "q_p_a2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 2,
+          "mobile": 1,
+          "infrastructure": 1,
+          "nodejs": 1
+        },
+        "next": "q_p_a2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_a2",
+    "axis": "product_SCALE",
+    "prompt": "Your current project has fewer than ten engineers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "productivity": 1,
+          "general-programming": 1,
+          "open-source": 1
+        },
+        "next": "q_p_a3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "enterprise": 2,
+          "architecture": 1,
+          "design-patterns": 1,
+          "agile": 1
+        },
+        "next": "q_p_a3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_a3",
+    "axis": "product_OWNERSHIP",
+    "prompt": "You own both the visual design decisions and the component code.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "design-systems": 2,
+          "ui": 2,
+          "css": 1,
+          "frontend": 1
+        },
+        "next": "q_p_bA1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 2,
+          "mobile": 1,
+          "react-native": 1,
+          "nextjs": 1
+        },
+        "next": "q_p_bB1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bA1",
+    "axis": "product_TOOLING",
+    "prompt": "React is your default choice for building UI.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "react": 2,
+          "typescript": 2,
+          "react-hooks": 1,
+          "frontend": 1
+        },
+        "next": "q_p_bA2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "svelte": 2,
+          "vue": 1,
+          "angular": 1,
+          "web-components": 1
+        },
+        "next": "q_p_bA2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bA2",
+    "axis": "product_CRAFT",
+    "prompt": "Accessibility audits are part of your definition of done.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "accessibility": 2,
+          "semantic-kernel": 1,
+          "ui-design": 1,
+          "design-systems": 1
+        },
+        "next": "q_p_bA3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "performance": 2,
+          "javascript": 1,
+          "web-development": 1,
+          "testing": 1
+        },
+        "next": "q_p_bA3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bA3",
+    "axis": "product_PHILOSOPHY",
+    "prompt": "Utility-first CSS beats writing custom class hierarchies every time.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "tailwind-css": 2,
+          "css": 1,
+          "ui": 1,
+          "frontend": 1
+        },
+        "next": "q_p_bA4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "css": 2,
+          "styled-components": 1,
+          "design-systems": 1,
+          "typography": 1
+        },
+        "next": "q_p_bA4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bA4",
+    "axis": "product_WORKFLOW",
+    "prompt": "Storybook is open in a browser tab most of your working day.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "storybook": 2,
+          "design-systems": 2,
+          "ui-design": 1,
+          "react": 1
+        },
+        "next": "q_p_c1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "performance": 2,
+          "lighthouse": 1,
+          "webdev": 1,
+          "pwa": 1
+        },
+        "next": "q_p_c2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bB1",
+    "axis": "product_MEDIUM",
+    "prompt": "Your code ships to a mobile app store, not a web URL.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mobile": 2,
+          "ios": 1,
+          "android": 1,
+          "expo": 1
+        },
+        "next": "q_p_bB2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "web-development": 2,
+          "nextjs": 1,
+          "nodejs": 1,
+          "backend": 1
+        },
+        "next": "q_p_bB2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bB2",
+    "axis": "product_AUDIENCE",
+    "prompt": "Your users are consumers, not other developers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mobile-dev": 2,
+          "user-testing": 1,
+          "ui-ux": 1,
+          "product-management": 1
+        },
+        "next": "q_p_bB3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "api": 2,
+          "devtools": 1,
+          "open-source": 1,
+          "backend": 1
+        },
+        "next": "q_p_bB3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bB3",
+    "axis": "product_TOOLING",
+    "prompt": "React Native or Flutter is your primary client-side tool.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "react-native": 2,
+          "flutter": 2,
+          "mobile": 1,
+          "expo": 1
+        },
+        "next": "q_p_bB4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "swift": 2,
+          "kotlin": 2,
+          "ios": 1,
+          "android": 1
+        },
+        "next": "q_p_bB4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_bB4",
+    "axis": "product_OWNERSHIP",
+    "prompt": "You also own the API and database that power your client app.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "backend": 2,
+          "nodejs": 1,
+          "postgresql": 1,
+          "rest-api": 1
+        },
+        "next": "q_p_c3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "mobile": 2,
+          "ios": 1,
+          "android": 1,
+          "react-native": 1
+        },
+        "next": "q_p_c4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c1_1",
+    "axis": "product_CRAFT",
+    "prompt": "Design tokens are a first-class concern in your component architecture.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "design-systems": 2,
+          "css": 2,
+          "ui-design": 1,
+          "styled-components": 1
+        },
+        "next": "q_p_c1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "frontend": 2,
+          "react": 1,
+          "javascript": 1,
+          "typescript": 1
+        },
+        "next": "q_p_c1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c1_2",
+    "axis": "product_TOOLING",
+    "prompt": "Your component library lives in Storybook with a written contribution guide.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "storybook": 2,
+          "design-systems": 2,
+          "ui": 1,
+          "accessibility": 1
+        },
+        "next": "q_p_c1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react": 2,
+          "typescript": 1,
+          "web-components": 1,
+          "frontend": 1
+        },
+        "next": "q_p_c1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c1_3",
+    "axis": "product_DEPTH",
+    "prompt": "CSS specificity is something you can explain to a junior in five minutes.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "css": 2,
+          "ui": 1,
+          "design-systems": 1,
+          "tailwind-css": 1
+        },
+        "next": "q_p_c1_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "javascript": 2,
+          "react": 1,
+          "frontend": 1,
+          "typescript": 1
+        },
+        "next": "q_p_c1_4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c1_4",
+    "axis": "product_PROCESS",
+    "prompt": "You write prop-table documentation before merging a new component.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "design-systems": 2,
+          "storybook": 2,
+          "ui-design": 1,
+          "accessibility": 1
+        },
+        "next": "q_p_d1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react": 2,
+          "frontend": 1,
+          "css": 1,
+          "javascript": 1
+        },
+        "next": "q_p_d1_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c2_1",
+    "axis": "product_CRAFT",
+    "prompt": "Core Web Vitals failures block a deploy in your team.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "performance": 2,
+          "lighthouse": 2,
+          "web-development": 1,
+          "webdev": 1
+        },
+        "next": "q_p_c2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "frontend": 2,
+          "javascript": 1,
+          "react": 1,
+          "typescript": 1
+        },
+        "next": "q_p_c2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c2_2",
+    "axis": "product_TOOLING",
+    "prompt": "Bundle analysis and tree-shaking are regular parts of your review checklist.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "vite": 2,
+          "webpack": 2,
+          "javascript": 1,
+          "performance": 1
+        },
+        "next": "q_p_c2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "nextjs": 2,
+          "react": 1,
+          "frontend": 1,
+          "webdev": 1
+        },
+        "next": "q_p_c2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c2_3",
+    "axis": "product_PHILOSOPHY",
+    "prompt": "Partial hydration beats shipping JavaScript you do not need.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "performance": 2,
+          "webassembly": 1,
+          "nextjs": 1,
+          "javascript": 1
+        },
+        "next": "q_p_c2_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react": 2,
+          "pwa": 1,
+          "webdev": 1,
+          "frontend": 1
+        },
+        "next": "q_p_c2_4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c2_4",
+    "axis": "product_WORKFLOW",
+    "prompt": "Profiling a page in DevTools is something you do most weeks.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "performance": 2,
+          "javascript": 2,
+          "web-development": 1,
+          "lighthouse": 1
+        },
+        "next": "q_p_d2_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "frontend": 2,
+          "react": 1,
+          "typescript": 1,
+          "webdev": 1
+        },
+        "next": "q_p_d2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c3_1",
+    "axis": "product_TOOLING",
+    "prompt": "Expo or the React Native CLI is the starting point for new projects.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "react-native": 2,
+          "expo": 2,
+          "mobile-dev": 1,
+          "javascript": 1
+        },
+        "next": "q_p_c3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "swift": 2,
+          "kotlin": 2,
+          "ios": 1,
+          "android": 1
+        },
+        "next": "q_p_c3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c3_2",
+    "axis": "product_AUDIENCE",
+    "prompt": "App store review cycles are a real constraint on your release cadence.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mobile": 2,
+          "ios": 1,
+          "android": 1,
+          "app-store": 1
+        },
+        "next": "q_p_c3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "mobile-dev": 2,
+          "react-native": 1,
+          "flutter": 1,
+          "web-development": 1
+        },
+        "next": "q_p_c3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c3_3",
+    "axis": "product_DEPTH",
+    "prompt": "Platform-specific APIs like push notifications and biometrics are your domain.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "ios": 2,
+          "android": 2,
+          "swiftui": 1,
+          "jetpack-compose": 1
+        },
+        "next": "q_p_c3_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react-native": 2,
+          "flutter": 1,
+          "mobile": 1,
+          "expo": 1
+        },
+        "next": "q_p_c3_4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c3_4",
+    "axis": "product_CRAFT",
+    "prompt": "Pixel-perfect fidelity on both iOS and Android matters to you.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mobile-dev": 2,
+          "ui-design": 1,
+          "swiftui": 1,
+          "jetpack-compose": 1
+        },
+        "next": "q_p_d3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "mobile": 2,
+          "react-native": 1,
+          "flutter": 1,
+          "android-development": 1
+        },
+        "next": "q_p_d3_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c4_1",
+    "axis": "product_OWNERSHIP",
+    "prompt": "A single feature spans your database schema, API, and UI — all yours.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "backend": 2,
+          "postgresql": 1,
+          "nodejs": 1,
+          "rest-api": 1
+        },
+        "next": "q_p_c4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "frontend": 2,
+          "react": 1,
+          "nextjs": 1,
+          "typescript": 1
+        },
+        "next": "q_p_c4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c4_2",
+    "axis": "product_TOOLING",
+    "prompt": "GraphQL or a typed REST client connects your frontend and backend layers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "graphql": 2,
+          "rest-api": 2,
+          "typescript": 1,
+          "nodejs": 1
+        },
+        "next": "q_p_c4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 2,
+          "prisma": 1,
+          "nodejs": 1,
+          "supabase": 1
+        },
+        "next": "q_p_c4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c4_3",
+    "axis": "product_DEPTH",
+    "prompt": "API contract design is something you treat as a craft, not an afterthought.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "graphql": 2,
+          "rest-api": 2,
+          "openapi": 1,
+          "backend": 1
+        },
+        "next": "q_p_c4_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "nodejs": 2,
+          "nextjs": 1,
+          "prisma": 1,
+          "typescript": 1
+        },
+        "next": "q_p_c4_4"
+      }
+    ]
+  },
+  {
+    "id": "q_p_c4_4",
+    "axis": "product_WORKFLOW",
+    "prompt": "Shipping a feature end-to-end solo is your normal, not an exception.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "nextjs": 2,
+          "backend": 2,
+          "vercel": 1,
+          "supabase": 1
+        },
+        "next": "q_p_d4_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "nodejs": 2,
+          "react": 1,
+          "typescript": 1,
+          "serverless": 1
+        },
+        "next": "q_p_d4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d1_1",
+    "axis": "product_PROCESS",
+    "prompt": "Your pull requests always include screenshots of before and after states.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "design-systems": 2,
+          "ui": 1,
+          "code-review": 1,
+          "accessibility": 1
+        },
+        "next": "q_p_d1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "frontend": 2,
+          "css": 1,
+          "react": 1,
+          "storybook": 1
+        },
+        "next": "q_p_d1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d1_2",
+    "axis": "product_AUDIENCE",
+    "prompt": "The consumers of your components are other developers on your team.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "design-systems": 2,
+          "storybook": 1,
+          "ui-design": 1,
+          "accessibility": 1
+        },
+        "next": "q_p_d1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "ui": 2,
+          "frontend": 1,
+          "css": 1,
+          "tailwind-css": 1
+        },
+        "next": "q_p_d1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d1_3",
+    "axis": "product_PHILOSOPHY",
+    "prompt": "A component that looks right but fails an a11y audit is not done.",
+    "archetypeId": "ui_engineer",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "accessibility": 2,
+          "design-systems": 2,
+          "ui": 1,
+          "storybook": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "css": 2,
+          "tailwind-css": 1,
+          "styled-components": 1,
+          "ui-design": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_p_d2_1",
+    "axis": "product_MEDIUM",
+    "prompt": "Server-side rendering and edge caching are tools you reach for by default.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "nextjs": 2,
+          "performance": 1,
+          "web-development": 1,
+          "javascript": 1
+        },
+        "next": "q_p_d2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "javascript": 2,
+          "react": 1,
+          "vite": 1,
+          "webdev": 1
+        },
+        "next": "q_p_d2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d2_2",
+    "axis": "product_SCALE",
+    "prompt": "Your optimisations target millions of page views, not thousands.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "performance": 2,
+          "web-development": 1,
+          "javascript": 1,
+          "lighthouse": 1
+        },
+        "next": "q_p_d2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "webdev": 2,
+          "nextjs": 1,
+          "react": 1,
+          "pwa": 1
+        },
+        "next": "q_p_d2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d2_3",
+    "axis": "product_DEPTH",
+    "prompt": "WebAssembly or WebGPU has come up in a real architectural conversation of yours.",
+    "archetypeId": "web_performance_engineer",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "webassembly": 2,
+          "webgpu": 2,
+          "performance": 1,
+          "javascript": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "performance": 2,
+          "vite": 1,
+          "lighthouse": 1,
+          "web-development": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_p_d3_1",
+    "axis": "product_PROCESS",
+    "prompt": "You write device-specific test plans before submitting to an app store.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mobile": 2,
+          "ios": 1,
+          "android": 1,
+          "testing": 1
+        },
+        "next": "q_p_d3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react-native": 2,
+          "flutter": 1,
+          "mobile-dev": 1,
+          "expo": 1
+        },
+        "next": "q_p_d3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d3_2",
+    "axis": "product_DEPTH",
+    "prompt": "You have written or patched a native module to bridge a gap in a cross-platform SDK.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "android-development": 2,
+          "swift": 2,
+          "kotlin": 1,
+          "react-native": 1
+        },
+        "next": "q_p_d3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react-native": 2,
+          "flutter": 2,
+          "expo": 1,
+          "mobile": 1
+        },
+        "next": "q_p_d3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d3_3",
+    "axis": "product_PHILOSOPHY",
+    "prompt": "A native feel on each platform beats writing it once and shipping everywhere.",
+    "archetypeId": "mobile_engineer",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "swift": 2,
+          "kotlin": 2,
+          "swiftui": 1,
+          "jetpack-compose": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "react-native": 2,
+          "flutter": 2,
+          "mobile-dev": 1,
+          "expo": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_p_d4_1",
+    "axis": "product_SCALE",
+    "prompt": "The product you build serves a lot more than a handful of internal users.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "serverless": 2,
+          "vercel": 1,
+          "nextjs": 1,
+          "nodejs": 1
+        },
+        "next": "q_p_d4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "supabase": 2,
+          "postgresql": 1,
+          "prisma": 1,
+          "backend": 1
+        },
+        "next": "q_p_d4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d4_2",
+    "axis": "product_AUDIENCE",
+    "prompt": "End users experience the product you build, not just the team shipping it.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "nextjs": 2,
+          "react": 1,
+          "vercel": 1,
+          "typescript": 1
+        },
+        "next": "q_p_d4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 2,
+          "graphql": 1,
+          "nodejs": 1,
+          "postgresql": 1
+        },
+        "next": "q_p_d4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_p_d4_3",
+    "axis": "product_PHILOSOPHY",
+    "prompt": "Shipping a rough but working feature beats a perfect one that takes twice as long.",
+    "archetypeId": "fullstack_builder",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "nextjs": 2,
+          "vercel": 2,
+          "supabase": 1,
+          "typescript": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 2,
+          "graphql": 1,
+          "rest-api": 1,
+          "prisma": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_i_a1",
+    "axis": "OWNERSHIP — infra lifecycle vs feature delivery",
+    "prompt": "Your work ships infrastructure and tooling, not features for end users.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "infrastructure": 2,
+          "devops": 1,
+          "platform-engineering": 1
+        },
+        "next": "q_i_a2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "backend": 1,
+          "cloud": 1,
+          "devtools": 1
+        },
+        "next": "q_i_a2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_a2",
+    "axis": "MEDIUM/SURFACE — cloud vs bare-metal vs local",
+    "prompt": "Most of what you run lives in a cloud provider, not on bare metal.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "aws": 1,
+          "gcp": 1,
+          "cloud-native": 2,
+          "azure": 1
+        },
+        "next": "q_i_a3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "infrastructure": 1,
+          "embedded": 1,
+          "self-hosted": 1
+        },
+        "next": "q_i_a3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_a3",
+    "axis": "WORKFLOW — operational/on-call rhythms vs project delivery",
+    "prompt": "Keeping systems healthy at 2am is a real part of your job.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "monitoring": 1,
+          "observability": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_bA1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "security": 1,
+          "cicd": 1
+        },
+        "next": "q_i_bB1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bA1",
+    "axis": "TOOLING — IaC and provisioning tools",
+    "prompt": "Terraform or Pulumi is how your team provisions every cloud resource.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "terraform": 2,
+          "iac": 2,
+          "pulumi": 1
+        },
+        "next": "q_i_bA2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "kubernetes": 1,
+          "ansible": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_bA2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bA2",
+    "axis": "SCALE — fleet and cluster size",
+    "prompt": "You manage clusters or fleets big enough that manual changes are forbidden.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "kubernetes": 2,
+          "cloud-native": 1,
+          "platform-engineering": 1
+        },
+        "next": "q_i_bA3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "monitoring": 1,
+          "sre": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_bA3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bA3",
+    "axis": "PHILOSOPHY — golden paths vs team freedom",
+    "prompt": "Giving teams a golden path matters more to you than letting them choose their own stack.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "platform-engineering": 2,
+          "devops": 1,
+          "iac": 1
+        },
+        "next": "q_i_bA4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "observability": 1,
+          "sre": 1,
+          "distributed-systems": 1
+        },
+        "next": "q_i_bA4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bA4",
+    "axis": "AUDIENCE — internal platform consumers vs service reliability",
+    "prompt": "Other engineering teams are the primary consumers of what you build.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "platform-engineering": 2,
+          "kubernetes": 1,
+          "helm": 1,
+          "devops": 1
+        },
+        "next": "q_i_c1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sre": 2,
+          "monitoring": 1,
+          "observability": 1,
+          "distributed-systems": 1
+        },
+        "next": "q_i_c2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bB1",
+    "axis": "AUDIENCE — developers as primary users of your output",
+    "prompt": "Other developers are the end users of everything you ship.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "cli": 1,
+          "open-source": 1
+        },
+        "next": "q_i_bB2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "devsecops": 1,
+          "appsec": 1
+        },
+        "next": "q_i_bB2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bB2",
+    "axis": "CRAFT/RIGOUR — security posture and threat awareness",
+    "prompt": "Threat modelling is a recurring activity on your team, not a one-off audit.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "security": 2,
+          "devsecops": 1,
+          "appsec": 1,
+          "vulnerability": 1
+        },
+        "next": "q_i_bB3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "cicd": 1,
+          "productivity": 1
+        },
+        "next": "q_i_bB3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bB3",
+    "axis": "TOOLING — CLI/build tools vs security scanning tools",
+    "prompt": "Build speed and local developer feedback loops are where you spend your energy.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "cli": 2,
+          "cicd": 1
+        },
+        "next": "q_i_bB4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "code-security": 1,
+          "devsecops": 1
+        },
+        "next": "q_i_bB4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_bB4",
+    "axis": "PHILOSOPHY — shift-left security vs DX and productivity",
+    "prompt": "Security catches in the IDE or PR pipeline beat anything found in production.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devsecops": 2,
+          "security": 2,
+          "code-security": 1
+        },
+        "next": "q_i_c3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 2,
+          "cli": 1,
+          "productivity": 1,
+          "open-source": 1
+        },
+        "next": "q_i_c4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c1_1",
+    "axis": "TOOLING — Kubernetes and container orchestration",
+    "prompt": "Kubernetes is the substrate everything else runs on in your world.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "kubernetes": 2,
+          "helm": 1,
+          "cloud-native": 1
+        },
+        "next": "q_i_c1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "terraform": 1,
+          "iac": 1,
+          "platform-engineering": 1
+        },
+        "next": "q_i_c1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c1_2",
+    "axis": "MEDIUM/SURFACE — multi-cloud vs single-cloud strategy",
+    "prompt": "Your platform spans more than one cloud provider by design.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "multi-cloud": 2,
+          "terraform": 1,
+          "cloud-native": 1
+        },
+        "next": "q_i_c1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "aws": 1,
+          "gcp": 1,
+          "azure": 1,
+          "platform-engineering": 1
+        },
+        "next": "q_i_c1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c1_3",
+    "axis": "PROCESS/ARTIFACTS — IaC modules, golden paths, developer portals",
+    "prompt": "You own the Terraform modules or Helm charts that other teams fork and extend.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "iac": 2,
+          "terraform": 1,
+          "helm": 1,
+          "platform-engineering": 2
+        },
+        "next": "q_i_c1_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devops": 1,
+          "kubernetes": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_c1_4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c1_4",
+    "axis": "DEPTH — platform engineering specialist vs generalist devops",
+    "prompt": "Platform engineering is your identity, not just one part of a broader devops role.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "platform-engineering": 2,
+          "devops": 1,
+          "cloud-native": 1
+        },
+        "next": "q_i_d1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devops": 2,
+          "infrastructure": 1,
+          "aws": 1
+        },
+        "next": "q_i_d1_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c2_1",
+    "axis": "WORKFLOW — on-call ownership and pager culture",
+    "prompt": "Pager rotations and incident response windows shape how your week is structured.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "monitoring": 1,
+          "observability": 1
+        },
+        "next": "q_i_c2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "distributed-systems": 1,
+          "architecture": 1,
+          "cloud": 1
+        },
+        "next": "q_i_c2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c2_2",
+    "axis": "PROCESS/ARTIFACTS — SLOs, error budgets, post-mortems",
+    "prompt": "Error budgets and SLO burn-rate alerts are part of your standard toolkit.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "observability": 1,
+          "monitoring": 1
+        },
+        "next": "q_i_c2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "distributed-systems": 1,
+          "architecture": 1,
+          "cicd": 1
+        },
+        "next": "q_i_c2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c2_3",
+    "axis": "TOOLING — observability stack (Prometheus, Grafana, OpenTelemetry)",
+    "prompt": "Prometheus, Grafana, and OpenTelemetry are daily-use tools, not occasional references.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "prometheus": 2,
+          "grafana": 2,
+          "opentelemetry": 1
+        },
+        "next": "q_i_c2_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "logging": 1,
+          "apm": 1,
+          "observability": 1
+        },
+        "next": "q_i_c2_4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c2_4",
+    "axis": "CRAFT/RIGOUR — chaos engineering and incident retrospectives",
+    "prompt": "Controlled failure injection is a legitimate way to harden your systems.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "distributed-systems": 1,
+          "observability": 1
+        },
+        "next": "q_i_d2_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "monitoring": 1,
+          "logging": 1,
+          "cloud": 1
+        },
+        "next": "q_i_d2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c3_1",
+    "axis": "OWNERSHIP — supply chain and pipeline security",
+    "prompt": "The security of the build and release pipeline is your primary concern.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devsecops": 2,
+          "sbom": 1,
+          "cicd": 1,
+          "code-security": 1
+        },
+        "next": "q_i_c3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "appsec": 1,
+          "security": 1,
+          "web-security": 1
+        },
+        "next": "q_i_c3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c3_2",
+    "axis": "TOOLING — SAST, DAST, and vulnerability scanning",
+    "prompt": "Static analysis and dependency scanning tools run on every pull request.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "code-security": 2,
+          "devsecops": 1,
+          "vulnerability": 1
+        },
+        "next": "q_i_c3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "pentesting": 1,
+          "appsec": 1,
+          "security": 1
+        },
+        "next": "q_i_c3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c3_3",
+    "axis": "PHILOSOPHY — security as sprint-planning participant vs post-launch gate",
+    "prompt": "Your team treats security reviews as part of sprint planning, not a pre-launch checkbox.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devsecops": 2,
+          "appsec": 1,
+          "security": 1
+        },
+        "next": "q_i_c3_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "compliance": 1,
+          "vulnerability": 1
+        },
+        "next": "q_i_c3_4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c3_4",
+    "axis": "CRAFT/RIGOUR — threat modelling and offensive security",
+    "prompt": "You have run a threat model or a pen test exercise in the last six months.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "pentesting": 2,
+          "appsec": 1,
+          "security": 1
+        },
+        "next": "q_i_d3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "devsecops": 1,
+          "code-security": 1
+        },
+        "next": "q_i_d3_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c4_1",
+    "axis": "AUDIENCE — other engineers as first-class users",
+    "prompt": "Your success metric is how fast other engineers can ship, not what they ship.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "productivity": 2,
+          "cli": 1
+        },
+        "next": "q_i_c4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "open-source": 1,
+          "cli": 1
+        },
+        "next": "q_i_c4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c4_2",
+    "axis": "TOOLING — compilers, build systems, CLI tools",
+    "prompt": "Compilers, linkers, or build graphs are where you spend real engineering time.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "rust": 1,
+          "go": 1,
+          "bun": 1,
+          "vite": 1,
+          "cli": 1
+        },
+        "next": "q_i_c4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "cicd": 1,
+          "git": 1
+        },
+        "next": "q_i_c4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c4_3",
+    "axis": "PHILOSOPHY — DX measured in friction removed",
+    "prompt": "Reducing time-to-first-green-build is a legitimate product goal for your team.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "productivity": 1,
+          "cicd": 1
+        },
+        "next": "q_i_c4_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "open-source": 1,
+          "devtools": 1,
+          "commandline": 1
+        },
+        "next": "q_i_c4_4"
+      }
+    ]
+  },
+  {
+    "id": "q_i_c4_4",
+    "axis": "PROCESS/ARTIFACTS — open-source tooling and plugin ecosystems",
+    "prompt": "Open-source is the default distribution model for what your team produces.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "open-source": 2,
+          "devtools": 1,
+          "git": 1
+        },
+        "next": "q_i_d4_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "enterprise": 1,
+          "cicd": 1
+        },
+        "next": "q_i_d4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d1_1",
+    "axis": "SCALE — number of teams served by the platform",
+    "prompt": "Your internal developer platform serves ten or more engineering teams simultaneously.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "platform-engineering": 2,
+          "kubernetes": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_d1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devops": 1,
+          "iac": 1,
+          "cloud-native": 1
+        },
+        "next": "q_i_d1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d1_2",
+    "axis": "MEDIUM/SURFACE — edge and hybrid cloud patterns",
+    "prompt": "Edge compute or hybrid-cloud routing is something your platform already handles.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "edge-computing": 2,
+          "hybrid-cloud": 1,
+          "cloud-native": 1
+        },
+        "next": "q_i_d1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "aws": 1,
+          "gcp": 1,
+          "infrastructure": 1
+        },
+        "next": "q_i_d1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d1_3",
+    "axis": "TERMINAL",
+    "prompt": "Provisioning new clusters or cloud accounts is a self-service flow, not a ticket.",
+    "cols": 2,
+    "archetypeId": "cloud_platform_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "platform-engineering": 2,
+          "kubernetes": 1,
+          "iac": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devops": 1,
+          "terraform": 1,
+          "cloud-native": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_i_d2_1",
+    "axis": "SCALE — service count and traffic volume",
+    "prompt": "Your observability stack covers hundreds of services across multiple regions.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "distributed-systems": 2,
+          "observability": 1,
+          "sre": 1
+        },
+        "next": "q_i_d2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "monitoring": 1,
+          "sre": 1,
+          "cloud": 1
+        },
+        "next": "q_i_d2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d2_2",
+    "axis": "PROCESS/ARTIFACTS — runbooks and post-mortem culture",
+    "prompt": "Post-mortems at your company produce action items that actually get closed.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "observability": 1,
+          "dora": 1
+        },
+        "next": "q_i_d2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "monitoring": 1,
+          "distributed-systems": 1,
+          "architecture": 1
+        },
+        "next": "q_i_d2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d2_3",
+    "axis": "TERMINAL",
+    "prompt": "Reliability is a feature your team owns from day one, not a handoff after launch.",
+    "cols": 2,
+    "archetypeId": "sre_reliability_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sre": 2,
+          "observability": 1,
+          "monitoring": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "distributed-systems": 1,
+          "cloud": 1,
+          "architecture": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_i_d3_1",
+    "axis": "DEPTH — specialist appsec vs broad DevSecOps generalist",
+    "prompt": "Application security is your deep specialty, not a shared responsibility you rotate through.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "appsec": 2,
+          "web-security": 1,
+          "security": 1
+        },
+        "next": "q_i_d3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devsecops": 1,
+          "security": 1,
+          "compliance": 1
+        },
+        "next": "q_i_d3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d3_2",
+    "axis": "WORKFLOW — async security review cadence vs embedded sprint presence",
+    "prompt": "Your security work runs alongside active sprints, not as a separate gate process.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devsecops": 2,
+          "appsec": 1,
+          "security": 1
+        },
+        "next": "q_i_d3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "compliance": 1,
+          "vulnerability": 1
+        },
+        "next": "q_i_d3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d3_3",
+    "axis": "TERMINAL",
+    "prompt": "A vulnerability without a clear owner is your problem until it has one.",
+    "cols": 2,
+    "archetypeId": "security_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "security": 2,
+          "appsec": 1,
+          "devsecops": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "security": 1,
+          "code-security": 1,
+          "vulnerability": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_i_d4_1",
+    "axis": "DEPTH — specialist tooling author vs generalist developer productivity",
+    "prompt": "You are the person who builds the tools, not just the person who configures them.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "cli": 1,
+          "open-source": 1
+        },
+        "next": "q_i_d4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "productivity": 1,
+          "cicd": 1,
+          "devops": 1
+        },
+        "next": "q_i_d4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d4_2",
+    "axis": "CRAFT/RIGOUR — language-level and runtime performance concerns",
+    "prompt": "Startup latency and binary size are real constraints in the tools you write.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "rust": 2,
+          "go": 1,
+          "commandline": 1
+        },
+        "next": "q_i_d4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "bun": 1,
+          "vite": 1
+        },
+        "next": "q_i_d4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_i_d4_3",
+    "axis": "TERMINAL",
+    "prompt": "A well-crafted CLI feels as good to use as a well-designed API.",
+    "cols": 2,
+    "archetypeId": "devtools_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "devtools": 2,
+          "cli": 1,
+          "commandline": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "devtools": 1,
+          "open-source": 1,
+          "productivity": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_d_a1",
+    "axis": "MEDIUM/SURFACE",
+    "prompt": "Your day-to-day is closer to data pipelines than to product UIs.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "machine-learning": 1,
+          "python": 1,
+          "sql": 1
+        },
+        "next": "q_d_a2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "ai": 1,
+          "genai": 1,
+          "llm": 1,
+          "frontend": 1,
+          "backend": 1
+        },
+        "next": "q_d_a2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_a2",
+    "axis": "OWNERSHIP",
+    "prompt": "You own the model or the pipeline — not just the API call that wraps it.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "machine-learning": 2,
+          "mlops": 2,
+          "data-engineering": 1
+        },
+        "next": "q_d_a3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "openai": 1,
+          "genai": 1,
+          "analytics-platforms": 1,
+          "bi": 1
+        },
+        "next": "q_d_a3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_a3",
+    "axis": "DEPTH",
+    "prompt": "Model quality and training dynamics interest you more than business dashboards.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "machine-learning": 2,
+          "deep-learning": 2,
+          "pytorch": 1
+        },
+        "next": "q_d_bA1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-analysis": 2,
+          "sql": 2,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_bB1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bA1",
+    "axis": "TOOLING",
+    "prompt": "PyTorch or TensorFlow lives in your environment, not just your reading list.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "pytorch": 2,
+          "tensorflow": 2,
+          "cuda": 1
+        },
+        "next": "q_d_bA2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "langchain": 2,
+          "openai": 1,
+          "llm": 2
+        },
+        "next": "q_d_bA2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bA2",
+    "axis": "WORKFLOW",
+    "prompt": "Experiment tracking and eval harnesses are non-negotiable parts of your workflow.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "machine-learning": 2,
+          "python": 1
+        },
+        "next": "q_d_bA3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "prompt-engineering": 2,
+          "rag": 1,
+          "llmops": 1,
+          "genai": 1
+        },
+        "next": "q_d_bA3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bA3",
+    "axis": "PHILOSOPHY",
+    "prompt": "Open-weights fine-tuning beats hitting a hosted API for your use cases.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "huggingface": 2,
+          "llama": 2,
+          "transformers": 1
+        },
+        "next": "q_d_bA4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "openai": 2,
+          "anthropic": 1,
+          "llm": 1,
+          "genai": 1
+        },
+        "next": "q_d_bA4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bA4",
+    "axis": "SCALE",
+    "prompt": "You've wrestled with serving a model under real production traffic, not just a demo.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "machine-learning": 2,
+          "kubernetes": 1
+        },
+        "next": "q_d_c1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "genai": 2,
+          "llm": 2,
+          "prompt-engineering": 1
+        },
+        "next": "q_d_c2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bB1",
+    "axis": "MEDIUM/SURFACE",
+    "prompt": "Pipelines and data movement occupy more of your week than SQL queries do.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "etl": 2,
+          "apache-kafka": 1
+        },
+        "next": "q_d_bB2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sql": 2,
+          "bi": 2,
+          "data-analysis": 1
+        },
+        "next": "q_d_bB2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bB2",
+    "axis": "AUDIENCE",
+    "prompt": "Your primary consumers are other engineering systems, not business stakeholders.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-airflow": 1,
+          "apache-kafka": 1,
+          "etl": 1
+        },
+        "next": "q_d_bB3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "analytics-platforms": 2,
+          "data-visualization": 2,
+          "bi": 1
+        },
+        "next": "q_d_bB3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bB3",
+    "axis": "TOOLING",
+    "prompt": "Spark, Kafka, or Flink are closer to home than dbt or Tableau.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "apache-spark": 2,
+          "apache-kafka": 2,
+          "apache-flink": 1
+        },
+        "next": "q_d_bB4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sql": 2,
+          "data-visualization": 1,
+          "bi": 1,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_bB4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_bB4",
+    "axis": "OWNERSHIP",
+    "prompt": "Pipeline reliability and data freshness SLAs keep you up, not metric definitions.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "etl": 2,
+          "change-data-capture": 1
+        },
+        "next": "q_d_c3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "bi": 1
+        },
+        "next": "q_d_c4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c1_1",
+    "axis": "CRAFT/RIGOUR",
+    "prompt": "A thorough eval harness is table stakes before any model hits production.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "machine-learning": 2,
+          "python": 1
+        },
+        "next": "q_d_c1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "machine-learning": 1,
+          "pytorch": 1,
+          "deep-learning": 1,
+          "neural-networks": 1
+        },
+        "next": "q_d_c1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c1_2",
+    "axis": "PROCESS/ARTIFACTS",
+    "prompt": "Model cards and reproducible training runs are part of your standard deliverables.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "huggingface": 1,
+          "machine-learning": 2
+        },
+        "next": "q_d_c1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "pytorch": 1,
+          "deep-learning": 1,
+          "neural-networks": 1,
+          "machine-learning": 1
+        },
+        "next": "q_d_c1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c1_3",
+    "axis": "PHILOSOPHY",
+    "prompt": "Compute budget and GPU utilisation heavily shape your model architectural decisions.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "cuda": 2,
+          "pytorch": 1,
+          "deep-learning": 1,
+          "machine-learning": 1
+        },
+        "next": "q_d_c1_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "mlops": 1,
+          "machine-learning": 2,
+          "python": 1,
+          "scikit": 1
+        },
+        "next": "q_d_c1_4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c1_4",
+    "axis": "SCALE",
+    "prompt": "You've tuned serving latency and throughput for models beyond a single GPU instance.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "kubernetes": 1,
+          "machine-learning": 2
+        },
+        "next": "q_d_d1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "machine-learning": 2,
+          "pytorch": 1,
+          "deep-learning": 1,
+          "python": 1
+        },
+        "next": "q_d_d1_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c2_1",
+    "axis": "TOOLING",
+    "prompt": "LangChain, LlamaIndex, or a similar orchestration layer is central to your builds.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "langchain": 2,
+          "rag": 2,
+          "llm": 1
+        },
+        "next": "q_d_c2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "openai": 2,
+          "genai": 2,
+          "llm": 1
+        },
+        "next": "q_d_c2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c2_2",
+    "axis": "WORKFLOW",
+    "prompt": "Iterating on prompts and retrieval strategies takes more time than writing application code.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "prompt-engineering": 2,
+          "rag": 2,
+          "llmops": 1
+        },
+        "next": "q_d_c2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "genai": 1,
+          "llm": 1,
+          "ai": 1,
+          "vector-search": 1,
+          "embeddings": 1
+        },
+        "next": "q_d_c2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c2_3",
+    "axis": "AUDIENCE",
+    "prompt": "Your end product is a user-facing feature, not a research artifact or internal tool.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "genai": 2,
+          "ai": 2,
+          "llm": 1
+        },
+        "next": "q_d_c2_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "llmops": 2,
+          "openai": 1,
+          "prompt-engineering": 1,
+          "rag": 1
+        },
+        "next": "q_d_c2_4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c2_4",
+    "axis": "CRAFT/RIGOUR",
+    "prompt": "Grounding, citation accuracy, and hallucination rate are metrics you actively track.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "rag": 2,
+          "llmops": 2,
+          "prompt-engineering": 1
+        },
+        "next": "q_d_d2_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "genai": 2,
+          "llm": 2,
+          "ai": 1
+        },
+        "next": "q_d_d2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c3_1",
+    "axis": "WORKFLOW",
+    "prompt": "You are on-call for data pipelines the same way a backend engineer is on-call for services.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-airflow": 2,
+          "etl": 1
+        },
+        "next": "q_d_c3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-engineering": 1,
+          "etl": 1,
+          "apache-kafka": 1,
+          "apache-spark": 1
+        },
+        "next": "q_d_c3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c3_2",
+    "axis": "TOOLING",
+    "prompt": "CDC, schema registries, or event-streaming platforms are in your production stack.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "change-data-capture": 2,
+          "apache-kafka": 2,
+          "apache-flink": 1
+        },
+        "next": "q_d_c3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "apache-spark": 2,
+          "apache-airflow": 1,
+          "etl": 1,
+          "data-engineering": 1
+        },
+        "next": "q_d_c3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c3_3",
+    "axis": "PHILOSOPHY",
+    "prompt": "Streaming beats batch for most of the problems you care about solving.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "apache-kafka": 2,
+          "apache-flink": 2,
+          "data-streaming": 1
+        },
+        "next": "q_d_c3_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "apache-spark": 2,
+          "etl": 1,
+          "data-engineering": 1,
+          "big-data": 1
+        },
+        "next": "q_d_c3_4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c3_4",
+    "axis": "SCALE",
+    "prompt": "Your pipelines move petabytes or handle millions of events per second, not just gigabytes.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "big-data": 2,
+          "apache-spark": 2,
+          "databricks": 1
+        },
+        "next": "q_d_d3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-engineering": 2,
+          "etl": 1,
+          "apache-airflow": 1,
+          "snowflake": 1
+        },
+        "next": "q_d_d3_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c4_1",
+    "axis": "PROCESS/ARTIFACTS",
+    "prompt": "A well-structured dbt model is the artefact you take the most pride in shipping.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_c4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "bi": 2,
+          "data-visualization": 2,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_c4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c4_2",
+    "axis": "CRAFT/RIGOUR",
+    "prompt": "Metric definitions and data contracts matter more to you than dashboard prettiness.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "exploratory-data-analysis": 1
+        },
+        "next": "q_d_c4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-visualization": 2,
+          "bi": 2,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_c4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c4_3",
+    "axis": "AUDIENCE",
+    "prompt": "Most of your work ends up as a dashboard or a number a non-technical stakeholder reads.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "analytics-platforms": 2,
+          "bi": 2,
+          "data-visualization": 1
+        },
+        "next": "q_d_c4_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "exploratory-data-analysis": 1
+        },
+        "next": "q_d_c4_4"
+      }
+    ]
+  },
+  {
+    "id": "q_d_c4_4",
+    "axis": "MEDIUM/SURFACE",
+    "prompt": "SQL is your primary language — Python is a tool you reach for, not your home base.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "duckdb": 1
+        },
+        "next": "q_d_d4_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "python": 2,
+          "data-science": 2,
+          "statistical-analysis": 1
+        },
+        "next": "q_d_d4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d1_1",
+    "axis": "OWNERSHIP",
+    "prompt": "You own the full lifecycle — training, packaging, and deploying — not just a training script.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "machine-learning": 2,
+          "kubernetes": 1
+        },
+        "next": "q_d_d1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "machine-learning": 2,
+          "pytorch": 1,
+          "deep-learning": 1,
+          "python": 1
+        },
+        "next": "q_d_d1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d1_2",
+    "axis": "MEDIUM/SURFACE",
+    "prompt": "Notebooks are a starting point — your real work lives in a proper codebase and CI.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "mlops": 2,
+          "python": 1,
+          "machine-learning": 2
+        },
+        "next": "q_d_d1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "jupyter": 2,
+          "machine-learning": 1,
+          "deep-learning": 1,
+          "python": 1
+        },
+        "next": "q_d_d1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d1_3",
+    "axis": "DEPTH",
+    "prompt": "Architecture papers and training techniques excite you as much as a good benchmark score.",
+    "cols": 2,
+    "archetypeId": "ml_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "deep-learning": 2,
+          "neural-networks": 2,
+          "transformers": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "machine-learning": 2,
+          "mlops": 2,
+          "python": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_d_d2_1",
+    "axis": "DEPTH",
+    "prompt": "You care more about what the model can do for users than how it was trained.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "genai": 2,
+          "ai": 2,
+          "llm": 1
+        },
+        "next": "q_d_d2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "llmops": 2,
+          "prompt-engineering": 1,
+          "rag": 1,
+          "embeddings": 1
+        },
+        "next": "q_d_d2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d2_2",
+    "axis": "WORKFLOW",
+    "prompt": "Shipping a new AI feature means wiring context, tools, and retrieval — not touching model weights.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "rag": 2,
+          "vector-search": 2,
+          "embeddings": 1
+        },
+        "next": "q_d_d2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "langchain": 2,
+          "openai": 1,
+          "genai": 1,
+          "llm": 1
+        },
+        "next": "q_d_d2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d2_3",
+    "axis": "PROCESS/ARTIFACTS",
+    "prompt": "Your deliverable is a working product integration, not a research notebook or a trained model.",
+    "cols": 2,
+    "archetypeId": "ai_application_builder",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "genai": 2,
+          "llm": 2,
+          "ai": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "llmops": 2,
+          "prompt-engineering": 1,
+          "rag": 1,
+          "langchain": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_d_d3_1",
+    "axis": "CRAFT/RIGOUR",
+    "prompt": "Data quality checks and schema validation are built into your pipelines from day one.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "data-quality": 2,
+          "etl": 1
+        },
+        "next": "q_d_d3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-spark": 1,
+          "apache-kafka": 1,
+          "etl": 1
+        },
+        "next": "q_d_d3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d3_2",
+    "axis": "OWNERSHIP",
+    "prompt": "You treat data infrastructure the way platform teams treat compute — always on, always reliable.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "databricks": 1,
+          "snowflake": 1,
+          "etl": 1
+        },
+        "next": "q_d_d3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-airflow": 2,
+          "etl": 1
+        },
+        "next": "q_d_d3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d3_3",
+    "axis": "PHILOSOPHY",
+    "prompt": "Reproducible, well-documented pipelines are your craft — messy notebooks make you uncomfortable.",
+    "cols": 2,
+    "archetypeId": "data_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-airflow": 2,
+          "etl": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-engineering": 2,
+          "apache-spark": 1,
+          "big-data": 1,
+          "apache-kafka": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_d_d4_1",
+    "axis": "TOOLING",
+    "prompt": "Your analytical stack includes a BI layer that non-engineers actually open and trust.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "bi": 2,
+          "data-visualization": 2,
+          "analytics-platforms": 1
+        },
+        "next": "q_d_d4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "exploratory-data-analysis": 1
+        },
+        "next": "q_d_d4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d4_2",
+    "axis": "PHILOSOPHY",
+    "prompt": "A single reliable metric definition beats ten dashboard tabs of similar-looking numbers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "data-analysis": 2,
+          "sql": 2,
+          "statistical-analysis": 1
+        },
+        "next": "q_d_d4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "analytics-platforms": 2,
+          "data-visualization": 2,
+          "bi": 1
+        },
+        "next": "q_d_d4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_d_d4_3",
+    "axis": "DEPTH",
+    "prompt": "Translating business questions into clean, testable models is the part of the job you enjoy most.",
+    "cols": 2,
+    "archetypeId": "analytics_engineer",
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "sql": 2,
+          "data-analysis": 2,
+          "analytics-platforms": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "data-science": 2,
+          "python": 1,
+          "statistical-analysis": 1,
+          "data-visualization": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_s_a1",
+    "axis": "specialty_A_MEDIUM_SURFACE",
+    "prompt": "Your work targets a physical device or interactive experience, not a web service.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 1,
+          "embedded": 1,
+          "hardware": 1
+        },
+        "next": "q_s_a2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "leadership": 1,
+          "startup": 1,
+          "architecture": 1
+        },
+        "next": "q_s_a2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_a2",
+    "axis": "specialty_A_TOOLING",
+    "prompt": "Your daily toolchain is built around native SDKs, game engines, or embedded runtimes.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "gamedev": 1,
+          "firmware": 1,
+          "c++": 1,
+          "rust": 1
+        },
+        "next": "q_s_a3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "leadership": 1,
+          "business": 1,
+          "product-management": 1
+        },
+        "next": "q_s_a3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_a3",
+    "axis": "specialty_A_OWNERSHIP",
+    "prompt": "You personally write more code than you review, delegate, or pitch.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 1,
+          "embedded": 1,
+          "graphics-programming": 1
+        },
+        "next": "q_s_bA1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "leadership": 1,
+          "startup": 1,
+          "entrepreneurship": 1
+        },
+        "next": "q_s_bB1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bA1",
+    "axis": "specialty_subA_MEDIUM_SURFACE",
+    "prompt": "Your primary output runs on a screen and is meant to be played.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 2,
+          "gaming": 1,
+          "game-design": 1
+        },
+        "next": "q_s_bA2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "embedded": 2,
+          "firmware": 1,
+          "iot": 1
+        },
+        "next": "q_s_bA2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bA2",
+    "axis": "specialty_subA_TOOLING",
+    "prompt": "A game engine — Unity, Unreal, or Godot — is your primary development environment.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "unity": 2,
+          "unreal-engine": 2,
+          "godot": 1
+        },
+        "next": "q_s_bA3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "embedded": 2,
+          "arm": 1,
+          "c": 1,
+          "sensors": 1
+        },
+        "next": "q_s_bA3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bA3",
+    "axis": "specialty_subA_AUDIENCE",
+    "prompt": "Your end users are players or gamers, not operators, OEM customers, or field engineers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "gaming": 2,
+          "game-development": 1,
+          "mobile-gaming": 1
+        },
+        "next": "q_s_bA4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 2,
+          "hardware": 1,
+          "robotics": 1
+        },
+        "next": "q_s_bA4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bA4",
+    "axis": "specialty_subA_PHILOSOPHY",
+    "prompt": "Gameplay feel and player delight matter more to you than deterministic timing budgets.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-design": 2,
+          "game-development": 1,
+          "gamedev": 1
+        },
+        "next": "q_s_c1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "embedded": 2,
+          "firmware": 2,
+          "sensors": 1
+        },
+        "next": "q_s_c2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bB1",
+    "axis": "specialty_subB_OWNERSHIP",
+    "prompt": "Growing and unblocking a team of engineers is the core of your role.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "career": 1,
+          "company-culture": 1
+        },
+        "next": "q_s_bB2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 2,
+          "entrepreneurship": 1,
+          "business": 1
+        },
+        "next": "q_s_bB2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bB2",
+    "axis": "specialty_subB_SCALE",
+    "prompt": "You operate inside an existing organisation rather than building one from scratch.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "agile": 1,
+          "project-management": 1
+        },
+        "next": "q_s_bB3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 2,
+          "entrepreneurship": 2,
+          "venture-capital": 1
+        },
+        "next": "q_s_bB3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bB3",
+    "axis": "specialty_subB_PROCESS_ARTIFACTS",
+    "prompt": "OKRs, performance reviews, and headcount planning are recurring deliverables in your role.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "productivity": 1,
+          "continuous-improvement": 1
+        },
+        "next": "q_s_bB4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 2,
+          "revenue": 1,
+          "business-development": 1
+        },
+        "next": "q_s_bB4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_bB4",
+    "axis": "specialty_subB_PHILOSOPHY",
+    "prompt": "Your biggest accountability is to the people on your team, not to investors or a board.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "company-culture": 2,
+          "remote-work": 1
+        },
+        "next": "q_s_c3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 2,
+          "venture-capital": 1,
+          "entrepreneurship": 2
+        },
+        "next": "q_s_c4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c1_1",
+    "axis": "game_dev_SCALE",
+    "prompt": "You have shipped at least one game to a public store or platform.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 2,
+          "games": 1,
+          "steam": 1
+        },
+        "next": "q_s_c1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "gamedev": 1,
+          "game-design": 1,
+          "godot": 1
+        },
+        "next": "q_s_c1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c1_2",
+    "axis": "game_dev_WORKFLOW",
+    "prompt": "Crunch windows and milestone reviews are a familiar part of your release cycle.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 2,
+          "gamedev": 1,
+          "productivity": 1
+        },
+        "next": "q_s_c1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "game-design": 1,
+          "godot": 1,
+          "games": 1
+        },
+        "next": "q_s_c1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c1_3",
+    "axis": "game_dev_CRAFT_RIGOUR",
+    "prompt": "You run structured playtesting sessions before declaring a feature complete.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-design": 2,
+          "game-development": 1,
+          "gaming": 1
+        },
+        "next": "q_s_c1_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "gamedev": 1,
+          "unity": 1,
+          "performance": 1
+        },
+        "next": "q_s_c1_4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c1_4",
+    "axis": "game_dev_DEPTH",
+    "prompt": "Graphics, physics, or engine internals draw your curiosity more than game design.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "graphics-programming": 2,
+          "vulkan": 1,
+          "webgpu": 1,
+          "performance": 1
+        },
+        "next": "q_s_d1_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "game-design": 2,
+          "game-development": 1,
+          "unity": 1
+        },
+        "next": "q_s_d1_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c2_1",
+    "axis": "embedded_MEDIUM_SURFACE",
+    "prompt": "Your code runs on a microcontroller or SoC with no general-purpose operating system.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "embedded": 2,
+          "firmware": 2,
+          "arm": 1
+        },
+        "next": "q_s_c2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 2,
+          "robotics": 1,
+          "raspberry-pi": 1
+        },
+        "next": "q_s_c2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c2_2",
+    "axis": "embedded_WORKFLOW",
+    "prompt": "Hardware bring-up and board-level debugging are routine parts of your sprint.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "embedded": 2,
+          "hardware": 2,
+          "sensors": 1
+        },
+        "next": "q_s_c2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 2,
+          "mqtt": 1,
+          "robotics": 1
+        },
+        "next": "q_s_c2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c2_3",
+    "axis": "embedded_CRAFT_RIGOUR",
+    "prompt": "Certification standards or safety constraints — MISRA, ISO 26262, IEC 62443 — shape your code reviews.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "firmware": 2,
+          "embedded": 2,
+          "c": 1
+        },
+        "next": "q_s_c2_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 1,
+          "robotics": 1,
+          "rust": 1,
+          "sensors": 1
+        },
+        "next": "q_s_c2_4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c2_4",
+    "axis": "embedded_DEPTH",
+    "prompt": "Memory footprint and interrupt latency are metrics you track as obsessively as throughput.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "embedded": 2,
+          "firmware": 2,
+          "arm": 1
+        },
+        "next": "q_s_d2_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 2,
+          "robotics": 1,
+          "sensors": 1
+        },
+        "next": "q_s_d2_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c3_1",
+    "axis": "eng_leader_AUDIENCE",
+    "prompt": "Your most important stakeholder conversations are with engineers on your team, not executives.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "career": 1,
+          "devrel": 1
+        },
+        "next": "q_s_c3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "leadership": 1,
+          "architecture": 1,
+          "project-management": 1
+        },
+        "next": "q_s_c3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c3_2",
+    "axis": "eng_leader_WORKFLOW",
+    "prompt": "Your week contains more one-on-ones and team rituals than design or architecture sessions.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "agile": 1,
+          "scrum": 1
+        },
+        "next": "q_s_c3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "architecture": 1,
+          "technical-debt": 1,
+          "continuous-improvement": 1
+        },
+        "next": "q_s_c3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c3_3",
+    "axis": "eng_leader_CRAFT_RIGOUR",
+    "prompt": "You track team health metrics and delivery velocity the way others track code coverage.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "productivity": 1,
+          "continuous-improvement": 1
+        },
+        "next": "q_s_c3_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "technical-debt": 1,
+          "agile": 1,
+          "scrum": 1
+        },
+        "next": "q_s_c3_4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c3_4",
+    "axis": "eng_leader_DEPTH",
+    "prompt": "Servant leadership and psychological safety are concepts you reference in your own words.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "company-culture": 2,
+          "career": 1
+        },
+        "next": "q_s_d3_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "project-management": 1,
+          "agile": 1,
+          "architecture": 1
+        },
+        "next": "q_s_d3_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c4_1",
+    "axis": "founder_AUDIENCE",
+    "prompt": "Investors and potential customers are audiences you prepare for more than your own engineers.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "venture-capital": 1,
+          "entrepreneurship": 1
+        },
+        "next": "q_s_c4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 1,
+          "business": 1,
+          "product-management": 1
+        },
+        "next": "q_s_c4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c4_2",
+    "axis": "founder_WORKFLOW",
+    "prompt": "Fundraising, investor updates, and runway planning are recurring items on your calendar.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "venture-capital": 2,
+          "startup": 2,
+          "finance": 1
+        },
+        "next": "q_s_c4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "startup": 1,
+          "revenue": 1,
+          "business-development": 1
+        },
+        "next": "q_s_c4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c4_3",
+    "axis": "founder_CRAFT_RIGOUR",
+    "prompt": "A pitch deck you authored directly closed a funding round or a major customer.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "venture-capital": 2,
+          "y-combinator": 1
+        },
+        "next": "q_s_c4_4"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "entrepreneurship": 1,
+          "business": 1,
+          "open-source": 1
+        },
+        "next": "q_s_c4_4"
+      }
+    ]
+  },
+  {
+    "id": "q_s_c4_4",
+    "axis": "founder_DEPTH",
+    "prompt": "Setting the technical direction of the whole company falls on your shoulders.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "architecture": 1,
+          "entrepreneurship": 1
+        },
+        "next": "q_s_d4_1"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "business": 1,
+          "revenue": 1,
+          "business-development": 1
+        },
+        "next": "q_s_d4_1"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d1_1",
+    "axis": "game_dev_PROCESS_ARTIFACTS",
+    "prompt": "Playable build demos and vertical-slice reviews are standard checkpoints in your project.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 2,
+          "game-design": 1,
+          "gaming": 1
+        },
+        "next": "q_s_d1_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "gamedev": 1,
+          "unity": 1,
+          "godot": 1
+        },
+        "next": "q_s_d1_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d1_2",
+    "axis": "game_dev_TOOLING",
+    "prompt": "A profiler is always open in a second window when you are iterating on a scene.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "performance": 2,
+          "graphics-programming": 1,
+          "unreal-engine": 1
+        },
+        "next": "q_s_d1_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "game-design": 1,
+          "unity": 1,
+          "game-development": 1
+        },
+        "next": "q_s_d1_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d1_3",
+    "archetypeId": "game_developer",
+    "axis": "game_dev_PHILOSOPHY",
+    "prompt": "Fun is an engineering constraint you hold as seriously as frame rate.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "game-development": 2,
+          "gamedev": 2,
+          "game-design": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "graphics-programming": 1,
+          "performance": 1,
+          "game-development": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_s_d2_1",
+    "axis": "embedded_PROCESS_ARTIFACTS",
+    "prompt": "Firmware binaries, flashing scripts, and hardware test rigs are standard deliverables in your project.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "firmware": 2,
+          "embedded": 2,
+          "hardware": 1
+        },
+        "next": "q_s_d2_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 1,
+          "robotics": 1,
+          "sensors": 1
+        },
+        "next": "q_s_d2_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d2_2",
+    "axis": "embedded_TOOLING",
+    "prompt": "GCC, Clang, or a vendor toolchain — never a browser-based IDE — is where you spend your day.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "c": 2,
+          "c++": 1,
+          "embedded": 2
+        },
+        "next": "q_s_d2_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "rust": 2,
+          "iot": 1,
+          "robotics": 1
+        },
+        "next": "q_s_d2_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d2_3",
+    "archetypeId": "embedded_systems_engineer",
+    "axis": "embedded_PHILOSOPHY",
+    "prompt": "Bare metal feels like home; an OS is a luxury you design around, not a default.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "embedded": 2,
+          "firmware": 2,
+          "c": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "iot": 2,
+          "robotics": 1,
+          "arm": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_s_d3_1",
+    "axis": "eng_leader_PROCESS_ARTIFACTS",
+    "prompt": "Engineering all-hands decks, growth memos, and hiring rubrics are artefacts you own.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "career": 1,
+          "company-culture": 1
+        },
+        "next": "q_s_d3_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "project-management": 1,
+          "agile": 1,
+          "scrum": 1
+        },
+        "next": "q_s_d3_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d3_2",
+    "axis": "eng_leader_TOOLING",
+    "prompt": "Linear, Notion, or a roadmap tool gets more of your attention than a code editor.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "productivity": 1,
+          "project-management": 1
+        },
+        "next": "q_s_d3_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "architecture": 1,
+          "technical-debt": 1,
+          "continuous-improvement": 1
+        },
+        "next": "q_s_d3_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d3_3",
+    "archetypeId": "engineering_leader",
+    "axis": "eng_leader_PHILOSOPHY",
+    "prompt": "Your team shipping without you is the sign of your best work.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "leadership": 2,
+          "company-culture": 2,
+          "continuous-improvement": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "agile": 1,
+          "scrum": 1,
+          "technical-debt": 1
+        },
+        "next": null
+      }
+    ]
+  },
+  {
+    "id": "q_s_d4_1",
+    "axis": "founder_PROCESS_ARTIFACTS",
+    "prompt": "Pitch decks, investor updates, and growth memos are deliverables you produce yourself.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "venture-capital": 1,
+          "entrepreneurship": 1
+        },
+        "next": "q_s_d4_2"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "business": 1,
+          "revenue": 1,
+          "series-a": 1
+        },
+        "next": "q_s_d4_2"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d4_2",
+    "axis": "founder_TOOLING",
+    "prompt": "Your most-used tools include a spreadsheet model, a CRM, and a slide deck — not a linter.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "business-development": 1,
+          "finance": 1
+        },
+        "next": "q_s_d4_3"
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "entrepreneurship": 1,
+          "open-source": 1,
+          "business": 1
+        },
+        "next": "q_s_d4_3"
+      }
+    ]
+  },
+  {
+    "id": "q_s_d4_3",
+    "archetypeId": "technical_founder",
+    "axis": "founder_PHILOSOPHY",
+    "prompt": "Debugging production at 2 am and a board presentation at 9 am — same day.",
+    "cols": 2,
+    "options": [
+      {
+        "id": "yes",
+        "label": "Yes",
+        "tagWeights": {
+          "startup": 2,
+          "entrepreneurship": 2,
+          "y-combinator": 1
+        },
+        "next": null
+      },
+      {
+        "id": "no",
+        "label": "No",
+        "tagWeights": {
+          "business": 1,
+          "venture-capital": 1,
+          "revenue": 1
+        },
+        "next": null
+      }
+    ]
+  }
+]
diff --git a/packages/webapp/components/persona-quiz/personaQuizSampleConfig.ts b/packages/webapp/components/persona-quiz/personaQuizSampleConfig.ts
new file mode 100644
index 00000000000..6255c4cc837
--- /dev/null
+++ b/packages/webapp/components/persona-quiz/personaQuizSampleConfig.ts
@@ -0,0 +1,110 @@
+import type {
+  FunnelStepPersonaQuiz,
+  PersonaArchetype,
+  PersonaQuizQuestion,
+} from '@dailydotdev/shared/src/features/onboarding/types/funnel';
+import {
+  FunnelStepTransitionType,
+  FunnelStepType,
+} from '@dailydotdev/shared/src/features/onboarding/types/funnel';
+import generatedArchetypes from './personaQuizArchetypes.json';
+import generatedGraph from './personaQuizQuestionGraph.json';
+
+// --------------------------------------------------------------------------
+// Persona quiz config (v2: convergent DAG + archetype personas).
+//
+// Structure:
+//   - Q1: multi-choice broad-bucket opener (4 options)
+//   - Each bucket: convergent yes/no DAG, 4 phases (A: 5, B: 5, C: 5, D: 4)
+//   - Per-user path = Q1 + 19 yes/no = 20 questions
+//   - Branching at end of Phase A (→ sub-domain) and Phase B (→ specialty)
+//   - Terminal nodes (last question of Phase D) carry an `archetypeId`
+//
+// `personaQuizQuestionGraph.json` and `personaQuizArchetypes.json` are
+// LLM-authored offline by the persona-quiz subagent waves. Tag-weight values
+// are constrained to the system tag vocabulary.
+// --------------------------------------------------------------------------
+
+const Q1: PersonaQuizQuestion = {
+  id: 'q1_domain',
+  axis: 'domain',
+  prompt: 'Which of these feels most like your day?',
+  cols: 1,
+  options: [
+    {
+      id: 'product',
+      label: 'Building things people see and use',
+      emoji: '🎨',
+      tagWeights: { frontend: 1, 'web-development': 1 },
+      next: 'q_p_a1',
+    },
+    {
+      id: 'infra',
+      label: 'Building the stuff underneath products',
+      emoji: '⚙️',
+      tagWeights: { backend: 1, infrastructure: 1 },
+      next: 'q_i_a1',
+    },
+    {
+      id: 'data',
+      label: 'Working with data, models, or AI',
+      emoji: '🧪',
+      tagWeights: { 'data-science': 1, 'machine-learning': 1, ai: 1 },
+      next: 'q_d_a1',
+    },
+    {
+      id: 'specialty',
+      label: 'Something else (games, embedded, leadership, founder)',
+      emoji: '🎮',
+      tagWeights: { 'game-development': 1, embedded: 1 },
+      next: 'q_s_a1',
+    },
+  ],
+};
+
+const GENERATED_QUESTIONS = generatedGraph as unknown as PersonaQuizQuestion[];
+const ARCHETYPES = generatedArchetypes as unknown as PersonaArchetype[];
+
+const QUESTIONS: PersonaQuizQuestion[] = [Q1, ...GENERATED_QUESTIONS];
+
+export const personaQuizSampleParameters: FunnelStepPersonaQuiz['parameters'] =
+  {
+    headline: 'Let me figure out who you are',
+    explainer:
+      "A few quick yes/no questions and I'll guess your developer profile.",
+    entryQuestionId: 'q1_domain',
+    questions: QUESTIONS,
+    selection: {
+      // 15 questions total: Q1 + 14 yes/no (phases 3-4-4-3). Soft cap — the
+      // graph itself terminates on the last Phase D question (which carries
+      // an `archetypeId`).
+      maxQuestions: 15,
+      targetTotalTags: 8,
+      tagConfidenceFloor: 1,
+      fallbackTags: ['javascript', 'webdev'],
+    },
+    archetypes: ARCHETYPES,
+    reveal: {
+      eyebrow: 'You are a…',
+      cta: 'Looks good',
+      feedbackCta: "This doesn't fit me",
+      feedbackPlaceholder: 'Tell us what we got wrong (optional)',
+      addTagCta: 'Add tag',
+    },
+  };
+
+export const buildSamplePersonaQuizStep = (
+  onTransition: FunnelStepPersonaQuiz['onTransition'],
+): FunnelStepPersonaQuiz => ({
+  id: 'persona-quiz-sample',
+  type: FunnelStepType.PersonaQuiz,
+  parameters: personaQuizSampleParameters,
+  transitions: [
+    {
+      on: FunnelStepTransitionType.Complete,
+      destination: 'next',
+    },
+  ],
+  isActive: true,
+  onTransition,
+});
diff --git a/packages/webapp/package.json b/packages/webapp/package.json
index a538dd8220b..4b318de052c 100644
--- a/packages/webapp/package.json
+++ b/packages/webapp/package.json
@@ -16,6 +16,7 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx --max-warnings 0",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "typecheck:strict": "tsc -p tsconfig.strict.json --noEmit",
+    "generate:persona-quiz": "npx -y tsx scripts/generatePersonaQuiz.ts",
     "pretest": "npm run lint",
     "test": "jest --runInBand",
     "deploy": "vercel"
diff --git a/packages/webapp/pages/dev/persona-quiz.tsx b/packages/webapp/pages/dev/persona-quiz.tsx
new file mode 100644
index 00000000000..f678a898413
--- /dev/null
+++ b/packages/webapp/pages/dev/persona-quiz.tsx
@@ -0,0 +1,74 @@
+import type { ReactElement } from 'react';
+import React, { useCallback, useState } from 'react';
+import type { NextSeoProps } from 'next-seo';
+import type { FunnelStepPersonaQuiz } from '@dailydotdev/shared/src/features/onboarding/types/funnel';
+import { FunnelPersonaQuiz } from '@dailydotdev/shared/src/features/onboarding/steps/FunnelPersonaQuiz';
+import { NextSeo } from 'next-seo';
+import { defaultOpenGraph, defaultSeo } from '../../next-seo';
+import { buildSamplePersonaQuizStep } from '../../components/persona-quiz/personaQuizSampleConfig';
+
+const seo: NextSeoProps = {
+  ...defaultSeo,
+  title: 'Persona quiz preview',
+  description:
+    'Local preview of the onboarding persona quiz. Answers translate into feed tags.',
+  openGraph: {
+    ...defaultOpenGraph,
+    type: 'website',
+    site_name: 'daily.dev',
+  },
+  noindex: true,
+  nofollow: true,
+};
+
+type CompletionPayload = Parameters<
+  FunnelStepPersonaQuiz['onTransition']
+>[0]['details'];
+
+const PersonaQuizDevPage = (): ReactElement => {
+  const [completion, setCompletion] = useState<CompletionPayload | null>(null);
+  const [resetKey, setResetKey] = useState(0);
+
+  const onTransition = useCallback<FunnelStepPersonaQuiz['onTransition']>(
+    ({ details }) => {
+      if (details) {
+        setCompletion(details);
+      }
+    },
+    [],
+  );
+
+  const step = buildSamplePersonaQuizStep(onTransition);
+
+  return (
+    <>
+      <NextSeo {...seo} />
+      <main className="mx-auto flex min-h-dvh w-full flex-col items-center bg-background-default px-4 py-6 laptop:py-10">
+        {completion ? (
+          <section className="flex w-full max-w-md flex-col gap-4 rounded-12 border border-border-subtlest-tertiary bg-background-subtle p-6">
+            <h2 className="font-bold text-text-primary typo-title3">
+              Completion payload (would be sent to Freyja)
+            </h2>
+            <pre className="overflow-auto rounded-8 bg-background-default p-3 text-text-secondary typo-footnote">
+              {JSON.stringify(completion, null, 2)}
+            </pre>
+            <button
+              type="button"
+              onClick={() => {
+                setCompletion(null);
+                setResetKey((k) => k + 1);
+              }}
+              className="self-start rounded-8 border border-border-subtlest-tertiary px-3 py-2 text-text-primary typo-callout hover:border-text-tertiary"
+            >
+              Run again
+            </button>
+          </section>
+        ) : (
+          <FunnelPersonaQuiz key={resetKey} {...step} />
+        )}
+      </main>
+    </>
+  );
+};
+
+export default PersonaQuizDevPage;
diff --git a/packages/webapp/scripts/compute-next-level.mjs b/packages/webapp/scripts/compute-next-level.mjs
new file mode 100644
index 00000000000..41eb8b21597
--- /dev/null
+++ b/packages/webapp/scripts/compute-next-level.mjs
@@ -0,0 +1,106 @@
+/* eslint-disable no-console, no-restricted-syntax, no-continue, no-plusplus, no-bitwise */
+// Compute parent tag profiles for nodes at a given depth in the persona-quiz graph.
+// Output: JSON with { bucketId, nodeId, path, parentTags, yesNextId, noNextId, parentPrompt } per node.
+// Usage: node compute-next-level.mjs <graph-json-path> <target-depth>
+//   target-depth: 1 (root) … 5 (terminal). Children of the previous level.
+import { readFileSync } from 'fs';
+
+const [, , graphPath, depthStr] = process.argv;
+const targetDepth = Number(depthStr);
+const TOTAL_DEPTH = 9;
+
+const BUCKETS = {
+  q_p: {
+    id: 'product',
+    label: 'Building things people see and use',
+    seedTags: { frontend: 1, 'web-development': 1 },
+  },
+  q_i: {
+    id: 'infra',
+    label: 'Building the stuff underneath products',
+    seedTags: { backend: 1, infrastructure: 1 },
+  },
+  q_d: {
+    id: 'data',
+    label: 'Working with data, models, or AI',
+    seedTags: { 'data-science': 1, 'machine-learning': 1, ai: 1 },
+  },
+  q_s: {
+    id: 'specialty',
+    label: 'Niche / non-eng (games, embedded, leadership, founder)',
+    seedTags: { 'game-development': 1, embedded: 1 },
+  },
+};
+
+const graph = JSON.parse(readFileSync(graphPath, 'utf-8'));
+const byId = new Map(graph.map((q) => [q.id, q]));
+
+const nodeIdFor = (prefix, path) =>
+  path.length === 0 ? `${prefix}_root` : `${prefix}_${path.join('')}`;
+
+const applyWeights = (base, w) => {
+  const next = { ...base };
+  for (const [t, n] of Object.entries(w ?? {})) {
+    next[t] = (next[t] ?? 0) + n;
+  }
+  return next;
+};
+
+const out = [];
+for (const [prefix, bucket] of Object.entries(BUCKETS)) {
+  const numPaths = 2 ** (targetDepth - 1);
+  for (let i = 0; i < numPaths; i += 1) {
+    const path = [];
+    for (let bit = targetDepth - 2; bit >= 0; bit -= 1) {
+      path.push(((i >> bit) & 1) === 1 ? 'y' : 'n');
+    }
+    const nodeId = nodeIdFor(prefix, path);
+
+    // Walk from root, accumulating tags along the chosen branches.
+    let parentTags = { ...bucket.seedTags };
+    const parentPrompts = [];
+    for (let p = 0; p < path.length; p += 1) {
+      const ancestorId = nodeIdFor(prefix, path.slice(0, p));
+      const ancestor = byId.get(ancestorId);
+      if (!ancestor) {
+        throw new Error(`Missing ancestor ${ancestorId} for ${nodeId}`);
+      }
+      const optIdx = path[p] === 'y' ? 0 : 1;
+      parentTags = applyWeights(
+        parentTags,
+        ancestor.options[optIdx].tagWeights,
+      );
+      parentPrompts.push(
+        `${ancestor.prompt}  →  ${path[p] === 'y' ? 'YES' : 'NO'}`,
+      );
+    }
+
+    const isTerminal = targetDepth === TOTAL_DEPTH;
+    const yesNextId = isTerminal ? null : nodeIdFor(prefix, [...path, 'y']);
+    const noNextId = isTerminal ? null : nodeIdFor(prefix, [...path, 'n']);
+
+    // Format parent tags sorted by weight, top 12 for prompt brevity.
+    const sortedTags = Object.entries(parentTags)
+      .sort(([, a], [, b]) => b - a)
+      .slice(0, 12)
+      .map(([t, w]) => `${t}(${w})`)
+      .join(', ');
+
+    out.push({
+      bucketId: bucket.id,
+      bucketLabel: bucket.label,
+      nodeId,
+      path: path.join('') || '(root)',
+      parentTagsRaw: parentTags,
+      parentTagsCompact: sortedTags,
+      yesNextId,
+      noNextId,
+      parentPath: parentPrompts.length
+        ? parentPrompts.join('\n   then  ')
+        : '(this is the bucket entry)',
+      isTerminal,
+    });
+  }
+}
+
+console.log(JSON.stringify(out, null, 2));
diff --git a/packages/webapp/scripts/merge-and-validate-v2.mjs b/packages/webapp/scripts/merge-and-validate-v2.mjs
new file mode 100644
index 00000000000..8aee8b2919c
--- /dev/null
+++ b/packages/webapp/scripts/merge-and-validate-v2.mjs
@@ -0,0 +1,204 @@
+/* eslint-disable no-console, no-restricted-syntax, no-continue, no-plusplus, no-param-reassign */
+// Merge the 4 bucket-DAG shards into personaQuizQuestionGraph.json and run
+// validation gates: schema sanity, prompt uniqueness, reachability, tag vocab,
+// path length = 20. Fails non-zero on any check that doesn't pass.
+//
+// Usage: node merge-and-validate-v2.mjs
+import { readFileSync, writeFileSync } from 'fs';
+
+const TAG_FILE =
+  '/Users/davide/conductor/workspaces/apps/albuquerque-v2/tmp/recswipe-prod-tags.json';
+const SHARD_DIR =
+  '/Users/davide/conductor/workspaces/apps/albuquerque-v2/tmp/persona-quiz-shards';
+const GRAPH_PATH =
+  '/Users/davide/conductor/workspaces/apps/albuquerque-v2/packages/webapp/components/persona-quiz/personaQuizQuestionGraph.json';
+const ARCHETYPE_PATH =
+  '/Users/davide/conductor/workspaces/apps/albuquerque-v2/packages/webapp/components/persona-quiz/personaQuizArchetypes.json';
+const EXPECTED_PATH_LENGTH = 15;
+
+const validTags = new Set(JSON.parse(readFileSync(TAG_FILE, 'utf-8')));
+const archetypes = JSON.parse(readFileSync(ARCHETYPE_PATH, 'utf-8'));
+const archetypeIds = new Set(archetypes.map((a) => a.id));
+
+const allNodes = [];
+for (const bucket of ['product', 'infra', 'data', 'specialty']) {
+  const shard = JSON.parse(
+    readFileSync(`${SHARD_DIR}/${bucket}-dag.json`, 'utf-8'),
+  );
+  for (const node of shard) {
+    allNodes.push(node);
+  }
+}
+
+writeFileSync(GRAPH_PATH, `${JSON.stringify(allNodes, null, 2)}\n`);
+console.log(`Merged ${allNodes.length} nodes → personaQuizQuestionGraph.json`);
+
+// --- Validation gates ---
+const errors = [];
+const nodeMap = new Map(allNodes.map((n) => [n.id, n]));
+
+// 1. Schema sanity
+for (const n of allNodes) {
+  if (!Array.isArray(n.options) || n.options.length !== 2) {
+    errors.push(`schema: ${n.id} does not have exactly 2 options`);
+    continue;
+  }
+  const [y, no] = n.options;
+  if (y.id !== 'yes' || no.id !== 'no') {
+    errors.push(`schema: ${n.id} options not in [yes, no] order`);
+  }
+  const isTerminal = y.next === null && no.next === null;
+  if (isTerminal && !n.archetypeId) {
+    errors.push(`schema: ${n.id} is terminal but has no archetypeId`);
+  }
+  if (!isTerminal && (y.next === null || no.next === null)) {
+    errors.push(
+      `schema: ${n.id} mixes null and non-null next pointers (must be all-null or all-set)`,
+    );
+  }
+  if (n.archetypeId && !archetypeIds.has(n.archetypeId)) {
+    errors.push(`schema: ${n.id} has unknown archetypeId "${n.archetypeId}"`);
+  }
+  if (n.archetypeId && !isTerminal) {
+    errors.push(
+      `schema: ${n.id} has archetypeId but is not terminal (next != null)`,
+    );
+  }
+}
+
+// 2. Prompt uniqueness across the whole DAG
+const promptToIds = new Map();
+for (const n of allNodes) {
+  const key = n.prompt.trim().toLowerCase();
+  if (!promptToIds.has(key)) {
+    promptToIds.set(key, []);
+  }
+  promptToIds.get(key).push(n.id);
+}
+for (const [prompt, ids] of promptToIds) {
+  if (ids.length > 1) {
+    errors.push(
+      `uniqueness: prompt "${prompt.slice(0, 80)}…" appears in ${
+        ids.length
+      } nodes: ${ids.join(', ')}`,
+    );
+  }
+}
+
+// 3. Reachability: walk from each Q1 entry, ensure every node is reachable and
+//    every archetype is hit.
+const Q1_ENTRIES = ['q_p_a1', 'q_i_a1', 'q_d_a1', 'q_s_a1'];
+const reached = new Set();
+const reachedArchetypes = new Set();
+const stack = [...Q1_ENTRIES];
+while (stack.length) {
+  const id = stack.pop();
+  if (reached.has(id)) {
+    continue;
+  }
+  reached.add(id);
+  const node = nodeMap.get(id);
+  if (!node) {
+    errors.push(`reachability: missing node ${id} referenced as next pointer`);
+    continue;
+  }
+  if (node.archetypeId) {
+    reachedArchetypes.add(node.archetypeId);
+  }
+  for (const opt of node.options) {
+    if (opt.next) {
+      stack.push(opt.next);
+    }
+  }
+}
+for (const n of allNodes) {
+  if (!reached.has(n.id)) {
+    errors.push(`reachability: node ${n.id} is orphaned (unreachable from Q1)`);
+  }
+}
+for (const a of archetypes) {
+  if (!reachedArchetypes.has(a.id)) {
+    errors.push(`reachability: archetype "${a.id}" has no path leading to it`);
+  }
+}
+
+// 4. Tag vocab — every tagWeights key must be in /tmp/recswipe-prod-tags.json
+for (const n of allNodes) {
+  for (const opt of n.options) {
+    for (const tag of Object.keys(opt.tagWeights ?? {})) {
+      if (!validTags.has(tag)) {
+        errors.push(`tag-vocab: ${n.id}.${opt.id} uses invalid tag "${tag}"`);
+      }
+    }
+  }
+}
+// Archetype keyTags too
+for (const a of archetypes) {
+  for (const tag of a.keyTags) {
+    if (!validTags.has(tag)) {
+      errors.push(
+        `tag-vocab: archetype "${a.id}" uses invalid keyTag "${tag}"`,
+      );
+    }
+  }
+}
+
+// 5. Path length = 20 (Q1 + 19 yes/no)
+const longestPath = (id, depth = 1, visiting = new Set()) => {
+  if (visiting.has(id)) {
+    return depth;
+  } // cycle (shouldn't happen)
+  visiting.add(id);
+  const node = nodeMap.get(id);
+  if (!node) {
+    return depth;
+  }
+  let max = depth;
+  for (const opt of node.options) {
+    if (opt.next) {
+      max = Math.max(max, longestPath(opt.next, depth + 1, new Set(visiting)));
+    }
+  }
+  return max;
+};
+const shortestPath = (id, depth = 1, visiting = new Set()) => {
+  if (visiting.has(id)) {
+    return depth;
+  }
+  visiting.add(id);
+  const node = nodeMap.get(id);
+  if (!node) {
+    return depth;
+  }
+  let min = Infinity;
+  for (const opt of node.options) {
+    if (opt.next) {
+      min = Math.min(min, shortestPath(opt.next, depth + 1, new Set(visiting)));
+    } else {
+      min = Math.min(min, depth);
+    }
+  }
+  return min === Infinity ? depth : min;
+};
+for (const entryId of Q1_ENTRIES) {
+  const longest = longestPath(entryId) + 1; // +1 for Q1
+  const shortest = shortestPath(entryId) + 1;
+  if (longest !== EXPECTED_PATH_LENGTH || shortest !== EXPECTED_PATH_LENGTH) {
+    errors.push(
+      `path-length: from ${entryId}, expected ${EXPECTED_PATH_LENGTH}, got min=${shortest}, max=${longest}`,
+    );
+  }
+}
+
+// --- Report ---
+if (errors.length === 0) {
+  console.log(
+    `✓ All validation checks passed. ${allNodes.length} nodes, ${archetypes.length} archetypes, ${reachedArchetypes.size} reachable.`,
+  );
+  process.exit(0);
+}
+console.error(`✗ ${errors.length} validation errors:`);
+for (const e of errors) {
+  console.error(`  - ${e}`);
+}
+process.exit(1);
diff --git a/packages/webapp/scripts/merge-quiz-shards.mjs b/packages/webapp/scripts/merge-quiz-shards.mjs
new file mode 100644
index 00000000000..ac4c14f5d59
--- /dev/null
+++ b/packages/webapp/scripts/merge-quiz-shards.mjs
@@ -0,0 +1,76 @@
+/* eslint-disable no-console, no-restricted-syntax, no-continue, no-plusplus */
+// Merge persona-quiz subagent shard files into the cumulative graph JSON.
+// Filters tag weights against /tmp/recswipe-prod-tags.json.
+// Usage: node merge-quiz-shards.mjs <graph-json-path> <shard-dir> <level-tag>
+//        e.g. node merge-quiz-shards.mjs ../components/persona-quiz/personaQuizQuestionGraph.json /tmp/persona-quiz-shards L1
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+const [, , graphPath, shardDir, levelTag] = process.argv;
+const validTags = new Set(
+  JSON.parse(readFileSync('/tmp/recswipe-prod-tags.json', 'utf-8')),
+);
+
+const filterWeights = (weights) => {
+  if (!weights || typeof weights !== 'object') {
+    return {};
+  }
+  const out = {};
+  for (const [tag, w] of Object.entries(weights)) {
+    if (!validTags.has(tag)) {
+      continue;
+    }
+    const n = typeof w === 'number' ? w : Number(w);
+    if (!Number.isFinite(n) || n <= 0) {
+      continue;
+    }
+    out[tag] = Math.max(1, Math.min(2, Math.round(n)));
+  }
+  return out;
+};
+
+const cleanQuestion = (q) => ({
+  ...q,
+  options: q.options.map((opt) => ({
+    ...opt,
+    tagWeights: filterWeights(opt.tagWeights),
+  })),
+});
+
+const existing = existsSync(graphPath)
+  ? JSON.parse(readFileSync(graphPath, 'utf-8'))
+  : [];
+const byId = new Map(existing.map((q) => [q.id, q]));
+
+// Only the answer-shard files written by question-authoring agents.
+// Format: `<bucket>-L<n>.json` or `<bucket>-L<n>-<chunk>.json` (when the level
+// is split across multiple agents) where bucket ∈ {product, infra, data, specialty}.
+const shardFilePattern = new RegExp(
+  `^(product|infra|data|specialty)-${levelTag}(-[A-Z]+)?\\.json$`,
+);
+const shardFiles = readdirSync(shardDir).filter((f) =>
+  shardFilePattern.test(f),
+);
+let added = 0;
+let droppedTags = 0;
+for (const file of shardFiles) {
+  const raw = JSON.parse(readFileSync(resolve(shardDir, file), 'utf-8'));
+  for (const q of raw) {
+    const cleaned = cleanQuestion(q);
+    for (let i = 0; i < q.options.length; i += 1) {
+      const before = Object.keys(q.options[i].tagWeights ?? {}).length;
+      const after = Object.keys(cleaned.options[i].tagWeights).length;
+      droppedTags += before - after;
+    }
+    if (!byId.has(cleaned.id)) {
+      added += 1;
+    }
+    byId.set(cleaned.id, cleaned);
+  }
+}
+
+const merged = [...byId.values()];
+writeFileSync(graphPath, `${JSON.stringify(merged, null, 2)}\n`);
+console.log(
+  `Merged ${shardFiles.length} shards (${levelTag}) → ${merged.length} total nodes (+${added} new, ${droppedTags} invalid tags dropped)`,
+);
diff --git a/packages/webapp/tsconfig.eslint.json b/packages/webapp/tsconfig.eslint.json
index 9bf2a2bf67d..f172317cc85 100644
--- a/packages/webapp/tsconfig.eslint.json
+++ b/packages/webapp/tsconfig.eslint.json
@@ -17,7 +17,9 @@
     "__mocks__/**/*.ts",
     "__mocks__/**/*.tsx",
     "lib/**/*.ts",
-    "lib/**/*.tsx"
+    "lib/**/*.tsx",
+    "scripts/**/*.ts",
+    "scripts/**/*.mjs"
   ],
   "exclude": [
     "node_modules"
diff --git a/scripts/typecheck-strict-changed.js b/scripts/typecheck-strict-changed.js
index a0868d95600..6c9939036b9 100644
--- a/scripts/typecheck-strict-changed.js
+++ b/scripts/typecheck-strict-changed.js
@@ -58,6 +58,13 @@ const strictSkipList = new Set([
   // string handling / null returns) and should be addressed separately.
   'packages/extension/src/newtab/DndModal.tsx',
   'packages/webapp/pages/jobs/[id]/questions.tsx',
+  // Persona-quiz branch — only touched to register the new PersonaQuiz
+  // step in stepComponentMap (+1 import, +1 map entry). Pre-existing strict
+  // violations on lines 86/128/228/260/281 (Partial<Record> map indexing,
+  // scrollend event typing, null returns, Partial<FunnelBannerMessageParameters>
+  // spread, PaddleEventData handler shape) come from other authors months
+  // ago and should be addressed in a dedicated cleanup PR.
+  'packages/shared/src/features/onboarding/shared/FunnelStepper.tsx',
 ]);
 
 const changedFiles = getChangedTypescriptFiles().filter(