diff --git a/.github/actions/pnpm-cache/action.yml b/.github/actions/pnpm-cache/action.yml
deleted file mode 100644
index 0af26d52f..000000000
--- a/.github/actions/pnpm-cache/action.yml
+++ /dev/null
@@ -1,72 +0,0 @@
-name: 'pnpm Cache'
-description: 'Restore or save pnpm store cache'
-
-inputs:
-  mode:
-    description: 'Whether to restore or save the cache'
-    required: true
-  path:
-    description: 'Custom cache path (defaults to pnpm store path)'
-    required: false
-  key-prefix:
-    description: 'Cache key prefix (defaults to {runner.os}-pnpm-store)'
-    required: false
-  cache-hit:
-    description: 'Whether cache was hit (required for save mode)'
-    required: false
-  cache-key:
-    description: 'Cache key to use for saving (required for save mode)'
-    required: false
-
-outputs:
-  cache-hit:
-    description: 'Whether cache was restored'
-    value: ${{ steps.cache-restore.outputs.cache-hit }}
-  cache-key:
-    description: 'Cache key for use in save step'
-    value: ${{ steps.cache-restore.outputs.cache-primary-key }}
-
-runs:
-  using: 'composite'
-  steps:
-    # Restore mode steps
-    - name: Get pnpm store directory
-      if: inputs.mode == 'restore' && inputs.path == ''
-      id: pnpm-store
-      shell: bash
-      run: echo "path=$(pnpm store path)" >> $GITHUB_OUTPUT
-
-    - name: Compute cache key prefix
-      if: inputs.mode == 'restore'
-      id: key-prefix
-      shell: bash
-      run: |
-        if [ -n "${{ inputs.key-prefix }}" ]; then
-          echo "value=${{ inputs.key-prefix }}" >> $GITHUB_OUTPUT
-        else
-          echo "value=${{ runner.os }}-pnpm-store" >> $GITHUB_OUTPUT
-        fi
-
-    - name: Restore pnpm cache
-      if: inputs.mode == 'restore'
-      id: cache-restore
-      uses: actions/cache/restore@v4
-      with:
-        path: ${{ inputs.path || steps.pnpm-store.outputs.path }}
-        key: ${{ steps.key-prefix.outputs.value }}-${{ hashFiles('**/pnpm-lock.yaml') }}
-        restore-keys: |
-          ${{ steps.key-prefix.outputs.value }}-
-
-    # Save mode steps
-    - name: Get pnpm store directory for save
-      if: inputs.mode == 'save' && inputs.cache-hit != 'true' && inputs.path == ''
-      id: pnpm-store-save
-      shell: bash
-      run: echo "path=$(pnpm store path)" >> $GITHUB_OUTPUT
-
-    - name: Save pnpm cache
-      if: inputs.mode == 'save' && inputs.cache-hit != 'true'
-      uses: actions/cache/save@v4
-      with:
-        path: ${{ inputs.path || steps.pnpm-store-save.outputs.path }}
-        key: ${{ inputs.cache-key }}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 7fc5adc77..feec74f3b 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -11,140 +11,24 @@ on:
       - '*'
 
 jobs:
-  lint:
+  check:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Lint
+            command: pnpm lint
+          - name: Type check
+            command: pnpm typecheck
+          - name: Unit tests
+            command: pnpm test:unit
+          - name: Knip
+            command: pnpm knip
+    name: ${{ matrix.name }}
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+      - name: Setup
+        uses: complexdatacollective/github-actions/setup-pnpm@v1
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Restore pnpm cache
-        id: cache
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: restore
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Lint
-        run: pnpm lint
-
-      - name: Save pnpm cache
-        if: always()
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: save
-          cache-hit: ${{ steps.cache.outputs.cache-hit }}
-          cache-key: ${{ steps.cache.outputs.cache-key }}
-
-  typecheck:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Restore pnpm cache
-        id: cache
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: restore
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Type check
-        run: pnpm typecheck
-
-      - name: Save pnpm cache
-        if: always()
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: save
-          cache-hit: ${{ steps.cache.outputs.cache-hit }}
-          cache-key: ${{ steps.cache.outputs.cache-key }}
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Restore pnpm cache
-        id: cache
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: restore
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run unit tests
-        run: pnpm test:unit
-
-      - name: Save pnpm cache
-        if: always()
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: save
-          cache-hit: ${{ steps.cache.outputs.cache-hit }}
-          cache-key: ${{ steps.cache.outputs.cache-key }}
-
-  knip:
-    env:
-      SKIP_ENV_VALIDATION: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Restore pnpm cache
-        id: cache
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: restore
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run knip
-        run: pnpm knip
-
-      - name: Save pnpm cache
-        if: always()
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: save
-          cache-hit: ${{ steps.cache.outputs.cache-hit }}
-          cache-key: ${{ steps.cache.outputs.cache-key }}
+      - name: ${{ matrix.name }}
+        run: ${{ matrix.command }}
diff --git a/.github/workflows/chromatic.yml b/.github/workflows/chromatic.yml
index cb9cbba11..65620191c 100644
--- a/.github/workflows/chromatic.yml
+++ b/.github/workflows/chromatic.yml
@@ -10,17 +10,11 @@ jobs:
     name: Run Chromatic
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
+      - name: Setup
+        uses: complexdatacollective/github-actions/setup-pnpm@v1
         with:
-          fetch-depth: 0
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-      - uses: actions/setup-node@v4
-        with:
-          cache: 'pnpm'
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+          fetch-depth: '0'
+
       - name: Run Chromatic
         uses: chromaui/action@latest
         with:
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 9dcbf280c..c0620b71e 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -7,9 +7,9 @@ permissions:
   pull-requests: write
 
 on:
+  workflow_dispatch:
   push:
     branches: [main, next]
-  pull_request:
 
 jobs:
   e2e:
@@ -19,24 +19,13 @@ jobs:
       test-result: ${{ steps.test.outcome }}
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - name: Setup
+        id: setup
+        uses: complexdatacollective/github-actions/setup-pnpm@v1
         with:
-          node-version-file: '.nvmrc'
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Restore pnpm cache
-        id: cache
-        uses: ./.github/actions/pnpm-cache
-        with:
-          mode: restore
-          path: .pnpm-docker-store
-          key-prefix: pnpm-docker-store
+          install: 'false'
+          cache-path: .pnpm-docker-store
+          cache-key-prefix: pnpm-docker-store
 
       - name: Run E2E tests
         id: test
@@ -63,18 +52,44 @@ jobs:
           retention-days: 7
 
       - name: Save pnpm cache
-        if: always()
-        uses: ./.github/actions/pnpm-cache
+        if: always() && steps.setup.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
         with:
-          mode: save
           path: .pnpm-docker-store
-          cache-hit: ${{ steps.cache.outputs.cache-hit }}
-          cache-key: ${{ steps.cache.outputs.cache-key }}
+          key: ${{ steps.setup.outputs.cache-key }}
+
+  # Resolve PR context for both pull_request and workflow_dispatch events
+  resolve-pr:
+    if: failure() && needs.e2e.outputs.test-result == 'failure'
+    needs: e2e
+    runs-on: ubuntu-latest
+    outputs:
+      pr-number: ${{ steps.pr.outputs.number }}
+      head-sha: ${{ steps.pr.outputs.head_sha }}
+      branch: ${{ steps.pr.outputs.branch }}
+    steps:
+      - name: Resolve PR context
+        id: pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            echo "number=${{ github.event.pull_request.number }}" >> "$GITHUB_OUTPUT"
+            echo "head_sha=${{ github.event.pull_request.head.sha }}" >> "$GITHUB_OUTPUT"
+            echo "branch=${{ github.head_ref }}" >> "$GITHUB_OUTPUT"
+          else
+            PR_NUMBER=$(gh pr list --repo "${{ github.repository }}" --head "${{ github.ref_name }}" --json number --jq '.[0].number')
+            if [ -n "$PR_NUMBER" ] && [ "$PR_NUMBER" != "null" ]; then
+              echo "number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+            fi
+            echo "head_sha=${{ github.sha }}" >> "$GITHUB_OUTPUT"
+            echo "branch=${{ github.ref_name }}" >> "$GITHUB_OUTPUT"
+          fi
 
   # Deploy report to GitHub Pages on test failure (PR-specific subdirectory)
   deploy-report:
-    if: failure() && github.event_name == 'pull_request' && needs.e2e.outputs.test-result == 'failure'
-    needs: e2e
+    if: failure() && needs.resolve-pr.outputs.pr-number != ''
+    needs: [e2e, resolve-pr]
     runs-on: ubuntu-latest
     # Single concurrency group for all Pages deployments to prevent race conditions
     concurrency:
@@ -82,7 +97,7 @@ jobs:
       cancel-in-progress: false
     environment:
       name: github-pages
-      url: https://complexdatacollective.github.io/Fresco/pr-${{ github.event.pull_request.number }}/
+      url: https://complexdatacollective.github.io/Fresco/pr-${{ needs.resolve-pr.outputs.pr-number }}/
 
     steps:
       - name: Download playwright report
@@ -110,8 +125,8 @@ jobs:
           fi
 
           # Create PR-specific subdirectory with new report
-          mkdir -p merged/pr-${{ github.event.pull_request.number }}
-          cp -r new-report/playwright-report/* merged/pr-${{ github.event.pull_request.number }}/
+          mkdir -p merged/pr-${{ needs.resolve-pr.outputs.pr-number }}
+          cp -r new-report/playwright-report/* merged/pr-${{ needs.resolve-pr.outputs.pr-number }}/
 
           # Generate index page listing all reports
           echo "<ul>" > merged/index.html.tmp
@@ -159,21 +174,21 @@ jobs:
         uses: actions/deploy-pages@v4
 
       - name: Comment on PR with report link
-        uses: peter-evans/create-or-update-comment@v4
+        uses: peter-evans/create-or-update-comment@v5
         with:
-          issue-number: ${{ github.event.pull_request.number }}
+          issue-number: ${{ needs.resolve-pr.outputs.pr-number }}
           body: |
             ## Playwright E2E Test Report
 
             Tests failed. View the full report here:
 
-            **[https://complexdatacollective.github.io/Fresco/pr-${{ github.event.pull_request.number }}/](https://complexdatacollective.github.io/Fresco/pr-${{ github.event.pull_request.number }}/)**
+            👉 **[https://complexdatacollective.github.io/Fresco/pr-${{ needs.resolve-pr.outputs.pr-number }}/](https://complexdatacollective.github.io/Fresco/pr-${{ needs.resolve-pr.outputs.pr-number }}/)**
 
             <details>
             <summary>Report details</summary>
 
             - **Workflow run:** [View logs](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
-            - **Commit:** ${{ github.event.pull_request.head.sha }}
-            - **Branch:** `${{ github.head_ref }}`
+            - **Commit:** ${{ needs.resolve-pr.outputs.head-sha }}
+            - **Branch:** `${{ needs.resolve-pr.outputs.branch }}`
 
             </details>
diff --git a/.github/workflows/netlify-cleanup-preview.yml b/.github/workflows/netlify-cleanup-preview.yml
new file mode 100644
index 000000000..fd376e180
--- /dev/null
+++ b/.github/workflows/netlify-cleanup-preview.yml
@@ -0,0 +1,15 @@
+name: Delete Preview Branch on Neon
+on:
+  pull_request:
+    types: [closed]
+permissions:
+  contents: read
+jobs:
+  delete-preview:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: oven-sh/setup-bun@v2
+      - name: Delete Neon Branch
+        run: bunx neonctl branches delete preview/pr-${{ github.event.number }}-${{ github.event.pull_request.head.ref }} --project-id ${{ vars.NEON_PROJECT_ID }}
+        env:
+          NEON_API_KEY: ${{ secrets.NEON_API_KEY }}
diff --git a/.github/workflows/netlify-deploy-preview.yml b/.github/workflows/netlify-deploy-preview.yml
new file mode 100644
index 000000000..37584962c
--- /dev/null
+++ b/.github/workflows/netlify-deploy-preview.yml
@@ -0,0 +1,80 @@
+name: Deploy Preview
+
+on:
+  push:
+    branches-ignore:
+      - main
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  deploy-preview:
+    runs-on: ubuntu-latest
+    env:
+      NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+      NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
+    steps:
+      - name: Get PR number
+        id: pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          PR_NUMBER=$(gh pr list --repo "${{ github.repository }}" --head "${{ github.ref_name }}" --json number --jq '.[0].number')
+          if [ -n "$PR_NUMBER" ] && [ "$PR_NUMBER" != "null" ]; then
+            echo "number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+          else
+            echo "No open PR for branch ${{ github.ref_name }}, skipping deploy"
+            exit 0
+          fi
+
+      - name: Setup
+        uses: complexdatacollective/github-actions/setup-pnpm@v1
+
+      - name: Get branch name
+        id: branch-name
+        uses: tj-actions/branch-names@v9
+
+      - name: Create Neon Branch
+        id: create-branch
+        uses: neondatabase/create-branch-action@v6
+        with:
+          project_id: ${{ vars.NEON_PROJECT_ID }}
+          branch_name: preview/pr-${{ steps.pr.outputs.number }}-${{ steps.branch-name.outputs.current_branch }}
+          database: ${{ vars.NEON_DATABASE_NAME }}
+          role: ${{ vars.NEON_DATABASE_USERNAME }}
+          api_key: ${{ secrets.NEON_API_KEY }}
+          prisma: true
+
+      - name: Install Netlify CLI
+        run: pnpm add -g netlify-cli
+
+      - name: Set Neon database URLs in Netlify
+        run: |
+          netlify env:set DATABASE_URL "${{ steps.create-branch.outputs.db_url_pooled }}" --context branch:${{ steps.branch-name.outputs.current_branch }}
+          netlify env:set DATABASE_URL_UNPOOLED "${{ steps.create-branch.outputs.db_url }}" --context branch:${{ steps.branch-name.outputs.current_branch }}
+
+      - name: Create .env for build
+        run: |
+          echo "DATABASE_URL=${{ steps.create-branch.outputs.db_url_pooled }}" > .env
+          echo "DATABASE_URL_UNPOOLED=${{ steps.create-branch.outputs.db_url }}" >> .env
+
+      - name: Build
+        run: netlify build --context branch:${{ steps.branch-name.outputs.current_branch }}
+
+      - name: Deploy preview
+        id: deploy
+        run: |
+          netlify deploy --alias="pr-${{ steps.pr.outputs.number }}" --json > netlify-deploy.json
+          echo "deploy_url=$(jq -r '.deploy_url' netlify-deploy.json)" >> "$GITHUB_OUTPUT"
+
+      - name: Comment on Pull Request
+        uses: peter-evans/create-or-update-comment@v5
+        with:
+          issue-number: ${{ steps.pr.outputs.number }}
+          body: |
+            | Resource | Link |
+            |----------|------|
+            | Netlify Preview | ${{ steps.deploy.outputs.deploy_url }} |
+            | Neon branch | https://console.neon.tech/app/projects/${{ vars.NEON_PROJECT_ID }}/branches/${{ steps.create-branch.outputs.branch_id }} |
diff --git a/.gitignore b/.gitignore
index 2bd897044..a31849b0a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -57,3 +57,7 @@ storybook-static
 # Serena
 .serena
 .pnpm-store
+.pnpm-docker-store
+
+# Local Netlify folder
+.netlify
diff --git a/actions/interviews.ts b/actions/interviews.ts
index 4d05d40b9..4e5a80efd 100644
--- a/actions/interviews.ts
+++ b/actions/interviews.ts
@@ -221,12 +221,12 @@ export async function createInterview(data: CreateInterview) {
       },
     });
 
+    const { label, identifier } = createdInterview.participant;
+    const participantDisplay = label ? `${label} (${identifier})` : identifier;
+
     void addEvent(
       'Interview Started',
-      `Participant "${
-        createdInterview.participant.label ??
-        createdInterview.participant.identifier
-      }" started an interview`,
+      `Participant "${participantDisplay}" started an interview`,
     );
 
     safeRevalidateTag('getInterviews');
@@ -268,11 +268,17 @@ export async function finishInterview(interviewId: Interview['id']) {
       data: {
         finishTime: new Date(),
       },
+      include: {
+        participant: true,
+      },
     });
 
+    const { label, identifier } = updatedInterview.participant;
+    const participantDisplay = label ? `${label} (${identifier})` : identifier;
+
     void addEvent(
       'Interview Completed',
-      `Interview with ID ${interviewId} has been completed`,
+      `Participant "${participantDisplay}" completed an interview`,
     );
 
     const network = JSON.parse(
diff --git a/actions/reset.ts b/actions/reset.ts
index 42ec4536d..97038ffd1 100644
--- a/actions/reset.ts
+++ b/actions/reset.ts
@@ -3,9 +3,9 @@
 import { revalidatePath } from 'next/cache';
 import { env } from 'process';
 import { CacheTags, safeRevalidateTag } from '~/lib/cache';
+import { resetDatabase } from '~/lib/db/resetDatabase';
 import { getUTApi } from '~/lib/uploadthing/server-helpers';
 import { requireApiAuth } from '~/utils/auth';
-import { prisma } from '~/lib/db';
 
 export const resetAppSettings = async () => {
   if (env.NODE_ENV !== 'development') {
@@ -13,23 +13,7 @@ export const resetAppSettings = async () => {
   }
 
   try {
-    // Delete all data:
-    await Promise.all([
-      prisma.user.deleteMany(), // Deleting a user will cascade to Session and Key
-      prisma.participant.deleteMany(),
-      prisma.protocol.deleteMany(), // Deleting protocol will cascade to Interviews
-      prisma.appSettings.deleteMany(),
-      prisma.events.deleteMany(),
-      prisma.asset.deleteMany(),
-    ]);
-
-    // add a new initializedAt date
-    await prisma.appSettings.create({
-      data: {
-        key: 'initializedAt',
-        value: new Date().toISOString(),
-      },
-    });
+    await resetDatabase();
 
     revalidatePath('/');
     safeRevalidateTag(CacheTags);
diff --git a/app/(blobs)/(setup)/_components/SandboxCredentials.tsx b/app/(blobs)/(setup)/_components/SandboxCredentials.tsx
index ff24262bc..02f690f02 100644
--- a/app/(blobs)/(setup)/_components/SandboxCredentials.tsx
+++ b/app/(blobs)/(setup)/_components/SandboxCredentials.tsx
@@ -1,4 +1,3 @@
-import { KeyRound } from 'lucide-react';
 import { Alert, AlertDescription, AlertTitle } from '~/components/ui/Alert';
 import { env } from '~/env';
 
@@ -6,7 +5,6 @@ export default function SandboxCredentials() {
   if (!env.SANDBOX_MODE) return null;
   return (
     <Alert variant="info">
-      <KeyRound className="h-4 w-4" />
       <AlertTitle>Sandbox Credentials</AlertTitle>
       <AlertDescription>
         <div className="flex flex-col space-y-2">
diff --git a/app/(blobs)/(setup)/setup/page.tsx b/app/(blobs)/(setup)/setup/page.tsx
index 66ac4c47f..c9173cc93 100644
--- a/app/(blobs)/(setup)/setup/page.tsx
+++ b/app/(blobs)/(setup)/setup/page.tsx
@@ -15,7 +15,7 @@ async function getSetupData() {
     'allowAnonymousRecruitment',
   );
   const limitInterviews = await getAppSetting('limitInterviews');
-  const otherData = await prisma.$transaction([
+  const otherData = await Promise.all([
     prisma.protocol.count(),
     prisma.participant.count(),
   ]);
diff --git a/app/(interview)/preview/[protocolId]/interview/page.tsx b/app/(interview)/preview/[protocolId]/interview/page.tsx
index cad30820c..a01db7171 100644
--- a/app/(interview)/preview/[protocolId]/interview/page.tsx
+++ b/app/(interview)/preview/[protocolId]/interview/page.tsx
@@ -33,18 +33,13 @@ export default async function PreviewInterviewPage({
     notFound();
   }
 
-  // Only allow preview protocols
-  if (!protocol.isPreview) {
-    notFound();
-  }
-
   // Don't allow pending protocols (still uploading assets)
   if (protocol.isPending) {
     notFound();
   }
 
   // Update timestamp to prevent premature pruning
-  await prisma.protocol.update({
+  await prisma.previewProtocol.update({
     where: { id: protocolId },
     data: { importedAt: new Date() },
   });
diff --git a/app/(interview)/preview/[protocolId]/route.ts b/app/(interview)/preview/[protocolId]/route.ts
index 774aa4747..379415330 100644
--- a/app/(interview)/preview/[protocolId]/route.ts
+++ b/app/(interview)/preview/[protocolId]/route.ts
@@ -26,10 +26,10 @@ const handler = async (
     return NextResponse.redirect(url);
   }
 
-  // Verify that this is actually a preview protocol
-  const protocol = await prisma.protocol.findUnique({
+  // Verify that this is a preview protocol
+  const protocol = await prisma.previewProtocol.findUnique({
     where: { id: protocolId },
-    select: { isPreview: true, isPending: true, name: true },
+    select: { isPending: true, name: true },
   });
 
   if (!protocol) {
@@ -37,12 +37,6 @@ const handler = async (
     return NextResponse.redirect(url);
   }
 
-  if (!protocol.isPreview) {
-    // Not a preview protocol, redirect to regular onboard
-    url.pathname = `/onboard/${protocolId}`;
-    return NextResponse.redirect(url);
-  }
-
   if (protocol.isPending) {
     // Protocol assets are still being uploaded
     url.pathname = '/onboard/error';
diff --git a/app/api/preview/route.ts b/app/api/preview/[version]/_handlers/v1/handler.ts
similarity index 56%
rename from app/api/preview/route.ts
rename to app/api/preview/[version]/_handlers/v1/handler.ts
index 7689e243e..9bb758e8b 100644
--- a/app/api/preview/route.ts
+++ b/app/api/preview/[version]/_handlers/v1/handler.ts
@@ -1,8 +1,7 @@
-import { NextResponse, type NextRequest } from 'next/server';
+import { type NextRequest } from 'next/server';
 import { hash } from 'ohash';
 import { addEvent } from '~/actions/activityFeed';
 import { env } from '~/env';
-import { MIN_ARCHITECT_VERSION_FOR_PREVIEW } from '~/fresco.config';
 import trackEvent from '~/lib/analytics';
 import { prisma } from '~/lib/db';
 import { Prisma } from '~/lib/db/generated/client';
@@ -11,34 +10,25 @@ import { validateAndMigrateProtocol } from '~/lib/protocol/validateAndMigratePro
 import {
   generatePresignedUploadUrl,
   parseUploadThingToken,
+  registerUploadWithUploadThing,
 } from '~/lib/uploadthing/presigned';
+import { getUTApi } from '~/lib/uploadthing/server-helpers';
 import { getExistingAssets } from '~/queries/protocols';
 import { ensureError } from '~/utils/ensureError';
+import { getBaseUrl } from '~/utils/getBaseUrl';
 import { extractApikeyAssetsFromManifest } from '~/utils/protocolImport';
-import { compareSemver, semverSchema } from '~/utils/semVer';
-import { checkPreviewAuth, corsHeaders, jsonResponse } from './helpers';
-import type {
-  AbortResponse,
-  CompleteResponse,
-  InitializeResponse,
-  PreviewRequest,
-  PreviewResponse,
-  ReadyResponse,
-  RejectedResponse,
+import { checkPreviewAuth, jsonResponse } from './helpers';
+import {
+  type AbortResponse,
+  type CompleteResponse,
+  type InitializeResponse,
+  type PreviewRequest,
+  type ReadyResponse,
+  type RejectedResponse,
 } from './types';
 
-// Handle preflight OPTIONS request
-export function OPTIONS() {
-  return new NextResponse(null, {
-    status: 204,
-    headers: corsHeaders,
-  });
-}
-
-export async function POST(
-  req: NextRequest,
-): Promise<NextResponse<PreviewResponse>> {
-  const authError = await checkPreviewAuth(req);
+export async function v1(request: NextRequest) {
+  const authError = await checkPreviewAuth(request);
 
   if (authError) {
     return jsonResponse(authError.response, authError.status);
@@ -50,25 +40,12 @@ export async function POST(
   };
 
   try {
-    const body = (await req.json()) as PreviewRequest;
+    const body = (await request.json()) as PreviewRequest;
     const { type } = body;
 
     switch (type) {
       case 'initialize-preview': {
-        const { protocol: protocolJson, assetMeta, architectVersion } = body;
-
-        // Check Architect version compatibility
-        const architectVer = semverSchema.parse(`v${architectVersion}`);
-        const minVer = semverSchema.parse(
-          `v${MIN_ARCHITECT_VERSION_FOR_PREVIEW}`,
-        );
-        if (compareSemver(architectVer, minVer) < 0) {
-          const response: InitializeResponse = {
-            status: 'error',
-            message: `Architect versions below ${MIN_ARCHITECT_VERSION_FOR_PREVIEW} are not supported for preview mode`,
-          };
-          return jsonResponse(response, 400);
-        }
+        const { protocol: protocolJson, assetMeta } = body;
 
         // Validate and migrate protocol
         const validationResult = await validateAndMigrateProtocol(protocolJson);
@@ -88,8 +65,8 @@ export async function POST(
         // Ensures that we dont accumulate old preview protocols
         await prunePreviewProtocols();
 
-        // Check if this exact protocol already exists
-        const existingPreview = await prisma.protocol.findFirst({
+        // Check if this exact preview protocol already exists
+        const existingPreview = await prisma.previewProtocol.findFirst({
           where: {
             hash: protocolHash,
           },
@@ -97,7 +74,7 @@ export async function POST(
 
         // If protocol exists, return ready immediately
         if (existingPreview) {
-          const url = new URL(env.PUBLIC_URL ?? req.nextUrl.clone());
+          const url = new URL(env.PUBLIC_URL ?? request.nextUrl.clone());
           url.pathname = `/preview/${existingPreview.id}`;
 
           const response: ReadyResponse = {
@@ -130,49 +107,76 @@ export async function POST(
           (a) => !existingAssetIdSet.has(a.assetId),
         );
 
-        const tokenData = await parseUploadThingToken();
-
-        if (newAssets.length > 0 && !tokenData) {
-          const response: InitializeResponse = {
-            status: 'error',
-            message: 'UploadThing not configured',
+        // Generate presigned URLs for new assets that need uploading
+        type PresignedAssetData = {
+          uploadUrl: string;
+          assetRecord: {
+            assetId: string;
+            key: string;
+            name: string;
+            type: string;
+            url: string;
+            size: number;
           };
-          return jsonResponse(response, 500);
-        }
+        };
 
-        const presignedData = newAssets.map((asset) => {
-          const manifestEntry = assetManifest[asset.assetId];
-          const assetType = manifestEntry?.type ?? 'file';
+        let presignedData: PresignedAssetData[] = [];
 
-          const presigned = generatePresignedUploadUrl({
-            fileName: asset.name,
-            fileSize: asset.size,
-            tokenData: tokenData!,
-          });
+        if (newAssets.length > 0) {
+          const tokenData = await parseUploadThingToken();
 
-          if (!presigned) {
-            throw new Error('Failed to generate presigned URL');
+          if (!tokenData) {
+            const response: InitializeResponse = {
+              status: 'error',
+              message: 'UploadThing not configured',
+            };
+            return jsonResponse(response, 500);
           }
 
-          return {
-            uploadUrl: presigned.uploadUrl,
-            assetRecord: {
-              assetId: asset.assetId,
-              key: presigned.fileKey,
-              name: asset.name,
-              type: assetType,
-              url: presigned.fileUrl,
-              size: asset.size,
-            },
-          };
-        });
+          // tokenData is now narrowed to ParsedToken
+          presignedData = newAssets.map((asset) => {
+            const manifestEntry = assetManifest[asset.assetId];
+            const assetType = manifestEntry?.type ?? 'file';
+
+            const presigned = generatePresignedUploadUrl({
+              fileName: asset.name,
+              fileSize: asset.size,
+              tokenData,
+            });
+
+            if (!presigned) {
+              throw new Error('Failed to generate presigned URL');
+            }
+
+            return {
+              uploadUrl: presigned.uploadUrl,
+              assetRecord: {
+                assetId: asset.assetId,
+                key: presigned.fileKey,
+                name: asset.name,
+                type: assetType,
+                url: presigned.fileUrl,
+                size: asset.size,
+              },
+            };
+          });
+
+          const fileKeys = presignedData.map((d) => d.assetRecord.key);
+
+          // Register the uploads with UploadThing to enable CORS for browser uploads
+          const callbackUrl = `${getBaseUrl()}/api/uploadthing`;
+          await registerUploadWithUploadThing({
+            fileKeys,
+            tokenData,
+            callbackUrl,
+          });
+        }
 
-        const presignedUrls = presignedData.map((d) => d.uploadUrl);
         const assetsToCreate = presignedData.map((d) => d.assetRecord);
 
-        // Create the protocol with assets immediately
+        // Create the preview protocol with assets immediately
         // Mark as pending if there are assets to upload
-        const protocol = await prisma.protocol.create({
+        const protocol = await prisma.previewProtocol.create({
           data: {
             hash: protocolHash,
             name: `preview-${Date.now()}`,
@@ -184,8 +188,7 @@ export async function POST(
             stages: protocolToValidate.stages,
             codebook: protocolToValidate.codebook,
             experiments: protocolToValidate.experiments ?? Prisma.JsonNull,
-            isPreview: true,
-            isPending: presignedUrls.length > 0,
+            isPending: presignedData.length > 0,
             assets: {
               create: [...assetsToCreate, ...newApikeyAssets],
               connect: existingAssetIds.map((assetId) => ({ assetId })),
@@ -196,8 +199,8 @@ export async function POST(
         void addEvent('Preview Mode', `Preview protocol upload initiated`);
 
         // If no new assets to upload, return ready immediately
-        if (presignedUrls.length === 0) {
-          const url = new URL(env.PUBLIC_URL ?? req.nextUrl.clone());
+        if (presignedData.length === 0) {
+          const url = new URL(env.PUBLIC_URL ?? request.nextUrl.clone());
           url.pathname = `/preview/${protocol.id}`;
 
           const response: InitializeResponse = {
@@ -207,6 +210,13 @@ export async function POST(
           return jsonResponse(response);
         }
 
+        // Return presigned URLs with their associated assetIds
+        // so the client can match files to URLs correctly
+        const presignedUrls = presignedData.map((d) => ({
+          assetId: d.assetRecord.assetId,
+          url: d.uploadUrl,
+        }));
+
         const response: InitializeResponse = {
           status: 'job-created',
           protocolId: protocol.id,
@@ -218,8 +228,8 @@ export async function POST(
       case 'complete-preview': {
         const { protocolId } = body;
 
-        // Find the protocol
-        const protocol = await prisma.protocol.findUnique({
+        // Find the preview protocol
+        const protocol = await prisma.previewProtocol.findUnique({
           where: { id: protocolId },
         });
 
@@ -232,14 +242,14 @@ export async function POST(
         }
 
         // Update timestamp and clear pending flag to mark completion
-        await prisma.protocol.update({
+        await prisma.previewProtocol.update({
           where: { id: protocol.id },
           data: { importedAt: new Date(), isPending: false },
         });
 
         void addEvent('Preview Mode', `Preview protocol upload completed`);
 
-        const url = new URL(env.PUBLIC_URL ?? req.nextUrl.clone());
+        const url = new URL(env.PUBLIC_URL ?? request.nextUrl.clone());
         url.pathname = `/preview/${protocol.id}`;
 
         const response: CompleteResponse = {
@@ -252,8 +262,8 @@ export async function POST(
       case 'abort-preview': {
         const { protocolId } = body;
 
-        // Find and delete the protocol
-        const protocol = await prisma.protocol.findUnique({
+        // Find the preview protocol
+        const protocol = await prisma.previewProtocol.findUnique({
           where: { id: protocolId },
         });
 
@@ -265,8 +275,43 @@ export async function POST(
           return jsonResponse(response, 404);
         }
 
-        // Delete the protocol (cascades to related entities)
-        await prisma.protocol.delete({
+        // Find assets that are ONLY associated with this preview protocol
+        // (not shared with any regular protocols or other preview protocols)
+        const assetsToDelete = await prisma.asset.findMany({
+          where: {
+            AND: [
+              { previewProtocols: { some: { id: protocolId } } },
+              { previewProtocols: { every: { id: protocolId } } },
+              { protocols: { none: {} } },
+            ],
+          },
+          select: { key: true },
+        });
+
+        // Delete assets from UploadThing (best effort)
+        if (assetsToDelete.length > 0) {
+          try {
+            const utapi = await getUTApi();
+            await utapi.deleteFiles(assetsToDelete.map((a) => a.key));
+          } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Error deleting preview protocol assets:', error);
+          }
+        }
+
+        // Delete assets from database
+        if (assetsToDelete.length > 0) {
+          await prisma.asset.deleteMany({
+            where: {
+              key: {
+                in: assetsToDelete.map((a) => a.key),
+              },
+            },
+          });
+        }
+
+        // Delete the preview protocol
+        await prisma.previewProtocol.delete({
           where: { id: protocolId },
         });
 
diff --git a/app/api/preview/helpers.ts b/app/api/preview/[version]/_handlers/v1/helpers.ts
similarity index 100%
rename from app/api/preview/helpers.ts
rename to app/api/preview/[version]/_handlers/v1/helpers.ts
diff --git a/app/api/preview/types.ts b/app/api/preview/[version]/_handlers/v1/types.ts
similarity index 93%
rename from app/api/preview/types.ts
rename to app/api/preview/[version]/_handlers/v1/types.ts
index a905f90ba..22306931f 100644
--- a/app/api/preview/types.ts
+++ b/app/api/preview/[version]/_handlers/v1/types.ts
@@ -18,7 +18,6 @@ type InitializePreviewRequest = {
   type: 'initialize-preview';
   protocol: VersionedProtocol;
   assetMeta: AssetMetadata[];
-  architectVersion: string;
 };
 
 type CompletePreviewRequest = {
@@ -38,10 +37,15 @@ export type PreviewRequest =
 
 // RESPONSE TYPES
 
+type PresignedUrlWithAssetId = {
+  assetId: string;
+  url: string;
+};
+
 type JobCreatedResponse = {
   status: 'job-created';
   protocolId: string;
-  presignedUrls: string[];
+  presignedUrls: PresignedUrlWithAssetId[];
 };
 
 // No assets to upload
diff --git a/app/api/preview/[version]/route.ts b/app/api/preview/[version]/route.ts
new file mode 100644
index 000000000..8844d463a
--- /dev/null
+++ b/app/api/preview/[version]/route.ts
@@ -0,0 +1,47 @@
+import { type HTTP_METHOD } from 'next/dist/server/web/http';
+import { type NextRequest, NextResponse } from 'next/server';
+import { v1 } from './_handlers/v1/handler';
+import { corsHeaders } from './_handlers/v1/helpers';
+
+// Preflight options are always accepted with CORS headers
+export function OPTIONS() {
+  return new NextResponse(null, {
+    status: 204,
+    headers: corsHeaders,
+  });
+}
+
+type Handler = (request: NextRequest) => Response | Promise<Response>;
+
+const handlers: Record<string, Record<string, Handler>> = {
+  v1: { POST: v1 },
+};
+
+function createVersionedHandler(method: HTTP_METHOD) {
+  return async (
+    request: NextRequest,
+    { params }: { params: Promise<{ version: string }> },
+  ) => {
+    const { version } = await params;
+
+    const versionHandlers = handlers[version];
+    if (!versionHandlers) {
+      return Response.json(
+        { error: `Unsupported API version: ${version}` },
+        { status: 404 },
+      );
+    }
+
+    const handler = versionHandlers[method];
+    if (!handler) {
+      return Response.json(
+        { error: `${method} not supported in ${version}` },
+        { status: 405 },
+      );
+    }
+
+    return handler(request);
+  };
+}
+
+export const POST = createVersionedHandler('POST');
diff --git a/app/dashboard/_components/ProtocolsTable/ProtocolsTableClient.tsx b/app/dashboard/_components/ProtocolsTable/ProtocolsTableClient.tsx
index b180897d6..5e76f9fa0 100644
--- a/app/dashboard/_components/ProtocolsTable/ProtocolsTableClient.tsx
+++ b/app/dashboard/_components/ProtocolsTable/ProtocolsTableClient.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import { use, useState } from 'react';
-import { SuperJSON } from 'superjson';
+import SuperJSON from 'superjson';
 import { DeleteProtocolsDialog } from '~/app/dashboard/protocols/_components/DeleteProtocolsDialog';
 import { DataTable } from '~/components/DataTable/DataTable';
 import type { GetProtocolsQuery } from '~/queries/protocols';
diff --git a/app/dashboard/_components/RecruitmentTestSection.tsx b/app/dashboard/_components/RecruitmentTestSection.tsx
index 0646cc70e..37357c550 100644
--- a/app/dashboard/_components/RecruitmentTestSection.tsx
+++ b/app/dashboard/_components/RecruitmentTestSection.tsx
@@ -3,7 +3,7 @@ import type { Participant, Protocol } from '~/lib/db/generated/client';
 import { type Route } from 'next';
 import { useRouter } from 'next/navigation';
 import { use, useEffect, useState } from 'react';
-import { SuperJSON } from 'superjson';
+import SuperJSON from 'superjson';
 import { Button } from '~/components/ui/Button';
 import {
   Select,
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index 084ca2ba4..cd971c5ac 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -22,7 +22,7 @@ services:
     volumes:
       - postgres:/var/lib/postgresql/data:Z
     healthcheck:
-      test: ['CMD', 'pg_isready', '-U', 'postgres']
+      test: ['CMD', 'pg_isready', '-U', '${POSTGRES_USER}']
       interval: 5s
       timeout: 10s
       retries: 5
diff --git a/fresco.config.ts b/fresco.config.ts
index 0cc6747ba..6deac3a3f 100644
--- a/fresco.config.ts
+++ b/fresco.config.ts
@@ -1,6 +1,5 @@
 export const PROTOCOL_EXTENSION = '.netcanvas';
 export const APP_SUPPORTED_SCHEMA_VERSIONS = [7, 8];
-export const MIN_ARCHITECT_VERSION_FOR_PREVIEW = '7.0.1';
 
 // If unconfigured, the app will shut down after 2 hours (7200000 ms)
 export const UNCONFIGURED_TIMEOUT = 7200000;
diff --git a/knip.config.ts b/knip.config.ts
index 64df2b117..4080145b2 100644
--- a/knip.config.ts
+++ b/knip.config.ts
@@ -25,6 +25,7 @@ const config: KnipConfig = {
   ],
   ignoreBinaries: [
     'docker-compose', // Should be installed by developers if needed, not a project dependency
+    'netlify', // Installed globally in CI workflow, not a project dependency
   ],
   ignoreIssues: {
     // TestFixtures/WorkerFixtures are used by Playwright via base.extend<>() generic type parameter.
diff --git a/lib/__tests__/cache-collision.test.ts b/lib/__tests__/cache-collision.test.ts
new file mode 100644
index 000000000..5d7ae1fce
--- /dev/null
+++ b/lib/__tests__/cache-collision.test.ts
@@ -0,0 +1,159 @@
+/**
+ * Tests to verify that cached query functions exercised by this suite produce
+ * unique cache keys.
+ *
+ * This helps prevent cache key collisions where different functions return
+ * each other's data due to minification making function bodies identical.
+ */
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+
+// Track all calls to unstable_cache with their keyParts
+const capturedCacheCalls: {
+  keyParts: string[] | undefined;
+  tags: string[] | undefined;
+  functionName: string;
+}[] = [];
+
+// Mock unstable_cache to capture keyParts from all cached functions
+vi.mock('next/cache', () => ({
+  unstable_cache: vi.fn(
+    (
+      fn: () => Promise<unknown>,
+      keyParts: string[] | undefined,
+      options?: { tags?: string[] },
+    ) => {
+      capturedCacheCalls.push({
+        keyParts,
+        tags: options?.tags,
+        // Try to extract a meaningful name from the function
+        functionName: fn.name || fn.toString().slice(0, 50),
+      });
+      return fn;
+    },
+  ),
+  revalidateTag: vi.fn(),
+}));
+
+// Mock environment
+vi.mock('~/env', () => ({
+  env: {
+    DISABLE_NEXT_CACHE: false,
+  },
+}));
+
+// Mock Prisma client to prevent actual DB calls
+vi.mock('~/lib/db', () => ({
+  prisma: {
+    apiToken: { findMany: vi.fn().mockResolvedValue([]) },
+    protocol: {
+      findMany: vi.fn().mockResolvedValue([]),
+      findFirst: vi.fn().mockResolvedValue(null),
+    },
+    participant: { findMany: vi.fn().mockResolvedValue([]) },
+    interview: { count: vi.fn().mockResolvedValue(0) },
+    $transaction: vi.fn().mockResolvedValue([0, 0, 0]),
+  },
+}));
+
+// Mock server-only (it throws if imported in non-server context)
+vi.mock('server-only', () => ({}));
+
+describe('Cache Key Collision Prevention', () => {
+  beforeAll(async () => {
+    // Clear any previous calls
+    capturedCacheCalls.length = 0;
+
+    // Import all query modules that use createCachedFunction
+    // This triggers the cached function creation at module load time
+    await import('~/queries/apiTokens');
+    await import('~/queries/protocols');
+    await import('~/queries/participants');
+    await import('~/queries/summaryStatistics');
+  });
+
+  it('should have captured multiple cached function registrations', () => {
+    // Sanity check: we should have captured calls from the imports
+    expect(capturedCacheCalls.length).toBeGreaterThan(0);
+  });
+
+  it('all cached functions should have unique keyParts', () => {
+    // Group functions by their keyParts
+    const keyPartsToFunctions = new Map<string, string[]>();
+
+    for (const call of capturedCacheCalls) {
+      const keyPartsString = call.keyParts?.join(',') ?? '(empty)';
+      const funcName = call.tags?.join(',') ?? call.functionName;
+
+      if (!keyPartsToFunctions.has(keyPartsString)) {
+        keyPartsToFunctions.set(keyPartsString, []);
+      }
+      keyPartsToFunctions.get(keyPartsString)!.push(funcName);
+    }
+
+    // Find collisions (keyParts with multiple functions)
+    const collisions: { keyParts: string; functions: string[] }[] = [];
+
+    for (const [keyParts, functions] of keyPartsToFunctions) {
+      if (functions.length > 1) {
+        collisions.push({ keyParts, functions });
+      }
+    }
+
+    // Log collisions for visibility
+    if (collisions.length > 0) {
+      // eslint-disable-next-line no-console
+      console.log('\n🔴 CACHE KEY COLLISIONS DETECTED:');
+      for (const collision of collisions) {
+        // eslint-disable-next-line no-console
+        console.log(`  keyParts: "${collision.keyParts}"`);
+        // eslint-disable-next-line no-console
+        console.log(`  functions sharing this key:`);
+        for (const func of collision.functions) {
+          // eslint-disable-next-line no-console
+          console.log(`    - ${func}`);
+        }
+      }
+    }
+
+    expect(collisions).toEqual([]);
+  });
+
+  it('getApiTokens and getProtocols should have different keyParts', () => {
+    const apiTokensCall = capturedCacheCalls.find((call) =>
+      call.tags?.includes('getApiTokens'),
+    );
+    const protocolsCall = capturedCacheCalls.find(
+      (call) =>
+        call.tags?.includes('getProtocols') &&
+        !call.tags?.includes('getProtocolsByHash'),
+    );
+
+    expect(apiTokensCall).toBeDefined();
+    expect(protocolsCall).toBeDefined();
+
+    const apiTokensKey = apiTokensCall?.keyParts?.join(',');
+    const protocolsKey = protocolsCall?.keyParts?.join(',');
+
+    expect(apiTokensKey).not.toEqual(protocolsKey);
+  });
+
+  it('no cached function should have empty keyParts', () => {
+    const emptyKeyPartsCalls = capturedCacheCalls.filter(
+      (call) => !call.keyParts || call.keyParts.length === 0,
+    );
+
+    expect(emptyKeyPartsCalls).toEqual([]);
+  });
+
+  it('each cached function keyParts should contain at least one tag', () => {
+    for (const call of capturedCacheCalls) {
+      const keyParts = call.keyParts ?? [];
+      const tags = call.tags ?? [];
+
+      // At least one tag should be in keyParts (our fix ensures tags are used as default keyParts)
+      const hasTagInKeyParts = tags.some((tag) => keyParts.includes(tag));
+
+      expect(hasTagInKeyParts).toBe(true);
+    }
+  });
+});
diff --git a/lib/__tests__/cache.test.ts b/lib/__tests__/cache.test.ts
new file mode 100644
index 000000000..379591a66
--- /dev/null
+++ b/lib/__tests__/cache.test.ts
@@ -0,0 +1,167 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock unstable_cache to capture the keyParts it receives
+const mockUnstableCache = vi.fn(
+  (
+    fn: () => Promise<string>,
+    keyParts: string[] | undefined,
+    _options?: object,
+  ) => {
+    const wrapper = () => fn();
+    return Object.assign(wrapper, { _keyParts: keyParts });
+  },
+);
+
+vi.mock('next/cache', () => ({
+  unstable_cache: mockUnstableCache,
+  revalidateTag: vi.fn(),
+}));
+
+vi.mock('~/env', () => ({
+  env: {
+    DISABLE_NEXT_CACHE: false,
+  },
+}));
+
+describe('createCachedFunction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllEnvs();
+  });
+
+  it('should include VERCEL_DEPLOYMENT_ID in keyParts when options.keyParts is provided', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', 'dpl_test123');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['appSettings'], { keyParts: ['custom-key'] });
+
+    expect(mockUnstableCache).toHaveBeenCalledWith(
+      testFn,
+      // Tags + explicit keyParts + deployment ID
+      expect.arrayContaining(['appSettings', 'custom-key', 'dpl_test123']),
+      expect.any(Object),
+    );
+  });
+
+  it('should include VERCEL_DEPLOYMENT_ID in keyParts even when options is not provided', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', 'dpl_test456');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['appSettings']);
+
+    const call = mockUnstableCache.mock.calls[0] as [
+      () => Promise<string>,
+      string[] | undefined,
+    ];
+    const keyParts = call[1];
+
+    expect(keyParts).not.toBeUndefined();
+    expect(keyParts).toContain('dpl_test456');
+  });
+
+  it('should include VERCEL_DEPLOYMENT_ID in keyParts when options is provided without keyParts', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', 'dpl_test789');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['appSettings'], { revalidate: 60 });
+
+    const call = mockUnstableCache.mock.calls[0] as [
+      () => Promise<string>,
+      string[] | undefined,
+      object,
+    ];
+    const keyParts = call[1];
+
+    expect(keyParts).not.toBeUndefined();
+    expect(keyParts).toContain('dpl_test789');
+  });
+
+  it('should use tags as default keyParts when VERCEL_DEPLOYMENT_ID is not set and no options provided', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', '');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['appSettings']);
+
+    const call = mockUnstableCache.mock.calls[0] as [
+      () => Promise<string>,
+      string[] | undefined,
+    ];
+    const keyParts = call[1];
+
+    // Tags should be used as default keyParts to prevent cache collisions
+    expect(keyParts).toEqual(['appSettings']);
+  });
+
+  it('should use tags as default keyParts and append VERCEL_DEPLOYMENT_ID when set', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', 'dpl_collision_test');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['getProtocols', 'summaryStatistics']);
+
+    const call = mockUnstableCache.mock.calls[0] as [
+      () => Promise<string>,
+      string[] | undefined,
+    ];
+    const keyParts = call[1];
+
+    // Should include all tags plus deployment ID
+    expect(keyParts).toEqual([
+      'getProtocols',
+      'summaryStatistics',
+      'dpl_collision_test',
+    ]);
+  });
+
+  it('should combine tags with explicit keyParts when provided', async () => {
+    vi.stubEnv('VERCEL_DEPLOYMENT_ID', '');
+
+    vi.resetModules();
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    createCachedFunction(testFn, ['appSettings'], {
+      keyParts: ['custom-key'],
+    });
+
+    const call = mockUnstableCache.mock.calls[0] as [
+      () => Promise<string>,
+      string[] | undefined,
+    ];
+    const keyParts = call[1];
+
+    // Tags should always be included, with explicit keyParts appended
+    expect(keyParts).toEqual(['appSettings', 'custom-key']);
+  });
+
+  it('should bypass cache entirely when DISABLE_NEXT_CACHE is true', async () => {
+    vi.resetModules();
+    vi.doMock('~/env', () => ({
+      env: {
+        DISABLE_NEXT_CACHE: true,
+      },
+    }));
+
+    const { createCachedFunction } = await import('../cache');
+
+    const testFn = () => Promise.resolve('result');
+    const result = createCachedFunction(testFn, ['appSettings']);
+
+    expect(result).toBe(testFn);
+    expect(mockUnstableCache).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/__tests__/preview-protocol-pruning.test.ts b/lib/__tests__/preview-protocol-pruning.test.ts
index f0e335ff4..8de8dfa8f 100644
--- a/lib/__tests__/preview-protocol-pruning.test.ts
+++ b/lib/__tests__/preview-protocol-pruning.test.ts
@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // Mock Prisma
 const mockPrisma = {
-  protocol: {
+  previewProtocol: {
     findMany: vi.fn(),
     deleteMany: vi.fn(),
   },
@@ -46,15 +46,15 @@ describe('prunePreviewProtocols', () => {
       name: 'Old Protocol',
     };
 
-    mockPrisma.protocol.findMany.mockResolvedValue([oldProtocol]);
+    mockPrisma.previewProtocol.findMany.mockResolvedValue([oldProtocol]);
     mockPrisma.asset.findMany.mockResolvedValue([]);
-    mockPrisma.protocol.deleteMany.mockResolvedValue({ count: 1 });
+    mockPrisma.previewProtocol.deleteMany.mockResolvedValue({ count: 1 });
 
     const result = await prunePreviewProtocols();
 
     expect(result.deletedCount).toBe(1);
     expect(result.error).toBeUndefined();
-    expect(mockPrisma.protocol.deleteMany).toHaveBeenCalledWith({
+    expect(mockPrisma.previewProtocol.deleteMany).toHaveBeenCalledWith({
       where: {
         id: {
           in: ['old-protocol'],
@@ -67,12 +67,12 @@ describe('prunePreviewProtocols', () => {
     const { prunePreviewProtocols } =
       await import('../preview-protocol-pruning');
 
-    mockPrisma.protocol.findMany.mockResolvedValue([]);
+    mockPrisma.previewProtocol.findMany.mockResolvedValue([]);
 
     const result = await prunePreviewProtocols();
 
     expect(result.deletedCount).toBe(0);
-    expect(mockPrisma.protocol.deleteMany).not.toHaveBeenCalled();
+    expect(mockPrisma.previewProtocol.deleteMany).not.toHaveBeenCalled();
   });
 
   it('should delete associated assets from UploadThing', async () => {
@@ -88,10 +88,10 @@ describe('prunePreviewProtocols', () => {
     const assets = [{ key: 'ut-key-1' }, { key: 'ut-key-2' }];
 
     mockDeleteFiles.mockResolvedValue({ success: true });
-    mockPrisma.protocol.findMany.mockResolvedValue([oldProtocol]);
+    mockPrisma.previewProtocol.findMany.mockResolvedValue([oldProtocol]);
     mockPrisma.asset.findMany.mockResolvedValue(assets);
     mockPrisma.asset.deleteMany.mockResolvedValue({ count: 2 });
-    mockPrisma.protocol.deleteMany.mockResolvedValue({ count: 1 });
+    mockPrisma.previewProtocol.deleteMany.mockResolvedValue({ count: 1 });
 
     const result = await prunePreviewProtocols();
 
@@ -103,7 +103,7 @@ describe('prunePreviewProtocols', () => {
     const { prunePreviewProtocols } =
       await import('../preview-protocol-pruning');
 
-    mockPrisma.protocol.findMany.mockRejectedValue(new Error('Database error'));
+    mockPrisma.previewProtocol.findMany.mockRejectedValue(new Error('Database error'));
 
     const result = await prunePreviewProtocols();
 
@@ -115,28 +115,28 @@ describe('prunePreviewProtocols', () => {
     const { prunePreviewProtocols } =
       await import('../preview-protocol-pruning');
 
-    mockPrisma.protocol.findMany.mockResolvedValue([]);
+    mockPrisma.previewProtocol.findMany.mockResolvedValue([]);
 
     await prunePreviewProtocols();
 
     // Verify that findMany was called with the correct query structure
-    expect(mockPrisma.protocol.findMany).toHaveBeenCalled();
+    expect(mockPrisma.previewProtocol.findMany).toHaveBeenCalled();
 
-    const mockCalls = mockPrisma.protocol.findMany.mock.calls;
+    const mockCalls = mockPrisma.previewProtocol.findMany.mock.calls;
     expect(mockCalls.length).toBeGreaterThan(0);
 
-    // Check that the query includes isPreview: true
+    // Check that the query includes the OR clause for pending/completed
     const firstCall = mockCalls[0];
     expect(firstCall).toBeDefined();
     if (firstCall) {
       type QueryArgs = {
         where?: {
-          isPreview?: boolean;
           OR?: { isPending?: boolean; importedAt?: { lt?: Date } }[];
         };
       };
       const args = firstCall[0] as QueryArgs;
-      expect(args.where?.isPreview).toBe(true);
+      expect(args.where?.OR).toBeDefined();
+      expect(args.where?.OR?.length).toBe(2);
     }
   });
 });
diff --git a/lib/cache.ts b/lib/cache.ts
index 4dee447ce..1ea552a0d 100644
--- a/lib/cache.ts
+++ b/lib/cache.ts
@@ -46,7 +46,13 @@ export function createCachedFunction<T extends UnstableCacheParams[0]>(
 
   // eslint-disable-next-line no-process-env
   const VERCEL_DEPLOYMENT_ID = process.env.VERCEL_DEPLOYMENT_ID;
-  const keyParts = options?.keyParts?.concat(
+
+  // Always include tags in keyParts to prevent cache key collisions between
+  // functions with similar structure after minification.
+  const keyParts = [
+    ...tags,
+    ...(options?.keyParts ?? []),
+  ].concat(
     VERCEL_DEPLOYMENT_ID ? [VERCEL_DEPLOYMENT_ID] : [],
   );
 
diff --git a/lib/db/__tests__/resetDatabase.test.ts b/lib/db/__tests__/resetDatabase.test.ts
new file mode 100644
index 000000000..5b1b7c612
--- /dev/null
+++ b/lib/db/__tests__/resetDatabase.test.ts
@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const SCHEMA_PATH = path.resolve(__dirname, '../schema.prisma');
+
+// Parse schema.prisma to get all model names and cascade-deleted models
+function parseSchema(): { allModels: string[]; cascadeDeletedModels: string[] } {
+  const schema = fs.readFileSync(SCHEMA_PATH, 'utf-8');
+
+  // Extract all model names
+  const modelRegex = /^model\s+(\w+)\s*\{/gm;
+  const allModels: string[] = [];
+  let match;
+  while ((match = modelRegex.exec(schema)) !== null) {
+    if (match[1]) allModels.push(match[1]);
+  }
+
+  // Find models that have onDelete: Cascade in their relations
+  // These models are automatically deleted when their parent is deleted
+  const cascadeDeletedModels: string[] = [];
+  const modelBlockRegex = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+
+  while ((match = modelBlockRegex.exec(schema)) !== null) {
+    const modelName = match[1];
+    const modelBody = match[2];
+    if (modelName && modelBody && /onDelete:\s*Cascade/i.test(modelBody)) {
+      cascadeDeletedModels.push(modelName);
+    }
+  }
+
+  return { allModels, cascadeDeletedModels };
+}
+
+const mockPrisma = {
+  user: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  participant: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  protocol: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  previewProtocol: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  appSettings: {
+    deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
+    create: vi.fn().mockResolvedValue({ key: 'initializedAt', value: '' }),
+  },
+  events: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  asset: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+  apiToken: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }) },
+};
+
+vi.mock('~/lib/db', () => ({
+  prisma: mockPrisma,
+}));
+
+describe('resetDatabase', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should delete all models defined in the schema (except cascade-deleted ones)', async () => {
+    const { resetDatabase } = await import('~/lib/db/resetDatabase');
+    const { allModels, cascadeDeletedModels } = parseSchema();
+
+    // Models that need explicit deletion (not cascade-deleted)
+    const modelsRequiringDeletion = allModels.filter(
+      (model) => !cascadeDeletedModels.includes(model),
+    );
+
+    await resetDatabase();
+
+    // Verify each model that requires deletion has deleteMany called
+    for (const model of modelsRequiringDeletion) {
+      const prismaKey = model.charAt(0).toLowerCase() + model.slice(1);
+      const mockModel = mockPrisma[prismaKey as keyof typeof mockPrisma];
+
+      expect(
+        mockModel,
+        `Missing mock for model "${model}" - add it to mockPrisma and resetDatabase()`,
+      ).toBeDefined();
+
+      expect(
+        'deleteMany' in mockModel ? mockModel.deleteMany : undefined,
+        `Model "${model}" should have deleteMany called in resetDatabase()`,
+      ).toHaveBeenCalled();
+    }
+  });
+
+  it('should create only initializedAt setting after clearing data', async () => {
+    const { resetDatabase } = await import('~/lib/db/resetDatabase');
+
+    await resetDatabase();
+
+    expect(mockPrisma.appSettings.create).toHaveBeenCalledOnce();
+    expect(mockPrisma.appSettings.create).toHaveBeenCalledWith({
+      data: {
+        key: 'initializedAt',
+        value: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
+      },
+    });
+  });
+});
diff --git a/lib/db/migrations/20260302171028_add_preview_protocol_table/migration.sql b/lib/db/migrations/20260302171028_add_preview_protocol_table/migration.sql
new file mode 100644
index 000000000..3272f3e61
--- /dev/null
+++ b/lib/db/migrations/20260302171028_add_preview_protocol_table/migration.sql
@@ -0,0 +1,63 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `isPending` on the `Protocol` table. All the data in the column will be lost.
+  - You are about to drop the column `isPreview` on the `Protocol` table. All the data in the column will be lost.
+
+*/
+-- Delete existing preview protocols before dropping the columns
+-- Preview protocols are temporary and should not persist across this migration
+DELETE FROM "Protocol" WHERE "isPreview" = true;
+
+-- Clean up orphaned assets (those no longer linked to any Protocol)
+DELETE FROM "Asset" a
+WHERE NOT EXISTS (
+  SELECT 1 FROM "_AssetToProtocol" pa WHERE pa."A" = a."key"
+);
+
+-- DropIndex
+DROP INDEX "Protocol_isPreview_importedAt_idx";
+
+-- AlterTable
+ALTER TABLE "Protocol" DROP COLUMN "isPending",
+DROP COLUMN "isPreview";
+
+-- CreateTable
+CREATE TABLE "PreviewProtocol" (
+    "id" TEXT NOT NULL,
+    "hash" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "schemaVersion" INTEGER NOT NULL,
+    "description" TEXT,
+    "importedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "lastModified" TIMESTAMP(3) NOT NULL,
+    "stages" JSONB NOT NULL,
+    "codebook" JSONB NOT NULL,
+    "experiments" JSONB,
+    "isPending" BOOLEAN NOT NULL DEFAULT false,
+
+    CONSTRAINT "PreviewProtocol_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "_PreviewProtocolAssets" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+
+    CONSTRAINT "_PreviewProtocolAssets_AB_pkey" PRIMARY KEY ("A","B")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PreviewProtocol_hash_key" ON "PreviewProtocol"("hash");
+
+-- CreateIndex
+CREATE INDEX "PreviewProtocol_importedAt_idx" ON "PreviewProtocol"("importedAt");
+
+-- CreateIndex
+CREATE INDEX "_PreviewProtocolAssets_B_index" ON "_PreviewProtocolAssets"("B");
+
+-- AddForeignKey
+ALTER TABLE "_PreviewProtocolAssets" ADD CONSTRAINT "_PreviewProtocolAssets_A_fkey" FOREIGN KEY ("A") REFERENCES "Asset"("key") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_PreviewProtocolAssets" ADD CONSTRAINT "_PreviewProtocolAssets_B_fkey" FOREIGN KEY ("B") REFERENCES "PreviewProtocol"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/lib/db/resetDatabase.ts b/lib/db/resetDatabase.ts
new file mode 100644
index 000000000..b79c316f1
--- /dev/null
+++ b/lib/db/resetDatabase.ts
@@ -0,0 +1,32 @@
+import { prisma } from '~/lib/db';
+
+/**
+ * Deletes all data from the database and creates a fresh initializedAt setting.
+ * This is the core database reset logic, separated from orchestration concerns
+ * (auth, cache invalidation, file cleanup) for testability.
+ */
+export async function resetDatabase(): Promise<void> {
+  // Delete all data from all tables
+  // Note: Some models cascade-delete their children:
+  // - User cascades to Session, Key
+  // - Protocol cascades to Interview
+  // - Participant cascades to Interview
+  await Promise.all([
+    prisma.user.deleteMany(),
+    prisma.participant.deleteMany(),
+    prisma.protocol.deleteMany(),
+    prisma.previewProtocol.deleteMany(),
+    prisma.appSettings.deleteMany(),
+    prisma.events.deleteMany(),
+    prisma.asset.deleteMany(),
+    prisma.apiToken.deleteMany(),
+  ]);
+
+  // Create fresh initializedAt setting
+  await prisma.appSettings.create({
+    data: {
+      key: 'initializedAt',
+      value: new Date().toISOString(),
+    },
+  });
+}
diff --git a/lib/db/schema.prisma b/lib/db/schema.prisma
index a42d70ad8..28a5da514 100644
--- a/lib/db/schema.prisma
+++ b/lib/db/schema.prisma
@@ -50,21 +50,35 @@ model Protocol {
   assets        Asset[]
   interviews    Interview[]
   experiments   Json?
-  isPreview     Boolean     @default(false)
-  isPending     Boolean     @default(false)
+}
+
+model PreviewProtocol {
+  id            String   @id @default(cuid())
+  hash          String   @unique
+  name          String
+  schemaVersion Int
+  description   String?
+  importedAt    DateTime @default(now())
+  lastModified  DateTime
+  stages        Json
+  codebook      Json
+  assets        Asset[]  @relation("PreviewProtocolAssets")
+  experiments   Json?
+  isPending     Boolean  @default(false)
 
-  @@index([isPreview, importedAt])
+  @@index([importedAt])
 }
 
 model Asset {
-  key       String     @id
-  assetId   String     @unique
-  name      String
-  type      String
-  url       String
-  size      Int
-  protocols Protocol[]
-  value     String?
+  key              String            @id
+  assetId          String            @unique
+  name             String
+  type             String
+  url              String
+  size             Int
+  protocols        Protocol[]
+  previewProtocols PreviewProtocol[] @relation("PreviewProtocolAssets")
+  value            String?
 
   @@index(fields: [assetId, key])
 }
diff --git a/lib/form/utils/fieldValidation.ts b/lib/form/utils/fieldValidation.ts
index 84ab41938..18e6688fe 100644
--- a/lib/form/utils/fieldValidation.ts
+++ b/lib/form/utils/fieldValidation.ts
@@ -376,6 +376,52 @@ export const tanStackValidations = {
         ? `Your answer must be less than the value of "${variableName}"`
         : undefined;
     },
+
+  greaterThanOrEqualToVariable:
+    (variableId: string): TanStackValidator =>
+    ({ value, fieldApi, validationContext }) => {
+      const variable = getVariable(variableId, validationContext);
+
+      if (!variable) {
+        return 'Variable not found in codebook';
+      }
+
+      const { name: variableName, type: variableType } = variable;
+
+      if (!variableName || !variableType) {
+        return 'Variable not found in codebook';
+      }
+
+      const allValues = fieldApi.form.store.state.values;
+
+      return isNil(value) ||
+        compareVariables(value, allValues[variableId], variableType) < 0
+        ? `Your answer must be greater than or equal to the value of "${variableName}"`
+        : undefined;
+    },
+
+  lessThanOrEqualToVariable:
+    (variableId: string): TanStackValidator =>
+    ({ value, fieldApi, validationContext }) => {
+      const variable = getVariable(variableId, validationContext);
+
+      if (!variable) {
+        return 'Variable not found in codebook';
+      }
+
+      const { name: variableName, type: variableType } = variable;
+
+      if (!variableName || !variableType) {
+        return 'Variable not found in codebook';
+      }
+
+      const allValues = fieldApi.form.store.state.values;
+
+      return isNil(value) ||
+        compareVariables(value, allValues[variableId], variableType) > 0
+        ? `Your answer must be less than or equal to the value of "${variableName}"`
+        : undefined;
+    },
 };
 
 // TanStack-native validator function
diff --git a/lib/interviewer/behaviours/AssetMetaProvider.js b/lib/interviewer/behaviours/AssetMetaProvider.js
index 6f48c1931..a555f89c4 100644
--- a/lib/interviewer/behaviours/AssetMetaProvider.js
+++ b/lib/interviewer/behaviours/AssetMetaProvider.js
@@ -7,8 +7,6 @@ const AssetMetaProvider = ({ children, assetId }) => {
   const asset = codebookAssets[assetId];
 
   if (!codebookAssets) {
-    // eslint-disable-next-line no-console
-    console.log('error loading asset!', assetId);
     return null;
   }
 
diff --git a/lib/interviewer/components/NodeBin.tsx b/lib/interviewer/components/NodeBin.tsx
index a3d6e7ec7..50828ef7a 100644
--- a/lib/interviewer/components/NodeBin.tsx
+++ b/lib/interviewer/components/NodeBin.tsx
@@ -8,7 +8,7 @@ type NodeBinProps = {
 };
 
 /**
- * Renders a droppable NodeBin which accepts `EXISTING_NODE`.
+ * Renders a droppable NodeBin which accepts `EXISTING_NODE` and `FAMILY_TREE_NODE`.
  */
 const NodeBin = ({ accepts, dropHandler }: NodeBinProps) => {
   const { dropProps, isOver, willAccept } = useDropTarget({
diff --git a/lib/interviewer/components/NodeList.tsx b/lib/interviewer/components/NodeList.tsx
index cf912b417..5f1c6ff65 100644
--- a/lib/interviewer/components/NodeList.tsx
+++ b/lib/interviewer/components/NodeList.tsx
@@ -156,8 +156,6 @@ const NodeList = memo(
         {...dropProps}
         className={classNames}
         style={hoverStyles}
-        variants={nodeListVariants}
-        layout
         key="node-list"
       >
         <AnimatePresence mode="sync">
diff --git a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/CensusForm.tsx b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/CensusForm.tsx
index 5af50bb39..8c406c51a 100644
--- a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/CensusForm.tsx
+++ b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/CensusForm.tsx
@@ -193,6 +193,11 @@ export const CensusForm = ({
       onClose={() => setShow(false)}
       forceDisableFullscreen
       className="!w-auto"
+      footer={
+        <div className="flex w-full items-center justify-end pb-4">
+          <Button onClick={handleSubmit}>Generate Family Tree</Button>
+        </div>
+      }
     >
       <div className="flex flex-col">
         {shouldAskSex && variableDef?.options && (
@@ -230,9 +235,6 @@ export const CensusForm = ({
             />
           ))}
         </div>
-        <div className="mb-8 flex items-center justify-end">
-          <Button onClick={handleSubmit}>Generate Family Tree</Button>
-        </div>
       </div>
     </Overlay>
   );
diff --git a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeNode.tsx b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeNode.tsx
index b19a3ced6..77257a268 100644
--- a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeNode.tsx
+++ b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeNode.tsx
@@ -1,4 +1,5 @@
 import { type NcNode, type VariableValue } from '@codaco/shared-consts';
+
 import { useSelector } from 'react-redux';
 import { useDragSource } from '~/lib/dnd';
 import { useNodeLabel } from '~/lib/interviewer/containers/Interfaces/Anonymisation/useNodeLabel';
@@ -7,6 +8,67 @@ import { useClickUnlessDragged } from '~/lib/interviewer/containers/Interfaces/F
 import { getNodeColorSelector } from '~/lib/interviewer/selectors/session';
 import { Node } from '~/lib/ui/components';
 
+/**
+ * Icon for the ego (self) node in the family tree.
+ * Based on the add-a-person icon (lib/ui/assets/icons/add-a-person-single.svg).
+ *
+ * Variants:
+ * - "platinum": For colored backgrounds - uses platinum shades
+ * - "slate": For white/platinum backgrounds - uses slate blue shades
+ */
+function EgoIcon({
+  className,
+  variant = 'slate',
+}: {
+  className?: string;
+  variant?: 'platinum' | 'slate';
+}) {
+  const colors =
+    variant === 'platinum'
+      ? {
+          primary: 'var(--color-platinum)',
+          secondary: 'var(--color-platinum-dark)',
+        }
+      : {
+          primary: 'var(--color-slate-blue)',
+          secondary: 'var(--color-slate-blue-dark)',
+        };
+
+  return (
+    <svg
+      viewBox="0 0 139.8 167.5"
+      xmlns="http://www.w3.org/2000/svg"
+      className={className}
+    >
+      {/* Head - upper half */}
+      <path
+        fill={colors.primary}
+        d="M69.9,0C46.1,0,26.8,21.4,26.8,47.8c-0.1,11.6,3.8,22.9,11.1,32l64-64C94,6.1,82.6,0,69.9,0z"
+      />
+      {/* Head - lower half */}
+      <path
+        fill={colors.secondary}
+        d="M37.9,79.8c7.9,9.7,19.3,15.8,32,15.8c23.8,0,43.1-21.4,43.1-47.8c0.1-11.6-3.8-22.9-11.1-32L37.9,79.8z"
+      />
+      {/* Neck */}
+      <path
+        fill={colors.secondary}
+        d="M94,103.4c-4.1,0-13.6-7.5-10.9-11.3H56.6c2.7,3.8-6.8,11.3-10.9,11.3l24.2,10.8L94,103.4z"
+      />
+      {/* Body - left side */}
+      <path
+        fill={colors.primary}
+        d="M100.3,105.3l-58.6,58.6C26.5,160,12.3,152.8,0,143c9.2-20.1,27.7-35.5,50.2-41.3c5.9,3.8,12.7,5.8,19.7,5.9c7-0.1,13.8-2.1,19.7-5.9C93.3,102.7,96.8,103.9,100.3,105.3z"
+      />
+      {/* Body - right side */}
+      <path
+        fill={colors.secondary}
+        d="M139.8,143c-27.6,22-63.9,29.8-98.1,20.9l58.6-58.6C117.8,112.5,131.9,125.9,139.8,143z"
+      />
+    </svg>
+  );
+}
+
 export type FamilyTreeNodeType = {
   id: string;
   label: string;
@@ -103,20 +165,28 @@ export default function FamilyTreeNode(props: FamilyTreeNodeProps) {
         className="relative flex flex-col items-center gap-2 text-center"
         {...dragProps}
       >
-        <Node
-          className="shrink-0"
-          style={
-            {
-              width: FAMILY_TREE_CONFIG.nodeWidth,
-              height: FAMILY_TREE_CONFIG.nodeHeight,
-              ...nodeColor(),
-            } as React.CSSProperties
-          }
-          color="custom"
-          label={isEgo ? 'You' : ''}
-          shape={shape}
-          selected={selected}
-        />
+        <div className="relative shrink-0">
+          <Node
+            style={
+              {
+                width: FAMILY_TREE_CONFIG.nodeWidth,
+                height: FAMILY_TREE_CONFIG.nodeHeight,
+                ...nodeColor(),
+              } as React.CSSProperties
+            }
+            color="custom"
+            label=""
+            ariaLabel={isEgo ? 'You' : label || 'Node'}
+            shape={shape}
+            selected={selected}
+          />
+          {isEgo && (
+            <EgoIcon
+              className="pointer-events-none absolute top-1/2 left-1/2 h-8 w-8 -translate-x-1/2 -translate-y-1/2"
+              variant={networkNode ? 'platinum' : 'slate'}
+            />
+          )}
+        </div>
         {isEgo && (
           <svg
             viewBox="0 0 300 300"
diff --git a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeShells.tsx b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeShells.tsx
index 59c5e47fa..67af814c5 100644
--- a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeShells.tsx
+++ b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/components/FamilyTreeShells.tsx
@@ -30,8 +30,10 @@ import {
   getEgoSexVariable,
   getNodeIsEgoVariable,
   getNodeSexVariable,
+  getRelationshipToEgoVariable,
 } from '~/lib/interviewer/containers/Interfaces/FamilyTreeCensus/utils/nodeUtils';
 import { getNetworkEgo } from '~/lib/interviewer/selectors/session';
+import { FAMILY_TREE_CONFIG } from '~/lib/interviewer/containers/Interfaces/FamilyTreeCensus/config';
 
 const isFamilyTreeStageMetadata = (
   stageMetadata: unknown,
@@ -73,6 +75,16 @@ export const FamilyTreeShells = (props: {
     }
     return map;
   }, [networkNodes]);
+
+  // Calculate tree width for centering
+  const treeWidth = useMemo(() => {
+    if (nodesMap.size === 0) return FAMILY_TREE_CONFIG.nodeContainerWidth;
+    let maxX = 0;
+    for (const node of nodesMap.values()) {
+      if ((node.x ?? 0) > maxX) maxX = node.x ?? 0;
+    }
+    return maxX + FAMILY_TREE_CONFIG.nodeContainerWidth;
+  }, [nodesMap]);
   const [selectedNode, setSelectedNode] = useState<FamilyTreeNodeType | void>(
     undefined,
   );
@@ -82,6 +94,7 @@ export const FamilyTreeShells = (props: {
   const relationshipVariable = useSelector(getRelationshipTypeVariable);
   const nodeSexVariable = useSelector(getNodeSexVariable);
   const nodeIsEgoVariable = useSelector(getNodeIsEgoVariable);
+  const relationshipToEgoVariable = useSelector(getRelationshipToEgoVariable);
   const ego = useSelector(getNetworkEgo);
   const egoSexVariable = useSelector(getEgoSexVariable);
   const [hydratedOnce, setHydratedOnce] = useState(false);
@@ -156,14 +169,19 @@ export const FamilyTreeShells = (props: {
     for (const netNode of networkNodes) {
       const id = netNode._uid;
       const metadataNode = metadataByNetworkId.get(id);
-      const label = metadataNode?.label ?? '';
+      const label =
+        metadataNode?.label ??
+        (netNode.attributes?.[relationshipToEgoVariable] as string) ??
+        '';
       // Use sex from node attributes (primary source), fall back to metadata, then 'female'
       const attrSex = netNode.attributes?.[nodeSexVariable] as
         | 'male'
         | 'female'
         | undefined;
       const sex = attrSex ?? metadataNode?.sex ?? 'female';
-      const isEgo = metadataNode?.isEgo;
+      const isEgo =
+        metadataNode?.isEgo ??
+        (netNode.attributes?.[nodeIsEgoVariable] === true);
       const readOnly = metadataNode?.readOnly ?? false;
       const attributes = netNode.attributes ?? {};
       const diseaseVars =
@@ -287,52 +305,50 @@ export const FamilyTreeShells = (props: {
           }}
         />
       )}
-      <div className="census-node-canvas relative h-full w-full overflow-x-auto">
-        <div className="relative h-full w-full">
-          <EdgeRenderer />
-          {nodes.map((node) => (
-            <FamilyTreeNode
-              key={node.id}
-              placeholderId={node.id}
-              networkNode={
-                node.interviewNetworkId
-                  ? networkNodeMap.get(node.interviewNetworkId)
-                  : undefined
-              }
-              label={node.label}
-              isEgo={node.isEgo}
-              allowDrag={node.readOnly !== true && stepIndex < 2}
-              shape={node.sex === 'female' ? 'circle' : 'square'}
-              x={node.x ?? 0}
-              y={node.y ?? 0}
-              selected={
-                node.interviewNetworkId != null &&
-                typeof diseaseVariable === 'string' &&
-                node.diseases?.get(diseaseVariable)
-              }
-              handleClick={() => {
-                if (stepIndex === 0) {
-                  return;
-                } else if (stepIndex === 1) {
-                  setSelectedNode(node);
-                } else if (
-                  node.interviewNetworkId &&
-                  diseaseVariable &&
-                  !node.isEgo
-                ) {
-                  const diseaseValue = !node.diseases?.get(diseaseVariable);
-                  const diseaseData: Record<string, VariableValue> = {
-                    [diseaseVariable]: diseaseValue,
-                  };
-                  void updateNode({
-                    nodeId: node.interviewNetworkId,
-                    newAttributeData: diseaseData,
-                    diseaseValue: diseaseValue,
-                  });
+      <div className="census-node-canvas relative h-full w-full overflow-x-auto pt-6">
+        <div className="relative flex h-full min-w-fit justify-center">
+          <div className="relative" style={{ width: treeWidth }}>
+            <EdgeRenderer />
+            {nodes.map((node) => (
+              <FamilyTreeNode
+                key={node.id}
+                placeholderId={node.id}
+                networkNode={
+                  node.interviewNetworkId
+                    ? networkNodeMap.get(node.interviewNetworkId)
+                    : undefined
+                }
+                label={node.label}
+                isEgo={node.isEgo}
+                allowDrag={node.readOnly !== true && stepIndex < 2}
+                shape={node.sex === 'female' ? 'circle' : 'square'}
+                x={node.x ?? 0}
+                y={node.y ?? 0}
+                selected={
+                  node.interviewNetworkId != null &&
+                  typeof diseaseVariable === 'string' &&
+                  node.diseases?.get(diseaseVariable)
                 }
-              }}
-            />
-          ))}
+                handleClick={() => {
+                  if (stepIndex === 0) {
+                    return;
+                  } else if (stepIndex === 1) {
+                    setSelectedNode(node);
+                  } else if (node.interviewNetworkId && diseaseVariable) {
+                    const diseaseValue = !node.diseases?.get(diseaseVariable);
+                    const diseaseData: Record<string, VariableValue> = {
+                      [diseaseVariable]: diseaseValue,
+                    };
+                    void updateNode({
+                      nodeId: node.interviewNetworkId,
+                      newAttributeData: diseaseData,
+                      diseaseValue: diseaseValue,
+                    });
+                  }
+                }}
+              />
+            ))}
+          </div>
         </div>
       </div>
       <CensusForm
diff --git a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/config.ts b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/config.ts
index 45f9fa1e1..1f3b96663 100644
--- a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/config.ts
+++ b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/config.ts
@@ -3,7 +3,7 @@ export const FAMILY_TREE_CONFIG = {
   nodeContainerHeight: 160,
   nodeWidth: 80,
   nodeHeight: 80,
-  padding: 40,
+  padding: 60,
   get rowHeight() {
     return this.nodeContainerHeight + this.padding;
   },
diff --git a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/store.ts b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/store.ts
index 8f06fbd4b..414e0e121 100644
--- a/lib/interviewer/containers/Interfaces/FamilyTreeCensus/store.ts
+++ b/lib/interviewer/containers/Interfaces/FamilyTreeCensus/store.ts
@@ -680,7 +680,7 @@ export const createFamilyTreeStore = (
               const additionalPartnerId = addNode({
                 label: `father's partner ${index + 2}`,
                 sex: 'female',
-                readOnly: true,
+                readOnly: false,
               });
               addEdge({
                 source: fatherId,
@@ -696,7 +696,7 @@ export const createFamilyTreeStore = (
               const additionalPartnerId = addNode({
                 label: `mother's partner ${index + 2}`,
                 sex: 'male',
-                readOnly: true,
+                readOnly: false,
               });
               addEdge({
                 source: additionalPartnerId,
@@ -974,7 +974,7 @@ export const createFamilyTreeStore = (
             get().updateNode(newNodeId, {
               sex: partnerSex,
               label: `${anchorNode.label}'s partner`,
-              readOnly: true,
+              readOnly: false,
             });
 
             // Create partner edge
diff --git a/lib/interviewer/containers/Interfaces/FinishSession.js b/lib/interviewer/containers/Interfaces/FinishSession.js
index e5870c632..46f1f444a 100644
--- a/lib/interviewer/containers/Interfaces/FinishSession.js
+++ b/lib/interviewer/containers/Interfaces/FinishSession.js
@@ -1,19 +1,20 @@
-import { usePathname, useRouter } from 'next/navigation';
+import { useRouter } from 'next/navigation';
 import { useCallback, useEffect, useState } from 'react';
-import { useDispatch } from 'react-redux';
+import { useDispatch, useSelector } from 'react-redux';
 import { finishInterview } from '~/actions/interviews';
 import Loading from '~/lib/interviewer/components/Loading';
 import Button from '~/lib/ui/components/Button';
-import { openDialog as openDialogActopm } from '../../ducks/modules/dialogs';
+import { openDialog as openDialogAction } from '../../ducks/modules/dialogs';
+import { getInterviewId } from '../../selectors/session';
 
 const FinishSession = () => {
   const dispatch = useDispatch();
-  const pathname = usePathname();
   const router = useRouter();
 
   const [loading, setLoading] = useState(false);
 
-  const interviewId = pathname.split('/').pop(); // TODO: this should come from redux
+  const interviewId = useSelector(getInterviewId);
+  const isPreview = interviewId?.startsWith('preview-');
 
   const handleConfirmFinishInterview = async () => {
     if (!interviewId) {
@@ -28,7 +29,7 @@ const FinishSession = () => {
   };
 
   const openDialog = useCallback(
-    (dialog) => dispatch(openDialogActopm(dialog)),
+    (dialog) => dispatch(openDialogAction(dialog)),
     [dispatch],
   );
 
@@ -56,6 +57,29 @@ const FinishSession = () => {
     return <Loading message="Finishing interview..." />;
   }
 
+  if (isPreview) {
+    return (
+      <div className="interface finish-session-interface">
+        <div className="finish-session-interface__frame">
+          <h1 className="finish-session-interface__title type--title-1">
+            End of Preview
+          </h1>
+          <div className="finish-session-interface__section finish-session-interface__section--instructions">
+            <p>
+              You have reached the end of the interview preview. In a live
+              interview, participant data would be saved here and they would see
+              a thank-you screen.
+            </p>
+          </div>
+
+          <div className="finish-session-interface__section finish-session-interface__section--buttons">
+            <Button onClick={() => window.close()}>End Preview and Close</Button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
   return (
     <div className="interface finish-session-interface">
       <div className="finish-session-interface__frame">
diff --git a/lib/interviewer/containers/Interfaces/OrdinalBin.js b/lib/interviewer/containers/Interfaces/OrdinalBin.js
index 17b85b58e..c9eb14809 100644
--- a/lib/interviewer/containers/Interfaces/OrdinalBin.js
+++ b/lib/interviewer/containers/Interfaces/OrdinalBin.js
@@ -37,6 +37,7 @@ const OrdinalBin = (props) => {
           listId={`${stage.id}_${prompt?.id ?? 'unknown'}_NODE_BUCKET`}
           itemType="EXISTING_NODE"
           sortOrder={prompt?.bucketSortOrder}
+          nodeSize="sm"
         />
       </div>
       <div className="ordinal-bin-interface__bins">
diff --git a/lib/interviewer/containers/OrdinalBins.js b/lib/interviewer/containers/OrdinalBins.js
index 0a8b3f77d..92674ba87 100644
--- a/lib/interviewer/containers/OrdinalBins.js
+++ b/lib/interviewer/containers/OrdinalBins.js
@@ -119,8 +119,9 @@ const OrdinalBins = ({
               accepts={['NEW_NODE', 'EXISTING_NODE']}
               onDrop={(item) => onDrop({ meta: item })}
               hoverColor={highlightColor}
-              className="h-full content-center"
+              className="h-full content-start pt-4"
               showAcceptHighlight={false}
+              nodeSize="sm"
             />
           </div>
         </div>
diff --git a/lib/interviewer/containers/ProtocolScreen.tsx b/lib/interviewer/containers/ProtocolScreen.tsx
index 081a661d8..7941cbfd7 100644
--- a/lib/interviewer/containers/ProtocolScreen.tsx
+++ b/lib/interviewer/containers/ProtocolScreen.tsx
@@ -12,6 +12,7 @@ import usePrevious from '~/hooks/usePrevious';
 import Navigation from '../components/Navigation';
 import { updatePrompt, updateStage } from '../ducks/modules/session';
 import useReadyForNextStage from '../hooks/useReadyForNextStage';
+import { getStages } from '../ducks/modules/protocol';
 import {
   getCurrentStage,
   getNavigationInfo,
@@ -80,6 +81,19 @@ export default function ProtocolScreen() {
     useSelector(getNavigableStages);
   const stageCount = useSelector(getStageCount);
   const promptCount = useSelector(getPromptCount);
+  const stages = useSelector(getStages);
+
+  // Helper to get prompt count for a specific stage index
+  const getPromptCountForStage = useCallback(
+    (stageIndex: number) => {
+      const targetStage = stages[stageIndex];
+      if (targetStage && 'prompts' in targetStage && targetStage.prompts) {
+        return targetStage.prompts.length;
+      }
+      return 1; // Default to 1 if no prompts (same as getPromptCount selector)
+    },
+    [stages],
+  );
 
   // Refs
   const nextValidStageIndexRef = useRef(nextValidStageIndex);
@@ -153,11 +167,14 @@ export default function ProtocolScreen() {
       }
 
       // from this point on we are definitely navigating, so set up the animation
+      const nextPromptCount = getPromptCountForStage(
+        nextValidStageIndexRef.current,
+      );
       const fakeProgress = calculateProgress(
         nextValidStageIndexRef.current,
         stageCount,
         0,
-        promptCount,
+        nextPromptCount,
       );
       setProgress(fakeProgress);
       await animate(scope.current, { y: '-100vh' }, animationOptions);
@@ -176,7 +193,7 @@ export default function ProtocolScreen() {
     registerBeforeNext,
     scope,
     stageCount,
-    promptCount,
+    getPromptCountForStage,
     setQueryStep,
   ]);
 
@@ -196,11 +213,14 @@ export default function ProtocolScreen() {
         return;
       }
 
+      const prevPromptCount = getPromptCountForStage(
+        previousValidStageIndexRef.current,
+      );
       const fakeProgress = calculateProgress(
         previousValidStageIndexRef.current,
         stageCount,
         0,
-        promptCount,
+        prevPromptCount,
       );
       setProgress(fakeProgress);
 
@@ -220,7 +240,7 @@ export default function ProtocolScreen() {
     registerBeforeNext,
     scope,
     stageCount,
-    promptCount,
+    getPromptCountForStage,
   ]);
 
   const getNavigationHelpers = useCallback(
diff --git a/lib/interviewer/ducks/modules/__tests__/session.test.ts b/lib/interviewer/ducks/modules/__tests__/session.test.ts
index ecbec1e11..d367d8a11 100644
--- a/lib/interviewer/ducks/modules/__tests__/session.test.ts
+++ b/lib/interviewer/ducks/modules/__tests__/session.test.ts
@@ -1,8 +1,10 @@
 import { configureStore } from '@reduxjs/toolkit';
 import { describe, expect, it } from 'vitest';
 import {
+  addEdge,
   addNode,
   createInitialNetwork,
+  updateEgo,
 } from '~/lib/interviewer/ducks/modules/session';
 
 /**
@@ -238,15 +240,17 @@ describe('addNode', () => {
   });
 
   describe('default attributes', () => {
-    it('merges default attributes from codebook', async () => {
-      // Setup
+    it('includes all codebook variables even when only some are provided', async () => {
+      // Setup: codebook has 3 node variables
       const store = createTestStore({
         codebookVariables: {
           'var-uuid-1': { name: 'firstName' },
+          'var-uuid-2': { name: 'lastName' },
+          'var-uuid-3': { name: 'age' },
         },
       });
 
-      // Execute
+      // Execute: only provide value for one variable
       const result = await store.dispatch(
         addNode({
           type: 'test-node-type-uuid',
@@ -256,8 +260,206 @@ describe('addNode', () => {
         }),
       );
 
-      // Verify
+      // Verify: all variables should be in the payload, missing ones as null
       expect(result.type).toBe('NETWORK/ADD_NODE/fulfilled');
+      const payload = result.payload as { attributeData: Record<string, unknown> };
+      expect(payload.attributeData).toEqual({
+        'var-uuid-1': 'John',
+        'var-uuid-2': null,
+        'var-uuid-3': null,
+      });
+    });
+  });
+});
+
+/**
+ * Creates a test store with ego variables configured in the codebook.
+ */
+function createTestStoreWithEgo(options: {
+  egoVariables?: Record<string, { name: string }>;
+}) {
+  const { egoVariables = {} } = options;
+
+  const sessionState = createTestSessionState();
+  const protocolState = createTestProtocolState(egoVariables);
+  const uiState = { passphrase: null };
+
+  type SessionState = ReturnType<typeof createTestSessionState>;
+  type ProtocolState = ReturnType<typeof createTestProtocolState>;
+  type UIState = typeof uiState;
+
+  return configureStore({
+    reducer: {
+      session: (state: SessionState = sessionState): SessionState => state,
+      protocol: (state: ProtocolState = protocolState): ProtocolState => state,
+      ui: (state: UIState = uiState): UIState => state,
+    },
+    preloadedState: {
+      session: sessionState,
+      protocol: protocolState,
+      ui: uiState,
+    },
+  });
+
+  function createTestSessionState() {
+    return {
+      id: 'test-session',
+      startTime: new Date().toISOString(),
+      finishTime: null,
+      exportTime: null,
+      lastUpdated: new Date().toISOString(),
+      network: createInitialNetwork(),
+      currentStep: 0,
+      promptIndex: 0,
+    };
+  }
+
+  function createTestProtocolState(
+    egoVars: Record<string, { name: string }> = {},
+  ) {
+    return {
+      codebook: {
+        ego: {
+          variables: egoVars,
+        },
+        node: {},
+      },
+      stages: [{ id: 'stage-1' }],
+    };
+  }
+}
+
+/**
+ * Creates a test store with edge types configured in the codebook.
+ */
+function createTestStoreWithEdge(options: {
+  edgeVariables?: Record<string, { name: string }>;
+}) {
+  const edgeTypeId = 'test-edge-type-uuid';
+  const { edgeVariables = {} } = options;
+
+  const network = createInitialNetwork();
+  // Add two nodes so we can create edges between them
+  network.nodes = [
+    { _uid: 'node-1', type: 'person', attributes: {} },
+    { _uid: 'node-2', type: 'person', attributes: {} },
+  ];
+
+  const sessionState = createTestSessionState();
+  const protocolState = createTestProtocolState(edgeTypeId, edgeVariables);
+  const uiState = { passphrase: null };
+
+  type SessionState = ReturnType<typeof createTestSessionState>;
+  type ProtocolState = ReturnType<typeof createTestProtocolState>;
+  type UIState = typeof uiState;
+
+  return configureStore({
+    reducer: {
+      session: (state: SessionState = sessionState): SessionState => state,
+      protocol: (state: ProtocolState = protocolState): ProtocolState => state,
+      ui: (state: UIState = uiState): UIState => state,
+    },
+    preloadedState: {
+      session: sessionState,
+      protocol: protocolState,
+      ui: uiState,
+    },
+  });
+
+  function createTestSessionState() {
+    return {
+      id: 'test-session',
+      startTime: new Date().toISOString(),
+      finishTime: null,
+      exportTime: null,
+      lastUpdated: new Date().toISOString(),
+      network,
+      currentStep: 0,
+      promptIndex: 0,
+    };
+  }
+
+  function createTestProtocolState(
+    typeId: string,
+    variables: Record<string, { name: string }> = {},
+  ) {
+    return {
+      codebook: {
+        edge: {
+          [typeId]: {
+            name: 'friendship',
+            variables,
+          },
+        },
+        node: {},
+      },
+      stages: [{ id: 'stage-1' }],
+    };
+  }
+}
+
+describe('addEdge', () => {
+  describe('default attributes', () => {
+    it('includes all codebook variables even when only some are provided', async () => {
+      // Setup: codebook has 3 edge variables
+      const store = createTestStoreWithEdge({
+        edgeVariables: {
+          'edge-var-1': { name: 'strength' },
+          'edge-var-2': { name: 'duration' },
+          'edge-var-3': { name: 'frequency' },
+        },
+      });
+
+      // Execute: only provide value for one variable
+      const result = await store.dispatch(
+        addEdge({
+          type: 'test-edge-type-uuid',
+          from: 'node-1',
+          to: 'node-2',
+          attributeData: {
+            'edge-var-1': 5,
+          },
+        }),
+      );
+
+      // Verify: all variables should be in the payload, missing ones as null
+      expect(result.type).toBe('NETWORK/ADD_EDGE/fulfilled');
+      const payload = result.payload as { attributeData: Record<string, unknown> };
+      expect(payload.attributeData).toEqual({
+        'edge-var-1': 5,
+        'edge-var-2': null,
+        'edge-var-3': null,
+      });
+    });
+  });
+});
+
+describe('updateEgo', () => {
+  describe('default attributes', () => {
+    it('includes all codebook variables even when only some are provided', async () => {
+      // Setup: codebook has 3 ego variables
+      const store = createTestStoreWithEgo({
+        egoVariables: {
+          'ego-var-1': { name: 'age' },
+          'ego-var-2': { name: 'gender' },
+          'ego-var-3': { name: 'occupation' },
+        },
+      });
+
+      // Execute: only provide value for one variable
+      const result = await store.dispatch(
+        updateEgo({
+          'ego-var-1': 25,
+        }),
+      );
+
+      // Verify: all variables should be in the payload, missing ones as null
+      expect(result.type).toBe('NETWORK/UPDATE_EGO/fulfilled');
+      expect(result.payload).toEqual({
+        'ego-var-1': 25,
+        'ego-var-2': null,
+        'ego-var-3': null,
+      });
     });
   });
 });
diff --git a/lib/interviewer/ducks/modules/session.ts b/lib/interviewer/ducks/modules/session.ts
index c05baf230..363f631c3 100644
--- a/lib/interviewer/ducks/modules/session.ts
+++ b/lib/interviewer/ducks/modules/session.ts
@@ -384,7 +384,11 @@ export const updateEgo = createAsyncThunk(
       `Invalid ego attributes: ${invalidKeys.join(', ')} do not exist in protocol codebook`,
     );
 
-    return egoAttributes;
+    // Merge with default attributes to ensure all codebook variables exist
+    return {
+      ...getDefaultAttributesForEntityType(egoVariables),
+      ...egoAttributes,
+    };
   },
 );
 
diff --git a/lib/interviewer/selectors/session.ts b/lib/interviewer/selectors/session.ts
index ed17852be..d23c4a6dd 100644
--- a/lib/interviewer/selectors/session.ts
+++ b/lib/interviewer/selectors/session.ts
@@ -21,6 +21,8 @@ const getActiveSession = (state: RootState) => {
 
 export const getStageIndex = (state: RootState) => state.session.currentStep;
 
+export const getInterviewId = (state: RootState) => state.session.id;
+
 export const getStageMetadata = createSelector(
   getActiveSession,
   getStageIndex,
diff --git a/lib/interviewer/utils/__tests__/field-validations.test.ts b/lib/interviewer/utils/__tests__/field-validations.test.ts
index f762c3186..539b9cd11 100644
--- a/lib/interviewer/utils/__tests__/field-validations.test.ts
+++ b/lib/interviewer/utils/__tests__/field-validations.test.ts
@@ -777,4 +777,236 @@ describe('TanStack Validations', () => {
       ).toBe(errorMessage('String Variable'));
     });
   });
+
+  describe('greaterThanOrEqualToVariable()', () => {
+    const errorMessage = (value: string) =>
+      `Your answer must be greater than or equal to the value of "${value}"`;
+
+    it('fails for null or undefined', () => {
+      const subject1 = tanStackValidations.greaterThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(null, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+      expect(
+        subject1(
+          createMockValidatorParams(
+            undefined,
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+    });
+
+    it('passes if number is greater than', () => {
+      const subject1 = tanStackValidations.greaterThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(3, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if number is equal to', () => {
+      const subject1 = tanStackValidations.greaterThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(1, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if number is less than', () => {
+      const subject1 = tanStackValidations.greaterThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(0, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+    });
+
+    it('passes if date is greater than', () => {
+      const subject2 = tanStackValidations.greaterThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-11-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if date is equal to', () => {
+      const subject2 = tanStackValidations.greaterThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-10-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if date is less than', () => {
+      const subject2 = tanStackValidations.greaterThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-09-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(errorMessage('Date Variable'));
+    });
+
+    it('passes if string is greater than', () => {
+      const subject3 = tanStackValidations.greaterThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('zebra', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if string is equal to', () => {
+      const subject3 = tanStackValidations.greaterThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('word', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if string is less than', () => {
+      const subject3 = tanStackValidations.greaterThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('diff', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('String Variable'));
+    });
+  });
+
+  describe('lessThanOrEqualToVariable()', () => {
+    const errorMessage = (value: string) =>
+      `Your answer must be less than or equal to the value of "${value}"`;
+
+    it('fails for null or undefined', () => {
+      const subject1 = tanStackValidations.lessThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(null, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+      expect(
+        subject1(
+          createMockValidatorParams(
+            undefined,
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+    });
+
+    it('passes if number is less than', () => {
+      const subject1 = tanStackValidations.lessThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(0, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if number is equal to', () => {
+      const subject1 = tanStackValidations.lessThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(1, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if number is greater than', () => {
+      const subject1 = tanStackValidations.lessThanOrEqualToVariable('uid1');
+      expect(
+        subject1(
+          createMockValidatorParams(2, 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('Variable 1'));
+    });
+
+    it('passes if date is less than', () => {
+      const subject2 = tanStackValidations.lessThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-09-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if date is equal to', () => {
+      const subject2 = tanStackValidations.lessThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-10-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if date is greater than', () => {
+      const subject2 = tanStackValidations.lessThanOrEqualToVariable('uid2');
+      expect(
+        subject2(
+          createMockValidatorParams(
+            '2012-11-07',
+            'testField',
+            mockOtherFormValues,
+          ),
+        ),
+      ).toBe(errorMessage('Date Variable'));
+    });
+
+    it('passes if string is less than', () => {
+      const subject3 = tanStackValidations.lessThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('less', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('passes if string is equal to', () => {
+      const subject3 = tanStackValidations.lessThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('word', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(undefined);
+    });
+
+    it('fails if string is greater than', () => {
+      const subject3 = tanStackValidations.lessThanOrEqualToVariable('uid3');
+      expect(
+        subject3(
+          createMockValidatorParams('zebra', 'testField', mockOtherFormValues),
+        ),
+      ).toBe(errorMessage('String Variable'));
+    });
+  });
 });
diff --git a/lib/interviewer/utils/field-validation.ts b/lib/interviewer/utils/field-validation.ts
index 7280e62a3..aa36df874 100644
--- a/lib/interviewer/utils/field-validation.ts
+++ b/lib/interviewer/utils/field-validation.ts
@@ -302,6 +302,15 @@ const compareVariables = (
   }
 
   // check for numbers (could be number, ordinal, scalar, etc)
+  // Form inputs often return strings, so coerce to numbers when type indicates numeric
+  if (type === 'number' || type === 'scalar' || type === 'ordinal') {
+    const num1 = Number(value1);
+    const num2 = Number(value2);
+    if (!isNaN(num1) && !isNaN(num2)) {
+      return num1 - num2;
+    }
+  }
+
   if (isNumber(value1) && isNumber(value2)) {
     return value1 - value2;
   }
@@ -355,6 +364,46 @@ const lessThanVariable = (variableId: string, store: AppStore) => {
       : undefined;
 };
 
+const greaterThanOrEqualToVariable = (variableId: string, store: AppStore) => {
+  const variable = getVariable(variableId, store);
+
+  if (!variable) {
+    return () => 'Variable not found in codebook';
+  }
+
+  const { name: variableName, type: variableType } = variable;
+
+  if (!variableName || !variableType) {
+    return () => 'Variable not found in codebook';
+  }
+
+  return (value: FieldValue, allValues: Record<string, FieldValue>) =>
+    isNil(value) ||
+    compareVariables(value, allValues[variableId], variableType) < 0
+      ? `Your answer must be greater than or equal to the value of "${variableName}"`
+      : undefined;
+};
+
+const lessThanOrEqualToVariable = (variableId: string, store: AppStore) => {
+  const variable = getVariable(variableId, store);
+
+  if (!variable) {
+    return () => 'Variable not found in codebook';
+  }
+
+  const { name: variableName, type: variableType } = variable;
+
+  if (!variableName || !variableType) {
+    return () => 'Variable not found in codebook';
+  }
+
+  return (value: FieldValue, allValues: Record<string, FieldValue>) =>
+    isNil(value) ||
+    compareVariables(value, allValues[variableId], variableType) > 0
+      ? `Your answer must be less than or equal to the value of "${variableName}"`
+      : undefined;
+};
+
 // Type representing a variable with a validation object
 type VariableWithValidation = Extract<Variable, { validation?: unknown }>;
 export type VariableValidation = NonNullable<
@@ -375,6 +424,8 @@ const validations = {
   sameAs,
   greaterThanVariable,
   lessThanVariable,
+  greaterThanOrEqualToVariable,
+  lessThanOrEqualToVariable,
 };
 
 /**
diff --git a/lib/preview-protocol-pruning.ts b/lib/preview-protocol-pruning.ts
index 15c25a888..02f8644ba 100644
--- a/lib/preview-protocol-pruning.ts
+++ b/lib/preview-protocol-pruning.ts
@@ -26,9 +26,8 @@ export async function prunePreviewProtocols(): Promise<{
     // Find preview protocols to prune:
     // - Pending protocols older than 15 minutes (abandoned uploads)
     // - Completed protocols older than 24 hours
-    const oldProtocols = await prisma.protocol.findMany({
+    const oldProtocols = await prisma.previewProtocol.findMany({
       where: {
-        isPreview: true,
         OR: [
           { isPending: true, importedAt: { lt: pendingCutoff } },
           { isPending: false, importedAt: { lt: completedCutoff } },
@@ -47,16 +46,15 @@ export async function prunePreviewProtocols(): Promise<{
 
     const protocolIds = oldProtocols.map((p) => p.id);
 
-    // Select assets that are ONLY associated with the protocols to be deleted
+    // Select assets that are ONLY associated with the preview protocols to be deleted
+    // (not shared with any regular protocols or other preview protocols)
     const assetKeysToDelete = await prisma.asset.findMany({
       where: {
-        protocols: {
-          every: {
-            id: {
-              in: protocolIds,
-            },
-          },
-        },
+        AND: [
+          { previewProtocols: { some: { id: { in: protocolIds } } } },
+          { previewProtocols: { every: { id: { in: protocolIds } } } },
+          { protocols: { none: {} } },
+        ],
       },
       select: { key: true },
     });
@@ -83,8 +81,8 @@ export async function prunePreviewProtocols(): Promise<{
       });
     }
 
-    // Delete the protocols
-    const result = await prisma.protocol.deleteMany({
+    // Delete the preview protocols
+    const result = await prisma.previewProtocol.deleteMany({
       where: {
         id: {
           in: protocolIds,
diff --git a/lib/ui/components/Fields/TextArea.tsx b/lib/ui/components/Fields/TextArea.tsx
index 41780cfeb..569c27c4d 100644
--- a/lib/ui/components/Fields/TextArea.tsx
+++ b/lib/ui/components/Fields/TextArea.tsx
@@ -61,6 +61,7 @@ const TextArea = ({
       <div className={seamlessClasses}>
         <textarea
           id={id}
+          {...input}
           className="form-field form-field-text form-field-text--area form-field-text__input"
           placeholder={placeholder}
           autoFocus={autoFocus}
diff --git a/lib/ui/components/Node.tsx b/lib/ui/components/Node.tsx
index 745ee1d8d..149bef4b3 100644
--- a/lib/ui/components/Node.tsx
+++ b/lib/ui/components/Node.tsx
@@ -20,6 +20,8 @@ type UINodeProps = {
   color?: NodeColorSequence;
   shape?: 'circle' | 'square';
   label?: string;
+  /** Accessibility label for the node button. Falls back to `label` if not provided. */
+  ariaLabel?: string;
   selected?: boolean;
   linking?: boolean;
   loading?: boolean;
@@ -34,6 +36,7 @@ type UINodeProps = {
 const Node = forwardRef<HTMLButtonElement, UINodeProps>((props, ref) => {
   const {
     label = 'Node',
+    ariaLabel,
     color = 'node-color-seq-1',
     shape = 'circle',
     selected = false,
@@ -101,7 +104,7 @@ const Node = forwardRef<HTMLButtonElement, UINodeProps>((props, ref) => {
     label.length <= maxChars ? label : `${label.substring(0, maxChars - 3)}\u{AD}...`;
 
   return (
-    <button className={classes} ref={ref} aria-label={label} {...buttonProps}>
+    <button className={classes} ref={ref} {...buttonProps} aria-label={ariaLabel ?? label}>
       {loading && <Loader2 className="animate-spin" size={24} />}
       {!loading && <span className={labelClasses}>{labelWithEllipsis}</span>}
     </button>
diff --git a/lib/uploadthing/presigned.ts b/lib/uploadthing/presigned.ts
index e94f69cbf..237bd8295 100644
--- a/lib/uploadthing/presigned.ts
+++ b/lib/uploadthing/presigned.ts
@@ -2,6 +2,9 @@ import { createHmac } from 'crypto';
 import Sqids, { defaultOptions } from 'sqids';
 import { getAppSetting } from '~/queries/appSettings';
 
+const UPLOADTHING_SLUG = 'assetRouter';
+const REGISTER_TIMEOUT_MS = 30_000;
+
 export type ParsedToken = {
   apiKey: string;
   appId: string;
@@ -117,7 +120,7 @@ export function generatePresignedUploadUrl(
     'x-ut-identifier': appId,
     'x-ut-file-name': fileName,
     'x-ut-file-size': String(fileSize),
-    'x-ut-slug': 'assetRouter', // Use the existing file router slug
+    'x-ut-slug': UPLOADTHING_SLUG,
     'x-ut-content-disposition': 'inline',
     'x-ut-acl': 'public-read',
   });
@@ -140,3 +143,62 @@ export function generatePresignedUploadUrl(
     expiresAt,
   };
 }
+
+type RegisterUploadOptions = {
+  fileKeys: string[];
+  tokenData: ParsedToken;
+  callbackUrl: string;
+  callbackSlug?: string;
+};
+
+/**
+ * Register file uploads with UploadThing's route-metadata endpoint.
+ * This is required for CORS to work properly in Firefox/Safari.
+ */
+export async function registerUploadWithUploadThing(
+  options: RegisterUploadOptions,
+): Promise<void> {
+  const {
+    fileKeys,
+    tokenData,
+    callbackUrl,
+    callbackSlug = UPLOADTHING_SLUG,
+  } = options;
+  const { apiKey, regions, ingestHost } = tokenData;
+
+  const region = regions[0] ?? 'sea1';
+  const ingestUrl = `https://${region}.${ingestHost}`;
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REGISTER_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(`${ingestUrl}/route-metadata`, {
+      method: 'POST',
+      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'x-uploadthing-api-key': apiKey,
+        'x-uploadthing-be-adapter': 'server',
+        'x-uploadthing-fe-package': '@uploadthing/react',
+      },
+      body: JSON.stringify({
+        fileKeys,
+        metadata: {},
+        isDev: false, // Always false - isDev: true causes 60s delays
+        callbackUrl,
+        callbackSlug,
+        awaitServerData: false,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to register upload with UploadThing: ${response.status} ${errorText}`,
+      );
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
diff --git a/netlify.toml b/netlify.toml
index 6c11870e3..0f5ce60ac 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -1,2 +1,3 @@
 [build]
+  publish = ".next"
   command = "pnpm build:platform"
\ No newline at end of file
diff --git a/package.json b/package.json
index 3ba1f0287..fa0eba2ea 100644
--- a/package.json
+++ b/package.json
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@codaco/analytics": "8.0.0",
-    "@codaco/protocol-validation": "10.0.0",
+    "@codaco/protocol-validation": "10.1.0",
     "@codaco/shared-consts": "4.0.0",
     "@hookform/resolvers": "^5.2.2",
     "@lucia-auth/adapter-prisma": "^3.0.2",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index dc291dfe8..fcf8100f9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -12,8 +12,8 @@ importers:
         specifier: 8.0.0
         version: 8.0.0(next@14.2.35(@babel/core@7.29.0)(@playwright/test@1.58.2)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.97.3))
       '@codaco/protocol-validation':
-        specifier: 10.0.0
-        version: 10.0.0
+        specifier: 10.1.0
+        version: 10.1.0
       '@codaco/shared-consts':
         specifier: 4.0.0
         version: 4.0.0
@@ -582,8 +582,8 @@ packages:
     peerDependencies:
       next: 15.4.7
 
-  '@codaco/protocol-validation@10.0.0':
-    resolution: {integrity: sha512-mLkBgaMDvt28yWkL9wU5NnYpo/7vp/wZRw7tggVgTria6DZfJBPm2Gr+uKF7dfbZ6rIaJcM0dbiG4/SOPsp05w==}
+  '@codaco/protocol-validation@10.1.0':
+    resolution: {integrity: sha512-toUjrjYtyTJbsbS10PdNlmNkpRjeAdy3VIHpRsCtx9RWjGdNd1afRNimJd1ZgkePiFAfrPiy5ZSvTxogaTlgpA==}
     hasBin: true
 
   '@codaco/shared-consts@4.0.0':
@@ -6654,7 +6654,7 @@ snapshots:
       next: 14.2.35(@babel/core@7.29.0)(@playwright/test@1.58.2)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.97.3)
       zod: 4.3.6
 
-  '@codaco/protocol-validation@10.0.0':
+  '@codaco/protocol-validation@10.1.0':
     dependencies:
       '@codaco/shared-consts': 5.0.0
       '@faker-js/faker': 10.3.0
diff --git a/queries/activityFeed.ts b/queries/activityFeed.ts
index fd0441cff..bea8dfda9 100644
--- a/queries/activityFeed.ts
+++ b/queries/activityFeed.ts
@@ -30,8 +30,7 @@ export const getActivities = (rawSearchParams: unknown) =>
           }
         : {};
 
-      // Transaction is used to ensure both queries are executed in a single transaction
-      const [count, events] = await prisma.$transaction([
+      const [count, events] = await Promise.all([
         prisma.events.count({
           where: {
             ...queryFilterParams,
@@ -40,7 +39,7 @@ export const getActivities = (rawSearchParams: unknown) =>
         prisma.events.findMany({
           take: perPage,
           skip: offset,
-          orderBy: { [sortField]: sort },
+          orderBy: [{ [sortField]: sort }, { id: sort }],
           where: {
             ...queryFilterParams,
           },
diff --git a/queries/protocols.ts b/queries/protocols.ts
index bf9561436..c96033a61 100644
--- a/queries/protocols.ts
+++ b/queries/protocols.ts
@@ -6,9 +6,6 @@ import { prisma } from '~/lib/db';
 
 async function prisma_getProtocols() {
   return prisma.protocol.findMany({
-    where: {
-      isPreview: false,
-    },
     include: {
       interviews: true,
     },
@@ -38,12 +35,24 @@ export const getProtocolByHash = createCachedFunction(
   ['getProtocolsByHash', 'getProtocols'],
 );
 
+/**
+ * Find existing assets by assetId that are safe to reuse.
+ * Excludes assets that are ONLY associated with pending preview protocols,
+ * as these may have failed/stuck uploads with invalid URLs.
+ */
 export const getExistingAssets = async (assetIds: string[]) => {
   return prisma.asset.findMany({
     where: {
       assetId: {
         in: assetIds,
       },
+      // Asset is safe to reuse if it's associated with:
+      // - Any regular protocol, OR
+      // - A non-pending preview protocol (completed upload)
+      OR: [
+        { protocols: { some: {} } },
+        { previewProtocols: { some: { isPending: false } } },
+      ],
     },
     select: {
       assetId: true,
@@ -66,7 +75,7 @@ export const getNewAssetIds = async (assetIds: string[]) => {
  * Fetches the preview protocol with assets for preview mode.
  */
 export async function getProtocolForPreview(protocolId: string) {
-  return prisma.protocol.findUnique({
+  return prisma.previewProtocol.findUnique({
     where: { id: protocolId },
     include: { assets: true },
     omit: {
diff --git a/queries/summaryStatistics.ts b/queries/summaryStatistics.ts
index 8e786a9b7..2725473f3 100644
--- a/queries/summaryStatistics.ts
+++ b/queries/summaryStatistics.ts
@@ -3,18 +3,16 @@ import { createCachedFunction } from '~/lib/cache';
 import { prisma } from '~/lib/db';
 
 export const getSummaryStatistics = createCachedFunction(async () => {
-  const counts = await prisma.$transaction([
+  const [interviewCount, protocolCount, participantCount] = await Promise.all([
     prisma.interview.count(),
-    prisma.protocol.count({
-      where: { isPreview: false },
-    }),
+    prisma.protocol.count(),
     prisma.participant.count(),
   ]);
 
   return {
-    interviewCount: counts[0],
-    protocolCount: counts[1],
-    participantCount: counts[2],
+    interviewCount,
+    protocolCount,
+    participantCount,
   };
 }, [
   'summaryStatistics',
diff --git a/scripts/setup-database.ts b/scripts/setup-database.ts
index a7408c683..af3ac4cc2 100644
--- a/scripts/setup-database.ts
+++ b/scripts/setup-database.ts
@@ -31,26 +31,27 @@ function checkForNeededMigrations(): boolean {
     '--exit-code',
   ];
 
+  console.log(`Running: ${command} ${args.join(' ')}`);
   const result = spawnSync(command, args, { encoding: 'utf-8' });
 
   if (result.error) {
-    console.error('Failed to run command:', result.error);
+    console.error('Failed to spawn command:', result.error);
     throw result.error;
   }
 
-  // Handling the exit code
+  if (result.stdout) console.log('stdout:', result.stdout);
+  if (result.stderr) console.log('stderr:', result.stderr);
+  console.log('Exit code:', result.status);
+
   if (result.status === 0) {
     console.log('No differences between DB and schema detected.');
     return false;
   } else if (result.status === 2) {
     console.log('There are differences between the schemas.');
     return true;
-  } else if (result.status === 1) {
-    console.log('An error occurred.', result.stderr);
-    throw new Error(`Command failed with exit code ${result.status}`);
   }
 
-  return false;
+  throw new Error(`prisma migrate diff failed with exit code ${result.status}`);
 }
 
 /**
@@ -75,7 +76,12 @@ async function shouldApplyWorkaround(): Promise<boolean> {
 
 async function handleMigrations(): Promise<void> {
   try {
-    if (await shouldApplyWorkaround()) {
+    console.log('Starting migration process...');
+
+    const applyWorkaround = await shouldApplyWorkaround();
+    console.log('Should apply workaround:', applyWorkaround);
+
+    if (applyWorkaround) {
       console.log(
         'Workaround needed! Running: prisma migrate resolve --applied 0_init',
       );
@@ -84,12 +90,13 @@ async function handleMigrations(): Promise<void> {
       });
     }
 
-    // Determine if there are any migrations to run
     const needsMigrations = checkForNeededMigrations();
+    console.log('Needs migrations:', needsMigrations);
 
     if (needsMigrations) {
-      console.log('Migrations needed! Running: prisma migrate deploy');
+      console.log('Running: prisma migrate deploy');
       execSync('npx prisma migrate deploy', { stdio: 'inherit' });
+      console.log('Migrations applied successfully.');
     } else {
       console.log('No migrations needed.');
     }
diff --git a/tests/e2e/helpers/TestDataBuilder.ts b/tests/e2e/helpers/TestDataBuilder.ts
index 9479ed408..fef517325 100644
--- a/tests/e2e/helpers/TestDataBuilder.ts
+++ b/tests/e2e/helpers/TestDataBuilder.ts
@@ -140,8 +140,8 @@ export class TestDataBuilder {
     const protocolHash = hash(protocol);
 
     await this.pool.query(
-      `INSERT INTO "Protocol" (id, hash, name, "schemaVersion", description, "importedAt", "lastModified", stages, codebook, "isPreview", "isPending")
-       VALUES ($1, $2, $3, $4, $5, NOW(), NOW(), $6, $7, false, false)`,
+      `INSERT INTO "Protocol" (id, hash, name, "schemaVersion", description, "importedAt", "lastModified", stages, codebook)
+       VALUES ($1, $2, $3, $4, $5, NOW(), NOW(), $6, $7)`,
       [
         protocolId,
         protocolHash,
diff --git a/tests/e2e/specs/setup/initial-setup.spec.ts b/tests/e2e/specs/setup/initial-setup.spec.ts
deleted file mode 100644
index 35aa44215..000000000
--- a/tests/e2e/specs/setup/initial-setup.spec.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { expect, test } from '@playwright/test';
-
-const ADMIN_CREDENTIALS = {
-  username: 'testadmin',
-  password: 'TestAdmin123!',
-};
-
-// Longer timeout for heading assertions since step transitions may trigger
-// server component re-renders via nuqs URL state changes
-const STEP_TIMEOUT = 15_000;
-
-test.describe('Initial App Setup', () => {
-  test.describe.configure({ mode: 'serial' });
-
-  test('should redirect to setup page when not configured', async ({
-    page,
-  }) => {
-    await page.goto('/');
-
-    // Should redirect to setup
-    await expect(page).toHaveURL(/\/setup/, { timeout: STEP_TIMEOUT });
-    await expect(page.locator('h1, h2, h3')).toContainText(
-      /Welcome|Setup|Configure|Create.*Account/i,
-    );
-  });
-
-  test('should complete initial configuration', async ({ page }) => {
-    await page.goto('/setup');
-
-    // Step 1: Create admin account
-    await expect(
-      page.getByRole('heading', { name: /Create.*Account/i, level: 2 }),
-    ).toBeVisible({ timeout: STEP_TIMEOUT });
-
-    await page
-      .getByRole('textbox', { name: 'Username' })
-      .fill(ADMIN_CREDENTIALS.username);
-    await page
-      .getByRole('textbox', { name: 'Password' })
-      .fill(ADMIN_CREDENTIALS.password);
-    await page
-      .getByRole('textbox', { name: 'Confirm password' })
-      .fill(ADMIN_CREDENTIALS.password);
-
-    await page.getByRole('button', { name: 'Create account' }).click();
-
-    // Step 2: UploadThing configuration
-    await expect(
-      page.getByRole('heading', { name: /Connect UploadThing/i, level: 2 }),
-    ).toBeVisible({ timeout: STEP_TIMEOUT });
-
-    await page
-      .getByRole('textbox', { name: /UPLOADTHING_TOKEN/i })
-      .fill('UPLOADTHING_TOKEN=test_token_value_here_12345');
-    await page.getByRole('button', { name: /save.*continue/i }).click();
-
-    // Step 3: Upload Protocol (optional) - skip
-    await expect(
-      page.getByRole('heading', { name: 'Import Protocols', level: 2 }),
-    ).toBeVisible({ timeout: STEP_TIMEOUT });
-
-    // Wait for the step to fully render before clicking Continue
-    await page.waitForLoadState('networkidle');
-    await page.getByRole('button', { name: /^continue$/i }).click();
-
-    // Step 4: Configure Participation - skip
-    await expect(
-      page.getByRole('heading', {
-        name: 'Configure Participation',
-        level: 2,
-      }),
-    ).toBeVisible({ timeout: STEP_TIMEOUT });
-    await page.getByRole('button', { name: /^continue$/i }).click();
-
-    // Step 5: Documentation (final step)
-    await expect(
-      page.getByRole('heading', { name: 'Documentation', level: 2 }),
-    ).toBeVisible({ timeout: STEP_TIMEOUT });
-
-    // Complete onboarding
-    await page.getByRole('button', { name: 'Go to the dashboard!' }).click();
-
-    // Should now be on the dashboard
-    await expect(page).toHaveURL(/\/dashboard/, { timeout: STEP_TIMEOUT });
-    await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible({
-      timeout: STEP_TIMEOUT,
-    });
-  });
-});
diff --git a/utils/semVer.ts b/utils/semVer.ts
index b5d185632..5f9efb45d 100644
--- a/utils/semVer.ts
+++ b/utils/semVer.ts
@@ -60,14 +60,3 @@ export function getSemverUpdateType(
   // If we reach this point, we know the current version is higher than the new version
   return null;
 }
-
-/**
- * Compare two semantic versions.
- * Returns -1 if a < b, 0 if a == b, 1 if a > b
- */
-export function compareSemver(a: SemVer, b: SemVer): -1 | 0 | 1 {
-  if (a.major !== b.major) return a.major < b.major ? -1 : 1;
-  if (a.minor !== b.minor) return a.minor < b.minor ? -1 : 1;
-  if (a.patch !== b.patch) return a.patch < b.patch ? -1 : 1;
-  return 0;
-}