diff --git a/app/(app)/layout.tsx b/app/(app)/layout.tsx
new file mode 100644
index 0000000..3852ecb
--- /dev/null
+++ b/app/(app)/layout.tsx
@@ -0,0 +1,21 @@
+import Link from "next/link";
+
+export default function AppLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <div className="min-h-screen bg-slate-50">
+      <header className="border-b border-slate-200 bg-white">
+        <div className="mx-auto flex max-w-6xl items-center justify-between px-4 py-4 sm:px-6">
+          <Link href="/" className="text-lg font-semibold text-slate-900">
+            ScoutBase
+          </Link>
+          <span className="text-sm text-slate-500">Premises compliance</span>
+        </div>
+      </header>
+      <main className="mx-auto max-w-6xl px-4 py-8 sm:px-6">{children}</main>
+    </div>
+  );
+}
diff --git a/app/(app)/premises/[id]/audit/[auditId]/page.tsx b/app/(app)/premises/[id]/audit/[auditId]/page.tsx
new file mode 100644
index 0000000..8a4f14c
--- /dev/null
+++ b/app/(app)/premises/[id]/audit/[auditId]/page.tsx
@@ -0,0 +1,72 @@
+import Link from "next/link";
+import { notFound, redirect } from "next/navigation";
+import { AuditWizard } from "@/components/audit/AuditWizard";
+import { requireAuthContext } from "@/lib/auth";
+import { buildAuditOverview, getAuditForOrganisation } from "@/lib/audit";
+
+type PageProps = {
+  params: { id: string; auditId: string };
+  searchParams: { section?: string };
+};
+
+export default async function AuditWizardPage({
+  params,
+  searchParams,
+}: PageProps) {
+  let auth;
+  try {
+    auth = await requireAuthContext();
+  } catch {
+    redirect("/");
+  }
+
+  const audit = await getAuditForOrganisation(params.auditId, auth.organisationId);
+
+  if (!audit || audit.premises.id !== params.id) {
+    notFound();
+  }
+
+  const overview = buildAuditOverview(audit);
+  const initialSectionId =
+    searchParams.section &&
+    overview.sections.some((section) => section.id === searchParams.section)
+      ? searchParams.section
+      : overview.sections[0]?.id;
+
+  if (!initialSectionId) {
+    return (
+      <div className="rounded-xl border border-amber-200 bg-amber-50 p-6">
+        <h2 className="text-lg font-semibold text-amber-950">
+          This audit needs to be restarted
+        </h2>
+        <p className="mt-2 text-sm text-amber-900">
+          No audit sections apply to the current premises profile. Update your
+          profile or start a new audit.
+        </p>
+        <div className="mt-4 flex flex-wrap gap-3">
+          <Link
+            href={`/premises/${params.id}/profile`}
+            className="inline-flex rounded-lg bg-amber-800 px-4 py-2 text-sm font-medium text-white hover:bg-amber-900"
+          >
+            Review premises profile
+          </Link>
+          <Link
+            href={`/premises/${params.id}/audit`}
+            className="inline-flex rounded-lg border border-amber-300 px-4 py-2 text-sm font-medium text-amber-950 hover:bg-amber-100"
+          >
+            Back to audit
+          </Link>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <AuditWizard
+      premisesId={params.id}
+      auditId={params.auditId}
+      initialOverview={overview}
+      initialSectionId={initialSectionId}
+    />
+  );
+}
diff --git a/app/(app)/premises/[id]/audit/page.tsx b/app/(app)/premises/[id]/audit/page.tsx
new file mode 100644
index 0000000..7603842
--- /dev/null
+++ b/app/(app)/premises/[id]/audit/page.tsx
@@ -0,0 +1,50 @@
+import { notFound, redirect } from "next/navigation";
+import { AuditStatus } from "@prisma/client";
+import { AuditStartPanel } from "@/components/audit/AuditStartPanel";
+import { requireAuthContext } from "@/lib/auth";
+import { getPremisesForOrganisation } from "@/lib/premises";
+import { prisma } from "@/lib/prisma";
+
+type PageProps = {
+  params: { id: string };
+};
+
+export default async function PremisesAuditPage({ params }: PageProps) {
+  let auth;
+  try {
+    auth = await requireAuthContext();
+  } catch {
+    redirect("/");
+  }
+
+  const premises = await getPremisesForOrganisation(params.id, auth.organisationId);
+
+  if (!premises) {
+    notFound();
+  }
+
+  const draft = await prisma.audit.findFirst({
+    where: {
+      premisesId: premises.id,
+      status: AuditStatus.DRAFT,
+    },
+    select: { id: true },
+  });
+
+  return (
+    <div>
+      <p className="text-sm font-medium text-emerald-700">Annual safety audit</p>
+      <h1 className="mt-1 text-2xl font-semibold text-slate-900">{premises.name}</h1>
+      <p className="mt-1 text-slate-600">{premises.address}</p>
+
+      <div className="mt-8">
+        <AuditStartPanel
+          premisesId={premises.id}
+          premisesName={premises.name}
+          hasProfile={Boolean(premises.profile)}
+          draftAuditId={draft?.id ?? null}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/app/(app)/premises/[id]/profile/page.tsx b/app/(app)/premises/[id]/profile/page.tsx
new file mode 100644
index 0000000..a2c8319
--- /dev/null
+++ b/app/(app)/premises/[id]/profile/page.tsx
@@ -0,0 +1,87 @@
+import { notFound, redirect } from "next/navigation";
+import Link from "next/link";
+import { requireAuthContext } from "@/lib/auth";
+import { getPremisesForOrganisation } from "@/lib/premises";
+import { EMPTY_PROFILE_FORM } from "@/lib/profile-labels";
+import { ProfileWizard } from "@/components/profile/ProfileWizard";
+import type { ProfileFormData } from "@/lib/profile-labels";
+import type { BuildingAgeBand, FloodRiskZone, OwnershipType } from "@prisma/client";
+
+type PageProps = {
+  params: { id: string };
+};
+
+function toFormData(profile: {
+  ownershipType: OwnershipType;
+  buildingAgeBand: BuildingAgeBand;
+  hasGas: boolean;
+  floodRiskZone: FloodRiskZone | null;
+  hasCateringKitchen: boolean;
+  hasGrounds: boolean;
+  hasSleeping: boolean;
+  hasVehicles: boolean;
+  hasPlantMachinery: boolean;
+  hasThirdPartyUsers: boolean;
+}): ProfileFormData {
+  return {
+    ownershipType: profile.ownershipType,
+    buildingAgeBand: profile.buildingAgeBand,
+    hasGas: profile.hasGas,
+    floodRiskZone: profile.floodRiskZone,
+    hasCateringKitchen: profile.hasCateringKitchen,
+    hasGrounds: profile.hasGrounds,
+    hasSleeping: profile.hasSleeping,
+    hasVehicles: profile.hasVehicles,
+    hasPlantMachinery: profile.hasPlantMachinery,
+    hasThirdPartyUsers: profile.hasThirdPartyUsers,
+  };
+}
+
+export default async function PremisesProfilePage({ params }: PageProps) {
+  let auth;
+  try {
+    auth = await requireAuthContext();
+  } catch {
+    redirect("/");
+  }
+
+  const premises = await getPremisesForOrganisation(params.id, auth.organisationId);
+
+  if (!premises) {
+    notFound();
+  }
+
+  const initialProfile = premises.profile
+    ? toFormData(premises.profile)
+    : EMPTY_PROFILE_FORM;
+
+  const initialApplicableSections = premises.profile?.applicableSections ?? [];
+
+  return (
+    <div>
+      <p className="text-sm font-medium text-emerald-700">Premises profile</p>
+      <h1 className="mt-1 text-2xl font-semibold text-slate-900">{premises.name}</h1>
+      <p className="mt-1 text-slate-600">{premises.address}</p>
+      <p className="mt-4 text-sm text-slate-600">
+        Answer a few questions about your premises. We&apos;ll tailor the annual
+        safety audit to what applies to your building — usually about five
+        minutes.
+      </p>
+      {premises.profile ? (
+        <Link
+          href={`/premises/${premises.id}/audit`}
+          className="mt-4 inline-flex text-sm font-medium text-emerald-700 hover:text-emerald-800"
+        >
+          Go to annual audit →
+        </Link>
+      ) : null}
+      <div className="mt-8">
+        <ProfileWizard
+          premisesId={premises.id}
+          initialProfile={initialProfile}
+          initialApplicableSections={initialApplicableSections}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/app/api/actions/[actionId]/route.ts b/app/api/actions/[actionId]/route.ts
new file mode 100644
index 0000000..088b82d
--- /dev/null
+++ b/app/api/actions/[actionId]/route.ts
@@ -0,0 +1,108 @@
+import { NextResponse } from "next/server";
+import { Priority } from "@prisma/client";
+import { requireAuthContext } from "@/lib/auth";
+import { serializeLinkedAction, updateAuditAction, deleteAuditAction } from "@/lib/audit";
+import { prisma } from "@/lib/prisma";
+
+type RouteParams = { params: { actionId: string } };
+
+const VALID_PRIORITIES = new Set<string>(Object.values(Priority));
+
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+
+    const action = await prisma.action.findFirst({
+      where: {
+        id: params.actionId,
+        premises: { organisationId: auth.organisationId },
+      },
+    });
+
+    if (!action) {
+      return NextResponse.json(
+        { data: null, error: "Action not found" },
+        { status: 404 },
+      );
+    }
+
+    return NextResponse.json({
+      data: serializeLinkedAction(action),
+      error: null,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to load action";
+    const status = message === "Unauthorized" ? 401 : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
+
+export async function PATCH(request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const body = await request.json();
+
+    const title = body?.title as string | undefined;
+    const description = body?.description as string | undefined;
+    const priority = body?.priority as string | undefined;
+    const dueDate = body?.dueDate as string | null | undefined;
+
+    if (!title || !priority) {
+      return NextResponse.json(
+        { data: null, error: "title and priority are required" },
+        { status: 400 },
+      );
+    }
+
+    if (!VALID_PRIORITIES.has(priority)) {
+      return NextResponse.json(
+        { data: null, error: "Invalid priority value" },
+        { status: 400 },
+      );
+    }
+
+    const action = await updateAuditAction(params.actionId, auth.organisationId, {
+      title,
+      description,
+      priority: priority as Priority,
+      dueDate,
+    });
+
+    return NextResponse.json({
+      data: serializeLinkedAction(action),
+      error: null,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to update action";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Action not found"
+          ? 404
+          : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
+
+export async function DELETE(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    await deleteAuditAction(params.actionId, auth.organisationId);
+
+    return NextResponse.json({ data: { deleted: true }, error: null });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to delete action";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Action not found"
+          ? 404
+          : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
diff --git a/app/api/audit/[auditId]/actions/route.ts b/app/api/audit/[auditId]/actions/route.ts
new file mode 100644
index 0000000..e50805c
--- /dev/null
+++ b/app/api/audit/[auditId]/actions/route.ts
@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import { Priority } from "@prisma/client";
+import { requireAuthContext } from "@/lib/auth";
+import { createAuditAction, serializeLinkedAction } from "@/lib/audit";
+
+type RouteParams = { params: { auditId: string } };
+
+const VALID_PRIORITIES = new Set<string>(Object.values(Priority));
+
+export async function POST(request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const body = await request.json();
+
+    const title = body?.title as string | undefined;
+    const description = body?.description as string | undefined;
+    const priority = body?.priority as string | undefined;
+    const dueDate = body?.dueDate as string | null | undefined;
+    const itemId = body?.itemId as string | undefined;
+
+    if (!title || !priority || !itemId) {
+      return NextResponse.json(
+        {
+          data: null,
+          error: "title, priority, and itemId are required",
+        },
+        { status: 400 },
+      );
+    }
+
+    if (!VALID_PRIORITIES.has(priority)) {
+      return NextResponse.json(
+        { data: null, error: "Invalid priority value" },
+        { status: 400 },
+      );
+    }
+
+    const action = await createAuditAction(
+      params.auditId,
+      auth.organisationId,
+      auth.userId,
+      {
+        title,
+        description,
+        priority: priority as Priority,
+        dueDate,
+        itemId,
+      },
+    );
+
+    return NextResponse.json({
+      data: serializeLinkedAction(action),
+      error: null,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to create action";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Audit not found"
+          ? 404
+          : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
diff --git a/app/api/audit/[auditId]/responses/route.ts b/app/api/audit/[auditId]/responses/route.ts
new file mode 100644
index 0000000..107c518
--- /dev/null
+++ b/app/api/audit/[auditId]/responses/route.ts
@@ -0,0 +1,73 @@
+import { NextResponse } from "next/server";
+import { ResponseValue } from "@prisma/client";
+import { requireAuthContext } from "@/lib/auth";
+import { saveAuditResponse } from "@/lib/audit";
+
+type RouteParams = { params: { auditId: string } };
+
+const VALID_RESPONSES = new Set<string>([
+  ResponseValue.YES,
+  ResponseValue.NO,
+  ResponseValue.NA,
+]);
+
+export async function PUT(request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const body = await request.json();
+
+    const itemId = body?.itemId as string | undefined;
+    const sectionId = body?.sectionId as string | undefined;
+    const response = body?.response as string | undefined;
+    const notes = body?.notes as string | null | undefined;
+    const recordedDate = body?.recordedDate as string | null | undefined;
+    const needsAction = Boolean(body?.needsAction);
+
+    if (!itemId || !sectionId || !response) {
+      return NextResponse.json(
+        { data: null, error: "itemId, sectionId, and response are required" },
+        { status: 400 },
+      );
+    }
+
+    if (!VALID_RESPONSES.has(response)) {
+      return NextResponse.json(
+        { data: null, error: "Invalid response value" },
+        { status: 400 },
+      );
+    }
+
+    const result = await saveAuditResponse(
+      params.auditId,
+      auth.organisationId,
+      auth.userId,
+      itemId,
+      sectionId,
+      response as ResponseValue,
+      { notes, needsAction, recordedDate },
+    );
+
+    return NextResponse.json({
+      data: {
+        response: result.response,
+        sectionStatus: result.sectionStatus,
+      },
+      error: null,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to save response";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Audit not found" || message === "Question not found in this section"
+          ? 404
+          : message === "Cannot edit a completed audit" ||
+              message.includes("required") ||
+              message.includes("Needs action")
+            ? 400
+            : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
diff --git a/app/api/audit/[auditId]/route.ts b/app/api/audit/[auditId]/route.ts
new file mode 100644
index 0000000..322a1ce
--- /dev/null
+++ b/app/api/audit/[auditId]/route.ts
@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import { requireAuthContext } from "@/lib/auth";
+import { buildAuditOverview, getAuditForOrganisation } from "@/lib/audit";
+
+type RouteParams = { params: { auditId: string } };
+
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const audit = await getAuditForOrganisation(params.auditId, auth.organisationId);
+
+    if (!audit) {
+      return NextResponse.json(
+        { data: null, error: "Audit not found" },
+        { status: 404 },
+      );
+    }
+
+    return NextResponse.json({
+      data: buildAuditOverview(audit),
+      error: null,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        data: null,
+        error: error instanceof Error ? error.message : "Failed to load audit",
+      },
+      { status: error instanceof Error && error.message === "Unauthorized" ? 401 : 500 },
+    );
+  }
+}
diff --git a/app/api/audit/[auditId]/sections/[sectionId]/route.ts b/app/api/audit/[auditId]/sections/[sectionId]/route.ts
new file mode 100644
index 0000000..13225c5
--- /dev/null
+++ b/app/api/audit/[auditId]/sections/[sectionId]/route.ts
@@ -0,0 +1,39 @@
+import { NextResponse } from "next/server";
+import { requireAuthContext } from "@/lib/auth";
+import {
+  buildAuditSectionPayload,
+  getAuditForOrganisation,
+} from "@/lib/audit";
+
+type RouteParams = {
+  params: { auditId: string; sectionId: string };
+};
+
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const audit = await getAuditForOrganisation(params.auditId, auth.organisationId);
+
+    if (!audit) {
+      return NextResponse.json(
+        { data: null, error: "Audit not found" },
+        { status: 404 },
+      );
+    }
+
+    const payload = await buildAuditSectionPayload(audit, params.sectionId);
+
+    return NextResponse.json({ data: payload, error: null });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to load audit section";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Section not found"
+          ? 404
+          : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
diff --git a/app/api/premises/[id]/audit/route.ts b/app/api/premises/[id]/audit/route.ts
new file mode 100644
index 0000000..608ffff
--- /dev/null
+++ b/app/api/premises/[id]/audit/route.ts
@@ -0,0 +1,81 @@
+import { NextResponse } from "next/server";
+import { AuditStatus } from "@prisma/client";
+import { requireAuthContext } from "@/lib/auth";
+import { buildAuditOverview, startOrResumeAudit } from "@/lib/audit";
+import { getPremisesForOrganisation } from "@/lib/premises";
+import { prisma } from "@/lib/prisma";
+
+type RouteParams = { params: { id: string } };
+
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const premises = await getPremisesForOrganisation(
+      params.id,
+      auth.organisationId,
+    );
+
+    if (!premises) {
+      return NextResponse.json(
+        { data: null, error: "Premises not found" },
+        { status: 404 },
+      );
+    }
+
+    const draft = await prisma.audit.findFirst({
+      where: {
+        premisesId: params.id,
+        status: AuditStatus.DRAFT,
+      },
+      select: { id: true, startedAt: true },
+    });
+
+    return NextResponse.json({
+      data: {
+        hasProfile: Boolean(premises.profile),
+        draftAudit: draft,
+      },
+      error: null,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        data: null,
+        error: error instanceof Error ? error.message : "Failed to load audit",
+      },
+      { status: error instanceof Error && error.message === "Unauthorized" ? 401 : 500 },
+    );
+  }
+}
+
+export async function POST(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const { audit, created } = await startOrResumeAudit(
+      params.id,
+      auth.organisationId,
+      auth.userId,
+    );
+
+    return NextResponse.json({
+      data: {
+        auditId: audit.id,
+        created,
+        overview: buildAuditOverview(audit),
+      },
+      error: null,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to start audit";
+    const status =
+      message === "Unauthorized"
+        ? 401
+        : message === "Premises not found"
+          ? 404
+          : message.includes("profile") || message.includes("sections")
+            ? 400
+            : 500;
+
+    return NextResponse.json({ data: null, error: message }, { status });
+  }
+}
diff --git a/app/api/premises/[id]/profile/route.ts b/app/api/premises/[id]/profile/route.ts
new file mode 100644
index 0000000..b3ab61d
--- /dev/null
+++ b/app/api/premises/[id]/profile/route.ts
@@ -0,0 +1,203 @@
+import { NextResponse } from "next/server";
+import type { BuildingAgeBand, FloodRiskZone, OwnershipType } from "@prisma/client";
+import { requireAuthContext } from "@/lib/auth";
+import { getPremisesForOrganisation } from "@/lib/premises";
+import { prisma } from "@/lib/prisma";
+import { computeApplicableSections } from "@/lib/sections";
+import { EMPTY_PROFILE_FORM, type ProfileFormData } from "@/lib/profile-labels";
+
+type RouteParams = { params: { id: string } };
+
+function toFormData(profile: {
+  ownershipType: OwnershipType;
+  buildingAgeBand: BuildingAgeBand;
+  hasGas: boolean;
+  floodRiskZone: FloodRiskZone | null;
+  hasCateringKitchen: boolean;
+  hasGrounds: boolean;
+  hasSleeping: boolean;
+  hasVehicles: boolean;
+  hasPlantMachinery: boolean;
+  hasThirdPartyUsers: boolean;
+}): ProfileFormData {
+  return {
+    ownershipType: profile.ownershipType,
+    buildingAgeBand: profile.buildingAgeBand,
+    hasGas: profile.hasGas,
+    floodRiskZone: profile.floodRiskZone,
+    hasCateringKitchen: profile.hasCateringKitchen,
+    hasGrounds: profile.hasGrounds,
+    hasSleeping: profile.hasSleeping,
+    hasVehicles: profile.hasVehicles,
+    hasPlantMachinery: profile.hasPlantMachinery,
+    hasThirdPartyUsers: profile.hasThirdPartyUsers,
+  };
+}
+
+function parseProfileBody(body: unknown): ProfileFormData | null {
+  if (!body || typeof body !== "object") {
+    return null;
+  }
+
+  const data = body as Record<string, unknown>;
+
+  return {
+    ownershipType: (data.ownershipType as OwnershipType) ?? "",
+    buildingAgeBand: (data.buildingAgeBand as BuildingAgeBand) ?? "",
+    hasGas: Boolean(data.hasGas),
+    floodRiskZone:
+      data.floodRiskZone === null || data.floodRiskZone === ""
+        ? null
+        : (data.floodRiskZone as FloodRiskZone),
+    hasCateringKitchen: Boolean(data.hasCateringKitchen),
+    hasGrounds: Boolean(data.hasGrounds),
+    hasSleeping: Boolean(data.hasSleeping),
+    hasVehicles: Boolean(data.hasVehicles),
+    hasPlantMachinery: Boolean(data.hasPlantMachinery),
+    hasThirdPartyUsers: Boolean(data.hasThirdPartyUsers),
+  };
+}
+
+function validateProfileForm(form: ProfileFormData): string | null {
+  if (!form.ownershipType) {
+    return "Ownership type is required";
+  }
+  if (!form.buildingAgeBand) {
+    return "Building age is required";
+  }
+  return null;
+}
+
+export async function GET(_request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const premises = await getPremisesForOrganisation(params.id, auth.organisationId);
+
+    if (!premises) {
+      return NextResponse.json(
+        { data: null, error: "Premises not found" },
+        { status: 404 },
+      );
+    }
+
+    const form = premises.profile
+      ? toFormData(premises.profile)
+      : EMPTY_PROFILE_FORM;
+
+    const applicableSections = premises.profile
+      ? premises.profile.applicableSections
+      : [];
+
+    return NextResponse.json({
+      data: {
+        premises: {
+          id: premises.id,
+          name: premises.name,
+          address: premises.address,
+        },
+        profile: form,
+        applicableSections,
+      },
+      error: null,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        data: null,
+        error: error instanceof Error ? error.message : "Failed to load profile",
+      },
+      { status: error instanceof Error && error.message === "Unauthorized" ? 401 : 500 },
+    );
+  }
+}
+
+export async function PUT(request: Request, { params }: RouteParams) {
+  try {
+    const auth = await requireAuthContext();
+    const premises = await getPremisesForOrganisation(params.id, auth.organisationId);
+
+    if (!premises) {
+      return NextResponse.json(
+        { data: null, error: "Premises not found" },
+        { status: 404 },
+      );
+    }
+
+    const body = await request.json();
+    const form = parseProfileBody(body);
+
+    if (!form) {
+      return NextResponse.json(
+        { data: null, error: "Invalid request body" },
+        { status: 400 },
+      );
+    }
+
+    const validationError = validateProfileForm(form);
+    if (validationError) {
+      return NextResponse.json(
+        { data: null, error: validationError },
+        { status: 400 },
+      );
+    }
+
+    const applicableSections = computeApplicableSections({
+      buildingAgeBand: form.buildingAgeBand as BuildingAgeBand,
+      hasGas: form.hasGas,
+      hasSleeping: form.hasSleeping,
+      hasCateringKitchen: form.hasCateringKitchen,
+      hasGrounds: form.hasGrounds,
+      hasVehicles: form.hasVehicles,
+      hasPlantMachinery: form.hasPlantMachinery,
+      hasThirdPartyUsers: form.hasThirdPartyUsers,
+      floodRiskZone: form.floodRiskZone as FloodRiskZone | null,
+    });
+
+    const profile = await prisma.premisesProfile.upsert({
+      where: { premisesId: premises.id },
+      create: {
+        premisesId: premises.id,
+        ownershipType: form.ownershipType as OwnershipType,
+        buildingAgeBand: form.buildingAgeBand as BuildingAgeBand,
+        hasGas: form.hasGas,
+        floodRiskZone: form.floodRiskZone as FloodRiskZone | null,
+        hasCateringKitchen: form.hasCateringKitchen,
+        hasGrounds: form.hasGrounds,
+        hasSleeping: form.hasSleeping,
+        hasVehicles: form.hasVehicles,
+        hasPlantMachinery: form.hasPlantMachinery,
+        hasThirdPartyUsers: form.hasThirdPartyUsers,
+        applicableSections,
+      },
+      update: {
+        ownershipType: form.ownershipType as OwnershipType,
+        buildingAgeBand: form.buildingAgeBand as BuildingAgeBand,
+        hasGas: form.hasGas,
+        floodRiskZone: form.floodRiskZone as FloodRiskZone | null,
+        hasCateringKitchen: form.hasCateringKitchen,
+        hasGrounds: form.hasGrounds,
+        hasSleeping: form.hasSleeping,
+        hasVehicles: form.hasVehicles,
+        hasPlantMachinery: form.hasPlantMachinery,
+        hasThirdPartyUsers: form.hasThirdPartyUsers,
+        applicableSections,
+      },
+    });
+
+    return NextResponse.json({
+      data: {
+        profile: toFormData(profile),
+        applicableSections: profile.applicableSections,
+      },
+      error: null,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        data: null,
+        error: error instanceof Error ? error.message : "Failed to save profile",
+      },
+      { status: error instanceof Error && error.message === "Unauthorized" ? 401 : 500 },
+    );
+  }
+}
diff --git a/app/layout.tsx b/app/layout.tsx
index 7c92b9e..5842b22 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -2,8 +2,8 @@ import type { Metadata } from "next";
 import "./globals.css";
 
 export const metadata: Metadata = {
-  title: "Vigil",
-  description: "Compliance management for volunteer-run community buildings",
+  title: "ScoutBase",
+  description: "Premises compliance for volunteer-run community buildings",
 };
 
 export default function RootLayout({
diff --git a/app/page.tsx b/app/page.tsx
index 696ec88..d240981 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -1,10 +1,41 @@
-export default function Home() {
+import Link from "next/link";
+import { prisma } from "@/lib/prisma";
+
+export default async function Home() {
+  const premises = await prisma.premises.findFirst({
+    orderBy: { createdAt: "asc" },
+    select: { id: true, name: true, profile: { select: { id: true } } },
+  });
+
   return (
     <main className="flex min-h-screen flex-col items-center justify-center p-8">
-      <h1 className="text-3xl font-semibold">Vigil</h1>
-      <p className="mt-2 text-gray-600">
+      <h1 className="text-3xl font-semibold text-slate-900">ScoutBase</h1>
+      <p className="mt-2 max-w-md text-center text-slate-600">
         Compliance management for volunteer-run community buildings
       </p>
+      {premises ? (
+        <div className="mt-8 flex flex-col items-center gap-3">
+          <Link
+            href={`/premises/${premises.id}/profile`}
+            className="rounded-lg border border-slate-300 bg-white px-5 py-2.5 text-sm font-medium text-slate-700 hover:bg-slate-50"
+          >
+            {premises.profile ? "Edit" : "Set up"} {premises.name} profile
+          </Link>
+          {premises.profile ? (
+            <Link
+              href={`/premises/${premises.id}/audit`}
+              className="rounded-lg bg-emerald-700 px-5 py-2.5 text-sm font-medium text-white hover:bg-emerald-800"
+            >
+              Start annual audit
+            </Link>
+          ) : null}
+        </div>
+      ) : (
+        <p className="mt-8 text-sm text-slate-500">
+          Run <code className="rounded bg-slate-100 px-1">npm run db:seed</code>{" "}
+          to create a demo premises.
+        </p>
+      )}
     </main>
   );
 }
diff --git a/components/audit/ActionRaiseForm.tsx b/components/audit/ActionRaiseForm.tsx
new file mode 100644
index 0000000..71a40af
--- /dev/null
+++ b/components/audit/ActionRaiseForm.tsx
@@ -0,0 +1,174 @@
+"use client";
+
+import { useState } from "react";
+import type { Priority } from "@prisma/client";
+import type { AuditItemWithResponse, AuditLinkedAction } from "@/types/audit";
+import { Button } from "@/components/ui/form";
+
+const PRIORITY_OPTIONS: { value: Priority; label: string }[] = [
+  { value: "HIGH", label: "High" },
+  { value: "MEDIUM", label: "Medium" },
+  { value: "LOW", label: "Low" },
+];
+
+type ActionFormProps = {
+  item: AuditItemWithResponse;
+  existingAction?: AuditLinkedAction | null;
+  saving: boolean;
+  onSubmit: (input: {
+    title: string;
+    description: string;
+    priority: Priority;
+    dueDate: string;
+  }) => Promise<void>;
+  onCancel: () => void;
+};
+
+export function ActionForm({
+  item,
+  existingAction = null,
+  saving,
+  onSubmit,
+  onCancel,
+}: ActionFormProps) {
+  const isEditing = Boolean(existingAction);
+
+  const [title, setTitle] = useState(existingAction?.title ?? item.question);
+  const [description, setDescription] = useState(
+    existingAction?.description ?? "",
+  );
+  const [priority, setPriority] = useState<Priority>(
+    existingAction?.priority ?? "MEDIUM",
+  );
+  const [dueDate, setDueDate] = useState(existingAction?.dueDate ?? "");
+  const [error, setError] = useState<string | null>(null);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    setError(null);
+
+    if (!title.trim()) {
+      setError("Title is required");
+      return;
+    }
+
+    try {
+      await onSubmit({
+        title: title.trim(),
+        description: description.trim(),
+        priority,
+        dueDate,
+      });
+    } catch (submitError) {
+      setError(
+        submitError instanceof Error
+          ? submitError.message
+          : isEditing
+            ? "Failed to update action"
+            : "Failed to raise action",
+      );
+    }
+  }
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-slate-900/40 p-4">
+      <form
+        onSubmit={handleSubmit}
+        className="w-full max-w-lg rounded-xl border border-slate-200 bg-white p-6 shadow-xl"
+      >
+        <h2 className="text-lg font-semibold text-slate-900">
+          {isEditing ? "Edit action" : "Raise action"}
+        </h2>
+        <p className="mt-1 text-sm text-slate-600">
+          {isEditing
+            ? "Update the follow-up task linked to this audit question."
+            : "Create a follow-up task from this audit question."}
+        </p>
+
+        <div className="mt-4 space-y-4">
+          <div>
+            <label htmlFor="action-title" className="block text-sm font-medium text-slate-700">
+              Title
+            </label>
+            <input
+              id="action-title"
+              value={title}
+              onChange={(event) => setTitle(event.target.value)}
+              className="mt-1 w-full rounded-lg border border-slate-300 px-3 py-2 text-sm"
+            />
+          </div>
+
+          <div>
+            <label
+              htmlFor="action-description"
+              className="block text-sm font-medium text-slate-700"
+            >
+              Description
+            </label>
+            <textarea
+              id="action-description"
+              rows={3}
+              value={description}
+              onChange={(event) => setDescription(event.target.value)}
+              className="mt-1 w-full rounded-lg border border-slate-300 px-3 py-2 text-sm"
+              placeholder="What needs to be done?"
+            />
+          </div>
+
+          <div>
+            <span className="block text-sm font-medium text-slate-700">Priority</span>
+            <div className="mt-2 flex gap-2">
+              {PRIORITY_OPTIONS.map((option) => (
+                <button
+                  key={option.value}
+                  type="button"
+                  onClick={() => setPriority(option.value)}
+                  className={`rounded-lg border px-3 py-1.5 text-sm font-medium ${
+                    priority === option.value
+                      ? "border-emerald-600 bg-emerald-50 text-emerald-900"
+                      : "border-slate-200 bg-white text-slate-700"
+                  }`}
+                >
+                  {option.label}
+                </button>
+              ))}
+            </div>
+          </div>
+
+          <div>
+            <label htmlFor="action-due" className="block text-sm font-medium text-slate-700">
+              Target date (optional)
+            </label>
+            <input
+              id="action-due"
+              type="date"
+              value={dueDate}
+              onChange={(event) => setDueDate(event.target.value)}
+              className="mt-1 w-full max-w-xs rounded-lg border border-slate-300 px-3 py-2 text-sm"
+            />
+          </div>
+        </div>
+
+        {error ? (
+          <p className="mt-4 text-sm text-red-600">{error}</p>
+        ) : null}
+
+        <div className="mt-6 flex justify-end gap-3">
+          <Button variant="secondary" onClick={onCancel} disabled={saving}>
+            Cancel
+          </Button>
+          <Button type="submit" disabled={saving}>
+            {saving
+              ? "Saving…"
+              : isEditing
+                ? "Save changes"
+                : "Create action"}
+          </Button>
+        </div>
+      </form>
+    </div>
+  );
+}
+
+/** @deprecated Use ActionForm */
+export const ActionRaiseForm = ActionForm;
diff --git a/components/audit/AuditStartPanel.tsx b/components/audit/AuditStartPanel.tsx
new file mode 100644
index 0000000..f7c41ad
--- /dev/null
+++ b/components/audit/AuditStartPanel.tsx
@@ -0,0 +1,108 @@
+"use client";
+
+import { useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { Button } from "@/components/ui/form";
+
+type AuditStartPanelProps = {
+  premisesId: string;
+  premisesName: string;
+  hasProfile: boolean;
+  draftAuditId: string | null;
+};
+
+export function AuditStartPanel({
+  premisesId,
+  premisesName,
+  hasProfile,
+  draftAuditId,
+}: AuditStartPanelProps) {
+  const router = useRouter();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function startAudit() {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/premises/${premisesId}/audit`, {
+        method: "POST",
+      });
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(result.error ?? "Failed to start audit");
+      }
+
+      const firstSection = result.data.overview.sections[0]?.id;
+      const url = firstSection
+        ? `/premises/${premisesId}/audit/${result.data.auditId}?section=${firstSection}`
+        : `/premises/${premisesId}/audit/${result.data.auditId}`;
+
+      router.push(url);
+    } catch (startError) {
+      setError(
+        startError instanceof Error ? startError.message : "Failed to start audit",
+      );
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  if (!hasProfile) {
+    return (
+      <div className="rounded-xl border border-amber-200 bg-amber-50 p-6">
+        <h2 className="text-lg font-semibold text-amber-950">
+          Complete your premises profile first
+        </h2>
+        <p className="mt-2 text-sm text-amber-900">
+          We need to know about your building before we can tailor the audit
+          for {premisesName}.
+        </p>
+        <Link
+          href={`/premises/${premisesId}/profile`}
+          className="mt-4 inline-flex rounded-lg bg-amber-800 px-4 py-2 text-sm font-medium text-white hover:bg-amber-900"
+        >
+          Set up premises profile
+        </Link>
+      </div>
+    );
+  }
+
+  return (
+    <div className="rounded-xl border border-slate-200 bg-white p-6 shadow-sm">
+      <h2 className="text-lg font-semibold text-slate-900">Annual safety audit</h2>
+      <p className="mt-2 text-sm text-slate-600">
+        Work through the Scout Association premises audit section by section.
+        You can save your progress and come back later.
+      </p>
+
+      {draftAuditId ? (
+        <p className="mt-4 text-sm text-emerald-800">
+          You have a draft audit in progress.
+        </p>
+      ) : null}
+
+      {error ? (
+        <p className="mt-4 text-sm text-red-600">{error}</p>
+      ) : null}
+
+      <div className="mt-6 flex flex-wrap gap-3">
+        {draftAuditId ? (
+          <Link
+            href={`/premises/${premisesId}/audit/${draftAuditId}`}
+            className="inline-flex rounded-lg bg-emerald-700 px-4 py-2.5 text-sm font-medium text-white hover:bg-emerald-800"
+          >
+            Continue audit
+          </Link>
+        ) : (
+          <Button onClick={startAudit} disabled={loading}>
+            {loading ? "Starting…" : "Start audit"}
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/components/audit/AuditWizard.tsx b/components/audit/AuditWizard.tsx
new file mode 100644
index 0000000..9366dd8
--- /dev/null
+++ b/components/audit/AuditWizard.tsx
@@ -0,0 +1,471 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { useRouter } from "next/navigation";
+import type { Priority } from "@prisma/client";
+import type { QuestionSavePayload } from "@/components/audit/QuestionCard";
+import { ActionForm } from "@/components/audit/ActionRaiseForm";
+import { QuestionCard } from "@/components/audit/QuestionCard";
+import { QuestionGroupCard } from "@/components/audit/QuestionGroupCard";
+import { SectionNav } from "@/components/audit/SectionNav";
+import type {
+  AuditItemWithResponse,
+  AuditLinkedAction,
+  AuditOverview,
+  AuditSectionItem,
+  AuditSectionPayload,
+} from "@/types/audit";
+
+type AuditWizardProps = {
+  premisesId: string;
+  auditId: string;
+  initialOverview: AuditOverview;
+  initialSectionId: string;
+};
+
+type ActionDialogState = {
+  item: AuditItemWithResponse;
+  existingAction: AuditLinkedAction | null;
+};
+
+function updateSectionItemResponse(
+  items: AuditSectionItem[],
+  itemId: string,
+  response: NonNullable<AuditItemWithResponse["response"]>,
+): AuditSectionItem[] {
+  return items.map((entry) => {
+    if (entry.kind === "atomic" && entry.item.id === itemId) {
+      return {
+        ...entry,
+        item: {
+          ...entry.item,
+          response,
+        },
+      };
+    }
+
+    if (entry.kind === "group") {
+      const subQuestionIndex = entry.subQuestions.findIndex(
+        (subQuestion) => subQuestion.id === itemId,
+      );
+
+      if (subQuestionIndex === -1) {
+        return entry;
+      }
+
+      const subQuestions = [...entry.subQuestions];
+      subQuestions[subQuestionIndex] = {
+        ...subQuestions[subQuestionIndex],
+        response,
+      };
+
+      return {
+        ...entry,
+        subQuestions,
+      };
+    }
+
+    return entry;
+  });
+}
+
+function updateSectionItemActions(
+  items: AuditSectionItem[],
+  itemId: string,
+  actions: AuditLinkedAction[],
+): AuditSectionItem[] {
+  return items.map((entry) => {
+    if (entry.kind === "atomic" && entry.item.id === itemId) {
+      return {
+        ...entry,
+        item: {
+          ...entry.item,
+          actions,
+        },
+      };
+    }
+
+    if (entry.kind === "group") {
+      const subQuestionIndex = entry.subQuestions.findIndex(
+        (subQuestion) => subQuestion.id === itemId,
+      );
+
+      if (subQuestionIndex === -1) {
+        return entry;
+      }
+
+      const subQuestions = [...entry.subQuestions];
+      subQuestions[subQuestionIndex] = {
+        ...subQuestions[subQuestionIndex],
+        actions,
+      };
+
+      return {
+        ...entry,
+        subQuestions,
+      };
+    }
+
+    return entry;
+  });
+}
+
+export function AuditWizard({
+  premisesId,
+  auditId,
+  initialOverview,
+  initialSectionId,
+}: AuditWizardProps) {
+  const router = useRouter();
+  const [overview, setOverview] = useState(initialOverview);
+  const [activeSectionId, setActiveSectionId] = useState(initialSectionId);
+  const [sectionData, setSectionData] = useState<AuditSectionPayload | null>(null);
+  const [loadingSection, setLoadingSection] = useState(true);
+  const [savingItemId, setSavingItemId] = useState<string | null>(null);
+  const [actionDialog, setActionDialog] = useState<ActionDialogState | null>(null);
+  const [savingAction, setSavingAction] = useState(false);
+  const [deletingActionId, setDeletingActionId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const refreshOverview = useCallback(async () => {
+    const response = await fetch(`/api/audit/${auditId}`);
+    const result = await response.json();
+    if (response.ok && result.data) {
+      setOverview(result.data);
+    }
+  }, [auditId]);
+
+  const loadSection = useCallback(async (sectionId: string) => {
+    setLoadingSection(true);
+    setError(null);
+
+    try {
+      const response = await fetch(
+        `/api/audit/${auditId}/sections/${sectionId}`,
+      );
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(result.error ?? "Failed to load section");
+      }
+
+      setSectionData(result.data);
+    } catch (loadError) {
+      setError(
+        loadError instanceof Error ? loadError.message : "Failed to load section",
+      );
+    } finally {
+      setLoadingSection(false);
+    }
+  }, [auditId]);
+
+  useEffect(() => {
+    loadSection(activeSectionId);
+  }, [activeSectionId, loadSection]);
+
+  function handleSectionSelect(sectionId: string) {
+    setError(null);
+    setActiveSectionId(sectionId);
+    router.replace(
+      `/premises/${premisesId}/audit/${auditId}?section=${sectionId}`,
+      { scroll: false },
+    );
+  }
+
+  async function saveQuestion(
+    itemId: string,
+    sectionId: string,
+    payload: QuestionSavePayload,
+  ) {
+    setSavingItemId(itemId);
+    setError(null);
+
+    try {
+      const apiResponse = await fetch(`/api/audit/${auditId}/responses`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          itemId,
+          sectionId,
+          response: payload.response,
+          notes: payload.notes || null,
+          recordedDate: payload.recordedDate || null,
+          needsAction: false,
+        }),
+      });
+
+      const result = await apiResponse.json();
+
+      if (!apiResponse.ok) {
+        throw new Error(result.error ?? "Failed to save response");
+      }
+
+      const savedResponse = {
+        id: result.data.response.id,
+        response: result.data.response.response,
+        needsAction: result.data.response.needsAction,
+        notes: result.data.response.notes,
+        recordedDate: result.data.response.recordedDate ?? null,
+      };
+
+      setSectionData((current) => {
+        if (!current) return current;
+        return {
+          ...current,
+          section: {
+            ...current.section,
+            status: result.data.sectionStatus,
+          },
+          items: updateSectionItemResponse(current.items, itemId, savedResponse),
+        };
+      });
+
+      void refreshOverview();
+    } catch (saveError) {
+      throw saveError;
+    } finally {
+      setSavingItemId(null);
+    }
+  }
+
+  async function handleActionSubmit(input: {
+    title: string;
+    description: string;
+    priority: Priority;
+    dueDate: string;
+  }) {
+    if (!actionDialog) return;
+
+    setSavingAction(true);
+    setError(null);
+
+    try {
+      const isEditing = Boolean(actionDialog.existingAction);
+      const response = await fetch(
+        isEditing
+          ? `/api/actions/${actionDialog.existingAction!.id}`
+          : `/api/audit/${auditId}/actions`,
+        {
+          method: isEditing ? "PATCH" : "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(
+            isEditing
+              ? {
+                  title: input.title,
+                  description: input.description || null,
+                  priority: input.priority,
+                  dueDate: input.dueDate || null,
+                }
+              : {
+                  title: input.title,
+                  description: input.description || null,
+                  priority: input.priority,
+                  dueDate: input.dueDate || null,
+                  itemId: actionDialog.item.id,
+                },
+          ),
+        },
+      );
+
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(result.error ?? "Failed to save action");
+      }
+
+      const linkedAction = result.data as AuditLinkedAction;
+      const itemId = actionDialog.item.id;
+      const currentActions = actionDialog.item.actions;
+
+      const nextActions = isEditing
+        ? currentActions.map((action) =>
+            action.id === linkedAction.id ? linkedAction : action,
+          )
+        : [...currentActions, linkedAction];
+
+      setSectionData((current) => {
+        if (!current) return current;
+        return {
+          ...current,
+          items: updateSectionItemActions(current.items, itemId, nextActions),
+        };
+      });
+
+      setActionDialog(null);
+      await refreshOverview();
+    } finally {
+      setSavingAction(false);
+    }
+  }
+
+  async function handleDeleteAction(
+    item: AuditItemWithResponse,
+    action: AuditLinkedAction,
+  ) {
+    if (!window.confirm(`Delete action "${action.title}"?`)) {
+      return;
+    }
+
+    setDeletingActionId(action.id);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/actions/${action.id}`, {
+        method: "DELETE",
+      });
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(result.error ?? "Failed to delete action");
+      }
+
+      const nextActions = item.actions.filter((entry) => entry.id !== action.id);
+
+      setSectionData((current) => {
+        if (!current) return current;
+        return {
+          ...current,
+          items: updateSectionItemActions(current.items, item.id, nextActions),
+        };
+      });
+
+      await refreshOverview();
+    } catch (deleteError) {
+      setError(
+        deleteError instanceof Error
+          ? deleteError.message
+          : "Failed to delete action",
+      );
+    } finally {
+      setDeletingActionId(null);
+    }
+  }
+
+  const activeSection = overview.sections.find(
+    (section) => section.id === activeSectionId,
+  );
+
+  const actionHandlers = {
+    onAddAction: (item: AuditItemWithResponse) =>
+      setActionDialog({ item, existingAction: null }),
+    onEditAction: (item: AuditItemWithResponse, action: AuditLinkedAction) =>
+      setActionDialog({ item, existingAction: action }),
+    onDeleteAction: handleDeleteAction,
+  };
+
+  return (
+    <div className="space-y-6">
+      <div className="rounded-xl border border-slate-200 bg-white p-5 shadow-sm">
+        <div className="flex flex-wrap items-center justify-between gap-3">
+          <div>
+            <p className="text-sm text-slate-500">
+              Template {overview.templateVersion} · Draft audit
+            </p>
+            <h1 className="text-xl font-semibold text-slate-900">
+              {overview.premises.name}
+            </h1>
+          </div>
+          <p className="text-sm text-slate-600">
+            {overview.progress.completedSections} of{" "}
+            {overview.progress.totalSections} sections complete
+          </p>
+        </div>
+      </div>
+
+      <div className="grid gap-6 sm:grid-cols-[260px_minmax(0,1fr)]">
+        <aside className="sticky top-4 self-start max-h-[calc(100vh-6rem)] overflow-y-auto rounded-xl border border-slate-200 bg-white p-4 shadow-sm">
+          <h2 className="mb-3 text-sm font-semibold text-slate-900">Sections</h2>
+          <SectionNav
+            sections={overview.sections}
+            activeSectionId={activeSectionId}
+            onSelect={handleSectionSelect}
+          />
+        </aside>
+
+        <section className="min-w-0 space-y-4">
+          {activeSection ? (
+            <header>
+              <p className="text-sm text-slate-500">
+                Section {activeSection.number}
+              </p>
+              <h2 className="text-lg font-semibold text-slate-900">
+                {activeSection.title}
+              </h2>
+              <p className="mt-1 text-sm text-slate-600">
+                Answer each question below. Your responses are saved automatically.
+              </p>
+            </header>
+          ) : null}
+
+          {error ? (
+            <div className="rounded-lg border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-700">
+              {error}
+            </div>
+          ) : null}
+
+          {loadingSection ? (
+            <p className="text-sm text-slate-500">Loading questions…</p>
+          ) : sectionData ? (
+            <div className="space-y-4">
+              {sectionData.items.map((entry) =>
+                entry.kind === "group" ? (
+                  <QuestionGroupCard
+                    key={entry.id}
+                    group={entry}
+                    sectionId={sectionData.section.id}
+                    savingItemId={savingItemId}
+                    deletingActionId={deletingActionId}
+                    onSave={async (itemId, sectionId, payload) => {
+                      try {
+                        await saveQuestion(itemId, sectionId, payload);
+                      } catch (saveError) {
+                        setError(
+                          saveError instanceof Error
+                            ? saveError.message
+                            : "Failed to save response",
+                        );
+                        throw saveError;
+                      }
+                    }}
+                    {...actionHandlers}
+                  />
+                ) : (
+                  <QuestionCard
+                    key={entry.item.id}
+                    item={entry.item}
+                    sectionId={sectionData.section.id}
+                    saving={savingItemId === entry.item.id}
+                    deletingActionId={deletingActionId}
+                    onSave={async (itemId, sectionId, payload) => {
+                      try {
+                        await saveQuestion(itemId, sectionId, payload);
+                      } catch (saveError) {
+                        setError(
+                          saveError instanceof Error
+                            ? saveError.message
+                            : "Failed to save response",
+                        );
+                        throw saveError;
+                      }
+                    }}
+                    {...actionHandlers}
+                  />
+                ),
+              )}
+            </div>
+          ) : null}
+        </section>
+      </div>
+
+      {actionDialog ? (
+        <ActionForm
+          item={actionDialog.item}
+          existingAction={actionDialog.existingAction}
+          saving={savingAction}
+          onSubmit={handleActionSubmit}
+          onCancel={() => setActionDialog(null)}
+        />
+      ) : null}
+    </div>
+  );
+}
diff --git a/components/audit/ItemActionPanel.tsx b/components/audit/ItemActionPanel.tsx
new file mode 100644
index 0000000..b0275c7
--- /dev/null
+++ b/components/audit/ItemActionPanel.tsx
@@ -0,0 +1,111 @@
+"use client";
+
+import type { AuditItemWithResponse, AuditLinkedAction } from "@/types/audit";
+
+const PRIORITY_LABELS = {
+  HIGH: "High",
+  MEDIUM: "Medium",
+  LOW: "Low",
+} as const;
+
+const STATUS_LABELS = {
+  OPEN: "Open",
+  IN_PROGRESS: "In progress",
+  RESOLVED: "Resolved",
+} as const;
+
+type ItemActionPanelProps = {
+  item: AuditItemWithResponse;
+  onAddAction: (item: AuditItemWithResponse) => void;
+  onEditAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+  onDeleteAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+  deletingActionId?: string | null;
+};
+
+function formatDueDate(dueDate: string | null): string | null {
+  if (!dueDate) return null;
+  return new Date(`${dueDate}T00:00:00`).toLocaleDateString("en-GB", {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+  });
+}
+
+export function ItemActionPanel({
+  item,
+  onAddAction,
+  onEditAction,
+  onDeleteAction,
+  deletingActionId = null,
+}: ItemActionPanelProps) {
+  const actions = item.actions;
+
+  return (
+    <div className="mt-4 rounded-lg border border-slate-200 bg-slate-50/80 p-4">
+      <div className="flex items-center justify-between gap-3">
+        <h4 className="text-sm font-medium text-slate-900">Actions</h4>
+        <button
+          type="button"
+          onClick={() => onAddAction(item)}
+          className="text-sm font-medium text-emerald-700 hover:text-emerald-800"
+        >
+          Add action
+        </button>
+      </div>
+
+      {actions.length === 0 ? (
+        <p className="mt-2 text-sm text-slate-500">
+          No follow-up actions for this question yet.
+        </p>
+      ) : (
+        <ul className="mt-3 space-y-2">
+          {actions.map((action) => {
+            const dueLabel = formatDueDate(action.dueDate);
+
+            return (
+              <li
+                key={action.id}
+                className="rounded-lg border border-slate-200 bg-white px-3 py-3"
+              >
+                <div className="flex flex-wrap items-start justify-between gap-3">
+                  <div className="min-w-0">
+                    <p className="text-sm font-medium text-slate-900">
+                      {action.title}
+                    </p>
+                    <p className="mt-1 text-xs text-slate-500">
+                      {PRIORITY_LABELS[action.priority]} ·{" "}
+                      {STATUS_LABELS[action.status]}
+                      {dueLabel ? ` · Due ${dueLabel}` : ""}
+                    </p>
+                    {action.description ? (
+                      <p className="mt-2 text-sm text-slate-600">
+                        {action.description}
+                      </p>
+                    ) : null}
+                  </div>
+                  <div className="flex shrink-0 gap-3">
+                    <button
+                      type="button"
+                      onClick={() => onEditAction(item, action)}
+                      className="text-sm font-medium text-emerald-700 hover:text-emerald-800"
+                    >
+                      Edit
+                    </button>
+                    <button
+                      type="button"
+                      onClick={() => onDeleteAction(item, action)}
+                      disabled={deletingActionId === action.id}
+                      className="text-sm font-medium text-red-600 hover:text-red-700 disabled:opacity-50"
+                    >
+                      {deletingActionId === action.id ? "Deleting…" : "Delete"}
+                    </button>
+                  </div>
+                </div>
+              </li>
+            );
+          })}
+        </ul>
+      )}
+    </div>
+  );
+}
diff --git a/components/audit/QuestionCard.tsx b/components/audit/QuestionCard.tsx
new file mode 100644
index 0000000..f6cc82b
--- /dev/null
+++ b/components/audit/QuestionCard.tsx
@@ -0,0 +1,427 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import type { AuditItemWithResponse, AuditLinkedAction } from "@/types/audit";
+import {
+  isPrimaryResponse,
+  ResponseInput,
+  type PrimaryResponseValue,
+} from "@/components/audit/ResponseInput";
+import { ItemActionPanel } from "@/components/audit/ItemActionPanel";
+import { DateField } from "@/components/ui/form";
+import { formatInputDate, isInputDate } from "@/lib/dates";
+import {
+  isDateUploadItem,
+  isOpenTextItem,
+} from "@/types/audit-template";
+
+export type QuestionSavePayload = {
+  response: PrimaryResponseValue | "NA";
+  notes: string;
+  recordedDate?: string | null;
+};
+
+type QuestionCardProps = {
+  item: AuditItemWithResponse;
+  sectionId: string;
+  saving: boolean;
+  variant?: "default" | "sub";
+  deletingActionId?: string | null;
+  onSave: (
+    itemId: string,
+    sectionId: string,
+    payload: QuestionSavePayload,
+  ) => Promise<void>;
+  onAddAction: (item: AuditItemWithResponse) => void;
+  onEditAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+  onDeleteAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+};
+
+function normalizeStoredResponse(item: AuditItemWithResponse) {
+  const stored = item.response;
+
+  if (isDateUploadItem(item)) {
+    return {
+      response: null as PrimaryResponseValue | null,
+      notes: "",
+      recordedDate: formatInputDate(stored?.recordedDate),
+    };
+  }
+
+  if (isOpenTextItem(item)) {
+    return {
+      response: null as PrimaryResponseValue | null,
+      notes: stored?.notes ?? "",
+      recordedDate: "",
+    };
+  }
+
+  if (!stored) {
+    return {
+      response: null as PrimaryResponseValue | null,
+      notes: "",
+      recordedDate: "",
+    };
+  }
+
+  if (stored.response === "ACTION_NEEDED") {
+    return {
+      response: "NO" as PrimaryResponseValue,
+      notes: stored.notes ?? "",
+      recordedDate: "",
+    };
+  }
+
+  return {
+    response: isPrimaryResponse(stored.response) ? stored.response : null,
+    notes: stored.notes ?? "",
+    recordedDate: "",
+  };
+}
+
+function canSave(item: AuditItemWithResponse, payload: QuestionSavePayload): string | null {
+  if (isDateUploadItem(item)) {
+    if (!payload.recordedDate?.trim() || !isInputDate(payload.recordedDate)) {
+      return "Please select a date before saving.";
+    }
+    return null;
+  }
+
+  if (isOpenTextItem(item)) {
+    if (!payload.notes.trim()) {
+      return "Please provide an answer before saving.";
+    }
+    return null;
+  }
+
+  if (payload.response === "YES" && !payload.notes.trim()) {
+    return "Provide details is required when you answer Yes.";
+  }
+
+  return null;
+}
+
+function storedResponseKey(item: AuditItemWithResponse): string {
+  if (!item.response) {
+    return "none";
+  }
+
+  return [
+    item.response.id,
+    item.response.response,
+    item.response.notes ?? "",
+    item.response.recordedDate ?? "",
+  ].join(":");
+}
+
+export function QuestionCard({
+  item,
+  sectionId,
+  saving,
+  variant = "default",
+  deletingActionId = null,
+  onSave,
+  onAddAction,
+  onEditAction,
+  onDeleteAction,
+}: QuestionCardProps) {
+  const initial = normalizeStoredResponse(item);
+  const [response, setResponse] = useState<PrimaryResponseValue | null>(
+    initial.response,
+  );
+  const [notes, setNotes] = useState(initial.notes);
+  const [recordedDate, setRecordedDate] = useState(initial.recordedDate);
+  const [validationError, setValidationError] = useState<string | null>(null);
+
+  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const stateRef = useRef({
+    response: initial.response,
+    notes: initial.notes,
+    recordedDate: initial.recordedDate,
+  });
+  const onSaveRef = useRef(onSave);
+  const itemRef = useRef(item);
+  const inputFocusedRef = useRef(false);
+
+  const isOpenTextQuestion = isOpenTextItem(item);
+  const isDateQuestion = isDateUploadItem(item);
+
+  stateRef.current = { response, notes, recordedDate };
+  onSaveRef.current = onSave;
+  itemRef.current = item;
+
+  const responseKey = storedResponseKey(item);
+
+  useEffect(() => {
+    const next = normalizeStoredResponse(item);
+    setResponse(next.response);
+    if (!inputFocusedRef.current) {
+      setNotes(next.notes);
+      setRecordedDate(next.recordedDate);
+    }
+    setValidationError(null);
+  }, [item.id, responseKey]);
+
+  useEffect(() => {
+    return () => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+
+      const currentItem = itemRef.current;
+      const current = stateRef.current;
+      let payload: QuestionSavePayload | null = null;
+
+      if (isDateUploadItem(currentItem)) {
+        if (current.recordedDate.trim() && isInputDate(current.recordedDate)) {
+          payload = {
+            response: "NA",
+            notes: "",
+            recordedDate: current.recordedDate,
+          };
+        }
+      } else if (isOpenTextItem(currentItem)) {
+        if (current.notes.trim()) {
+          payload = { response: "NA", notes: current.notes };
+        }
+      } else if (current.response === "YES" && current.notes.trim()) {
+        payload = {
+          response: "YES",
+          notes: current.notes,
+        };
+      } else if (current.response === "NO") {
+        payload = {
+          response: "NO",
+          notes: "",
+        };
+      } else if (current.response === "NA") {
+        payload = { response: "NA", notes: "" };
+      }
+
+      if (payload && canSave(currentItem, payload) === null) {
+        void onSaveRef.current(currentItem.id, sectionId, payload);
+      }
+    };
+  }, [item.id, sectionId]);
+
+  const showYesDetails = !isOpenTextQuestion && !isDateQuestion && response === "YES";
+  const showActionsPanel =
+    isOpenTextQuestion || isDateQuestion || response !== "NA";
+
+  async function persist(next: QuestionSavePayload) {
+    const error = canSave(item, next);
+    if (error) {
+      setValidationError(error);
+      return;
+    }
+
+    setValidationError(null);
+    await onSave(item.id, sectionId, next);
+  }
+
+  function scheduleSave(next: QuestionSavePayload) {
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+    }
+
+    if (canSave(item, next) !== null) {
+      return;
+    }
+
+    debounceRef.current = setTimeout(() => {
+      void persist(next);
+    }, 800);
+  }
+
+  async function handleResponseChange(nextResponse: PrimaryResponseValue) {
+    const nextNotes = nextResponse === "YES" ? notes : "";
+
+    setResponse(nextResponse);
+
+    if (nextResponse === "NA") {
+      setNotes("");
+      await persist({ response: "NA", notes: "" });
+      return;
+    }
+
+    if (nextResponse === "NO") {
+      setNotes("");
+      await persist({ response: "NO", notes: "" });
+      return;
+    }
+
+    setValidationError(null);
+
+    if (nextNotes.trim()) {
+      await persist({
+        response: "YES",
+        notes: nextNotes,
+      });
+    }
+  }
+
+  function handleNotesChange(value: string) {
+    setNotes(value);
+
+    if (isOpenTextQuestion) {
+      scheduleSave({ response: "NA", notes: value });
+      return;
+    }
+
+    if (response === "YES") {
+      scheduleSave({ response: "YES", notes: value });
+    }
+  }
+
+  function handleDateChange(value: string) {
+    setRecordedDate(value);
+    scheduleSave({
+      response: "NA",
+      notes: "",
+      recordedDate: value,
+    });
+  }
+
+  function handleInputFocus() {
+    inputFocusedRef.current = true;
+  }
+
+  async function handleNotesBlur() {
+    inputFocusedRef.current = false;
+
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+      debounceRef.current = null;
+    }
+
+    if (isOpenTextQuestion) {
+      await persist({ response: "NA", notes });
+      return;
+    }
+
+    if (response !== "YES") return;
+    await persist({ response, notes });
+  }
+
+  async function handleDateBlur() {
+    inputFocusedRef.current = false;
+
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+      debounceRef.current = null;
+    }
+
+    if (!isDateQuestion) return;
+    await persist({
+      response: "NA",
+      notes: "",
+      recordedDate,
+    });
+  }
+
+  const isSubQuestion = variant === "sub";
+
+  return (
+    <article
+      className={
+        isSubQuestion
+          ? "rounded-lg border border-slate-200 bg-slate-50/70 p-4"
+          : "rounded-xl border border-slate-200 bg-white p-5 shadow-sm"
+      }
+    >
+      <h3
+        className={
+          isSubQuestion
+            ? "text-sm font-medium text-slate-900"
+            : "text-base font-medium text-slate-900"
+        }
+      >
+        {item.question}
+      </h3>
+      {item.guidance ? (
+        <p className="mt-2 rounded-lg bg-slate-50 px-3 py-2 text-sm text-slate-600">
+          {item.guidance}
+        </p>
+      ) : null}
+
+      {isDateQuestion ? (
+        <div className="mt-4">
+          <DateField
+            id={`date-${item.id}`}
+            label="Date"
+            value={recordedDate}
+            required
+            description="Document upload will be added in a later step."
+            onChange={handleDateChange}
+            onFocus={handleInputFocus}
+            onBlur={handleDateBlur}
+          />
+        </div>
+      ) : isOpenTextQuestion ? (
+        <div className="mt-4">
+          <label
+            htmlFor={`notes-${item.id}`}
+            className="block text-sm font-medium text-slate-700"
+          >
+            Your answer <span className="text-red-600">*</span>
+          </label>
+          <textarea
+            id={`notes-${item.id}`}
+            rows={3}
+            value={notes}
+            onChange={(event) => handleNotesChange(event.target.value)}
+            onFocus={handleInputFocus}
+            onBlur={handleNotesBlur}
+            className="mt-1 w-full rounded-lg border border-slate-300 px-3 py-2 text-sm text-slate-900"
+            placeholder="Type your answer here"
+          />
+        </div>
+      ) : (
+        <>
+          <div className="mt-4">
+            <ResponseInput
+              value={response}
+              disabled={saving}
+              onChange={handleResponseChange}
+            />
+          </div>
+
+          {showYesDetails ? (
+            <div className="mt-4">
+              <label
+                htmlFor={`notes-${item.id}`}
+                className="block text-sm font-medium text-slate-700"
+              >
+                Provide details <span className="text-red-600">*</span>
+              </label>
+              <textarea
+                id={`notes-${item.id}`}
+                rows={3}
+                value={notes}
+                onChange={(event) => handleNotesChange(event.target.value)}
+                onFocus={handleInputFocus}
+                onBlur={handleNotesBlur}
+                className="mt-1 w-full rounded-lg border border-slate-300 px-3 py-2 text-sm text-slate-900"
+                placeholder="Describe what is in place, any evidence, or context for your answer"
+              />
+            </div>
+          ) : null}
+        </>
+      )}
+
+      {validationError ? (
+        <p className="mt-3 text-sm text-red-600">{validationError}</p>
+      ) : null}
+
+      {showActionsPanel ? (
+        <ItemActionPanel
+          item={item}
+          deletingActionId={deletingActionId}
+          onAddAction={onAddAction}
+          onEditAction={onEditAction}
+          onDeleteAction={onDeleteAction}
+        />
+      ) : null}
+    </article>
+  );
+}
diff --git a/components/audit/QuestionGroupCard.tsx b/components/audit/QuestionGroupCard.tsx
new file mode 100644
index 0000000..e8ea9d3
--- /dev/null
+++ b/components/audit/QuestionGroupCard.tsx
@@ -0,0 +1,85 @@
+"use client";
+
+import { useMemo } from "react";
+import type { QuestionSavePayload } from "@/components/audit/QuestionCard";
+import { QuestionCard } from "@/components/audit/QuestionCard";
+import type {
+  AuditGroupSectionItem,
+  AuditItemWithResponse,
+  AuditLinkedAction,
+} from "@/types/audit";
+
+type QuestionGroupCardProps = {
+  group: AuditGroupSectionItem;
+  sectionId: string;
+  savingItemId: string | null;
+  deletingActionId?: string | null;
+  onSave: (
+    itemId: string,
+    sectionId: string,
+    payload: QuestionSavePayload,
+  ) => Promise<void>;
+  onAddAction: (item: AuditItemWithResponse) => void;
+  onEditAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+  onDeleteAction: (item: AuditItemWithResponse, action: AuditLinkedAction) => void;
+};
+
+function toQuestionItem(
+  subQuestion: AuditGroupSectionItem["subQuestions"][number],
+): AuditItemWithResponse {
+  return {
+    id: subQuestion.id,
+    question: subQuestion.question,
+    guidance: "",
+    responseType: subQuestion.responseType,
+    requiresDocument: subQuestion.requiresDocument,
+    documentType: subQuestion.documentType,
+    profileFlag: subQuestion.profileFlag,
+    response: subQuestion.response,
+    actions: subQuestion.actions,
+  };
+}
+
+export function QuestionGroupCard({
+  group,
+  sectionId,
+  savingItemId,
+  deletingActionId = null,
+  onSave,
+  onAddAction,
+  onEditAction,
+  onDeleteAction,
+}: QuestionGroupCardProps) {
+  const questionItems = useMemo(
+    () => group.subQuestions.map((subQuestion) => toQuestionItem(subQuestion)),
+    [group.subQuestions],
+  );
+
+  return (
+    <article className="rounded-xl border border-slate-200 bg-white p-5 shadow-sm">
+      <h3 className="text-base font-medium text-slate-900">{group.label}</h3>
+      {group.guidance ? (
+        <p className="mt-2 rounded-lg bg-slate-50 px-3 py-2 text-sm text-slate-600">
+          {group.guidance}
+        </p>
+      ) : null}
+
+      <div className="mt-4 space-y-4 border-l-2 border-emerald-100 pl-4">
+        {questionItems.map((item) => (
+          <QuestionCard
+            key={item.id}
+            item={item}
+            sectionId={sectionId}
+            variant="sub"
+            saving={savingItemId === item.id}
+            deletingActionId={deletingActionId}
+            onSave={onSave}
+            onAddAction={onAddAction}
+            onEditAction={onEditAction}
+            onDeleteAction={onDeleteAction}
+          />
+        ))}
+      </div>
+    </article>
+  );
+}
diff --git a/components/audit/ResponseInput.tsx b/components/audit/ResponseInput.tsx
new file mode 100644
index 0000000..b521be7
--- /dev/null
+++ b/components/audit/ResponseInput.tsx
@@ -0,0 +1,50 @@
+"use client";
+
+import type { ResponseValue } from "@prisma/client";
+import { RESPONSE_LABELS } from "@/types/audit";
+
+export const PRIMARY_RESPONSE_VALUES = ["YES", "NO", "NA"] as const;
+
+export type PrimaryResponseValue = (typeof PRIMARY_RESPONSE_VALUES)[number];
+
+type ResponseInputProps = {
+  value: PrimaryResponseValue | null;
+  disabled?: boolean;
+  onChange: (value: PrimaryResponseValue) => void;
+};
+
+export function ResponseInput({
+  value,
+  disabled = false,
+  onChange,
+}: ResponseInputProps) {
+  return (
+    <div className="flex flex-wrap gap-2">
+      {PRIMARY_RESPONSE_VALUES.map((option) => {
+        const selected = value === option;
+
+        return (
+          <button
+            key={option}
+            type="button"
+            disabled={disabled}
+            onClick={() => onChange(option)}
+            className={`rounded-lg border px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50 ${
+              selected
+                ? "border-emerald-600 bg-emerald-50 text-emerald-900"
+                : "border-slate-200 bg-white text-slate-700 hover:border-slate-300"
+            }`}
+          >
+            {RESPONSE_LABELS[option]}
+          </button>
+        );
+      })}
+    </div>
+  );
+}
+
+export function isPrimaryResponse(
+  value: ResponseValue | null | undefined,
+): value is PrimaryResponseValue {
+  return value === "YES" || value === "NO" || value === "NA";
+}
diff --git a/components/audit/SectionNav.tsx b/components/audit/SectionNav.tsx
new file mode 100644
index 0000000..f7d476e
--- /dev/null
+++ b/components/audit/SectionNav.tsx
@@ -0,0 +1,59 @@
+"use client";
+
+import type { AuditSectionStatus } from "@prisma/client";
+import type { AuditSectionSummary } from "@/types/audit";
+
+type SectionNavProps = {
+  sections: AuditSectionSummary[];
+  activeSectionId: string;
+  onSelect: (sectionId: string) => void;
+};
+
+function statusStyles(status: AuditSectionStatus): string {
+  switch (status) {
+    case "COMPLETE":
+      return "border-emerald-200 bg-emerald-50 text-emerald-900";
+    case "IN_PROGRESS":
+      return "border-amber-200 bg-amber-50 text-amber-900";
+    case "SKIPPED":
+      return "border-slate-200 bg-slate-100 text-slate-500";
+    default:
+      return "border-slate-200 bg-white text-slate-700 hover:border-slate-300";
+  }
+}
+
+export function SectionNav({
+  sections,
+  activeSectionId,
+  onSelect,
+}: SectionNavProps) {
+  return (
+    <nav aria-label="Audit sections" className="space-y-2">
+      {sections.map((section) => {
+        const isActive = section.id === activeSectionId;
+        return (
+          <button
+            key={section.id}
+            type="button"
+            onClick={() => onSelect(section.id)}
+            className={`flex w-full items-start gap-3 rounded-lg border px-3 py-3 text-left transition-colors ${
+              isActive
+                ? "border-emerald-600 ring-1 ring-emerald-600"
+                : statusStyles(section.status)
+            }`}
+          >
+            <span className="flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-white text-sm font-semibold text-slate-700">
+              {section.number}
+            </span>
+            <span className="min-w-0 flex-1">
+              <span className="block text-sm font-medium">{section.title}</span>
+              <span className="mt-0.5 block text-xs opacity-80">
+                {section.answeredCount}/{section.itemCount} answered
+              </span>
+            </span>
+          </button>
+        );
+      })}
+    </nav>
+  );
+}
diff --git a/components/profile/ProfileWizard.tsx b/components/profile/ProfileWizard.tsx
new file mode 100644
index 0000000..c390099
--- /dev/null
+++ b/components/profile/ProfileWizard.tsx
@@ -0,0 +1,361 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import type {
+  BuildingAgeBand,
+  FloodRiskZone,
+  OwnershipType,
+} from "@prisma/client";
+import { ChoiceGroup, Fieldset, ToggleField, Button } from "@/components/ui/form";
+import {
+  BUILDING_AGE_LABELS,
+  EMPTY_PROFILE_FORM,
+  FLOOD_RISK_LABELS,
+  OWNERSHIP_LABELS,
+  PROFILE_STEPS,
+  type ProfileFormData,
+} from "@/lib/profile-labels";
+import { computeApplicableSections } from "@/lib/sections";
+import { auditTemplate202509 } from "@/prisma/data/audit-template-normalized";
+
+type ProfileWizardProps = {
+  premisesId: string;
+  initialProfile: ProfileFormData;
+  initialApplicableSections: string[];
+};
+
+const sectionTitleById = Object.fromEntries(
+  auditTemplate202509.map((section) => [section.id, section.title]),
+);
+
+function canProceed(stepIndex: number, form: ProfileFormData): boolean {
+  if (stepIndex === 0) {
+    return Boolean(form.ownershipType && form.buildingAgeBand);
+  }
+  return true;
+}
+
+function previewApplicableSections(form: ProfileFormData): string[] {
+  if (!form.ownershipType || !form.buildingAgeBand) {
+    return [];
+  }
+
+  return computeApplicableSections({
+    buildingAgeBand: form.buildingAgeBand,
+    hasGas: form.hasGas,
+    hasSleeping: form.hasSleeping,
+    hasCateringKitchen: form.hasCateringKitchen,
+    hasGrounds: form.hasGrounds,
+    hasVehicles: form.hasVehicles,
+    hasPlantMachinery: form.hasPlantMachinery,
+    hasThirdPartyUsers: form.hasThirdPartyUsers,
+    floodRiskZone:
+      form.floodRiskZone === "" ? null : form.floodRiskZone,
+  });
+}
+
+export function ProfileWizard({
+  premisesId,
+  initialProfile,
+  initialApplicableSections,
+}: ProfileWizardProps) {
+  const [stepIndex, setStepIndex] = useState(0);
+  const [form, setForm] = useState<ProfileFormData>(initialProfile);
+  const [savedSections, setSavedSections] = useState(initialApplicableSections);
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [saved, setSaved] = useState(false);
+
+  const previewSections = useMemo(() => previewApplicableSections(form), [form]);
+  const currentStep = PROFILE_STEPS[stepIndex];
+
+  function updateForm(patch: Partial<ProfileFormData>) {
+    setForm((current) => ({ ...current, ...patch }));
+    setSaved(false);
+    setError(null);
+  }
+
+  async function saveProfile() {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/premises/${premisesId}/profile`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(form),
+      });
+
+      const result = await response.json();
+
+      if (!response.ok) {
+        throw new Error(result.error ?? "Failed to save profile");
+      }
+
+      setSavedSections(result.data.applicableSections);
+      setSaved(true);
+    } catch (saveError) {
+      setError(
+        saveError instanceof Error ? saveError.message : "Failed to save profile",
+      );
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  async function handleNext() {
+    if (stepIndex < PROFILE_STEPS.length - 1) {
+      setStepIndex((index) => index + 1);
+      return;
+    }
+    await saveProfile();
+  }
+
+  function handleBack() {
+    setStepIndex((index) => Math.max(0, index - 1));
+    setError(null);
+  }
+
+  return (
+    <div className="rounded-xl border border-slate-200 bg-white shadow-sm">
+      <div className="border-b border-slate-200 px-6 py-5">
+        <div className="flex items-center justify-between gap-4">
+          <div>
+            <p className="text-sm text-slate-500">
+              Step {stepIndex + 1} of {PROFILE_STEPS.length}
+            </p>
+            <h2 className="text-lg font-semibold text-slate-900">
+              {currentStep.title}
+            </h2>
+            <p className="mt-1 text-sm text-slate-600">{currentStep.description}</p>
+          </div>
+        </div>
+        <div className="mt-4 flex gap-2">
+          {PROFILE_STEPS.map((step, index) => (
+            <div
+              key={step.id}
+              className={`h-1.5 flex-1 rounded-full ${
+                index <= stepIndex ? "bg-emerald-600" : "bg-slate-200"
+              }`}
+            />
+          ))}
+        </div>
+      </div>
+
+      <div className="space-y-6 px-6 py-6">
+        {stepIndex === 0 ? (
+          <>
+            <Fieldset
+              legend="Who is responsible for the building?"
+              description="This helps us understand your legal obligations as trustees."
+            >
+              <ChoiceGroup<OwnershipType>
+                name="ownershipType"
+                value={form.ownershipType}
+                options={(
+                  Object.entries(OWNERSHIP_LABELS) as [OwnershipType, string][]
+                ).map(([value, label]) => ({ value, label }))}
+                onChange={(ownershipType) => updateForm({ ownershipType })}
+              />
+            </Fieldset>
+            <Fieldset
+              legend="When was the building constructed?"
+              description="Buildings built before 2000 may contain asbestos and need extra checks."
+            >
+              <ChoiceGroup<BuildingAgeBand>
+                name="buildingAgeBand"
+                value={form.buildingAgeBand}
+                options={(
+                  Object.entries(BUILDING_AGE_LABELS) as [BuildingAgeBand, string][]
+                ).map(([value, label]) => ({ value, label }))}
+                onChange={(buildingAgeBand) => updateForm({ buildingAgeBand })}
+              />
+            </Fieldset>
+          </>
+        ) : null}
+
+        {stepIndex === 1 ? (
+          <>
+            <Fieldset legend="Does the premises have a gas supply?">
+              <ToggleField
+                label="Yes, we have gas appliances on site"
+                description="Boilers, heaters, or a gas cooker — we'll include the Gas section in your audit."
+                checked={form.hasGas}
+                onChange={(hasGas) => updateForm({ hasGas })}
+              />
+            </Fieldset>
+            <Fieldset
+              legend="What is the flood risk for this site?"
+              description="Optional — choose the closest match if you know it."
+            >
+              <ChoiceGroup<FloodRiskZone | "">
+                name="floodRiskZone"
+                value={form.floodRiskZone ?? ""}
+                options={[
+                  { value: "", label: "Not sure / not assessed" },
+                  ...(
+                    Object.entries(FLOOD_RISK_LABELS) as [FloodRiskZone, string][]
+                  ).map(([value, label]) => ({ value, label })),
+                ]}
+                onChange={(floodRiskZone) =>
+                  updateForm({
+                    floodRiskZone: floodRiskZone === "" ? null : floodRiskZone,
+                  })
+                }
+              />
+            </Fieldset>
+          </>
+        ) : null}
+
+        {stepIndex === 2 ? (
+          <Fieldset legend="Which facilities do you have on site?">
+            <ToggleField
+              label="Catering kitchen"
+              description="A kitchen used for preparing food for camps or events."
+              checked={form.hasCateringKitchen}
+              onChange={(hasCateringKitchen) => updateForm({ hasCateringKitchen })}
+            />
+            <ToggleField
+              label="Outdoor grounds"
+              description="Trees, grass, paths, or play areas you maintain."
+              checked={form.hasGrounds}
+              onChange={(hasGrounds) => updateForm({ hasGrounds })}
+            />
+            <ToggleField
+              label="Sleeping accommodation"
+              description="Bunks, dorms, or rooms where people stay overnight."
+              checked={form.hasSleeping}
+              onChange={(hasSleeping) => updateForm({ hasSleeping })}
+            />
+          </Fieldset>
+        ) : null}
+
+        {stepIndex === 3 ? (
+          <Fieldset legend="How is the premises used day to day?">
+            <ToggleField
+              label="Vehicles stored or maintained on site"
+              description="Minibuses, trailers, or maintenance vehicles kept at the premises."
+              checked={form.hasVehicles}
+              onChange={(hasVehicles) => updateForm({ hasVehicles })}
+            />
+            <ToggleField
+              label="Plant, machinery, or power tools"
+              description="Workshop equipment, mowers, or other powered machinery."
+              checked={form.hasPlantMachinery}
+              onChange={(hasPlantMachinery) => updateForm({ hasPlantMachinery })}
+            />
+            <ToggleField
+              label="Hired out to third parties"
+              description="External groups or organisations use the building."
+              checked={form.hasThirdPartyUsers}
+              onChange={(hasThirdPartyUsers) => updateForm({ hasThirdPartyUsers })}
+            />
+          </Fieldset>
+        ) : null}
+
+        {stepIndex === 4 ? (
+          <div className="space-y-6">
+            <div className="rounded-lg bg-slate-50 p-4 text-sm text-slate-700">
+              <p className="font-medium text-slate-900">Your answers</p>
+              <ul className="mt-3 space-y-1">
+                <li>
+                  Ownership:{" "}
+                  {form.ownershipType
+                    ? OWNERSHIP_LABELS[form.ownershipType]
+                    : "—"}
+                </li>
+                <li>
+                  Building age:{" "}
+                  {form.buildingAgeBand
+                    ? BUILDING_AGE_LABELS[form.buildingAgeBand]
+                    : "—"}
+                </li>
+                <li>Gas on site: {form.hasGas ? "Yes" : "No"}</li>
+                <li>
+                  Flood risk:{" "}
+                  {form.floodRiskZone ? FLOOD_RISK_LABELS[form.floodRiskZone] : "Not set"}
+                </li>
+                <li>Kitchen: {form.hasCateringKitchen ? "Yes" : "No"}</li>
+                <li>Grounds: {form.hasGrounds ? "Yes" : "No"}</li>
+                <li>Sleeping: {form.hasSleeping ? "Yes" : "No"}</li>
+                <li>Vehicles: {form.hasVehicles ? "Yes" : "No"}</li>
+                <li>Plant/machinery: {form.hasPlantMachinery ? "Yes" : "No"}</li>
+                <li>Third-party hire: {form.hasThirdPartyUsers ? "Yes" : "No"}</li>
+              </ul>
+            </div>
+
+            <div>
+              <p className="font-medium text-slate-900">
+                {previewSections.length} audit sections will apply
+              </p>
+              <p className="mt-1 text-sm text-slate-600">
+                Based on your profile, we&apos;ll include the relevant sections
+                from the Scout Association September 2025 audit template.
+              </p>
+              <ul className="mt-4 max-h-64 space-y-2 overflow-y-auto text-sm text-slate-700">
+                {previewSections.map((sectionId) => (
+                  <li
+                    key={sectionId}
+                    className="rounded-md border border-slate-200 bg-white px-3 py-2"
+                  >
+                    {sectionTitleById[sectionId] ?? sectionId}
+                  </li>
+                ))}
+              </ul>
+            </div>
+
+            {saved ? (
+              <div className="rounded-lg border border-emerald-200 bg-emerald-50 px-4 py-3 text-sm text-emerald-800">
+                Profile saved. {savedSections.length} audit sections will apply to
+                your next audit.
+              </div>
+            ) : null}
+          </div>
+        ) : null}
+
+        {error ? (
+          <div className="rounded-lg border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-700">
+            {error}
+          </div>
+        ) : null}
+      </div>
+
+      <div className="flex items-center justify-between border-t border-slate-200 px-6 py-4">
+        <Button
+          variant="secondary"
+          onClick={handleBack}
+          disabled={stepIndex === 0 || isSaving}
+        >
+          Back
+        </Button>
+        <div className="flex gap-3">
+          {stepIndex === PROFILE_STEPS.length - 1 && saved ? (
+            <Button
+              variant="secondary"
+              onClick={() => {
+                setForm(EMPTY_PROFILE_FORM);
+                setStepIndex(0);
+                setSaved(false);
+                setSavedSections([]);
+              }}
+            >
+              Start again
+            </Button>
+          ) : null}
+          <Button
+            onClick={handleNext}
+            disabled={!canProceed(stepIndex, form) || isSaving}
+          >
+            {isSaving
+              ? "Saving…"
+              : stepIndex === PROFILE_STEPS.length - 1
+                ? saved
+                  ? "Saved"
+                  : "Save profile"
+                : "Continue"}
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/components/ui/form.tsx b/components/ui/form.tsx
new file mode 100644
index 0000000..0488286
--- /dev/null
+++ b/components/ui/form.tsx
@@ -0,0 +1,189 @@
+"use client";
+
+import type { ReactNode } from "react";
+
+type FieldsetProps = {
+  legend: string;
+  description?: string;
+  children: ReactNode;
+};
+
+export function Fieldset({ legend, description, children }: FieldsetProps) {
+  return (
+    <fieldset className="space-y-4">
+      <legend className="text-base font-medium text-slate-900">{legend}</legend>
+      {description ? (
+        <p className="text-sm text-slate-600">{description}</p>
+      ) : null}
+      <div className="space-y-3">{children}</div>
+    </fieldset>
+  );
+}
+
+type ChoiceOption<T extends string> = {
+  value: T;
+  label: string;
+  description?: string;
+};
+
+type ChoiceGroupProps<T extends string> = {
+  name: string;
+  value: T | "";
+  options: ChoiceOption<T>[];
+  onChange: (value: T) => void;
+};
+
+export function ChoiceGroup<T extends string>({
+  name,
+  value,
+  options,
+  onChange,
+}: ChoiceGroupProps<T>) {
+  return (
+    <div className="space-y-2">
+      {options.map((option) => {
+        const checked = value === option.value;
+        return (
+          <label
+            key={option.value}
+            className={`flex cursor-pointer gap-3 rounded-lg border p-4 transition-colors ${
+              checked
+                ? "border-emerald-600 bg-emerald-50"
+                : "border-slate-200 bg-white hover:border-slate-300"
+            }`}
+          >
+            <input
+              type="radio"
+              name={name}
+              value={option.value}
+              checked={checked}
+              onChange={() => onChange(option.value)}
+              className="mt-1 h-4 w-4 shrink-0 accent-emerald-600"
+            />
+            <span>
+              <span className="block font-medium text-slate-900">{option.label}</span>
+              {option.description ? (
+                <span className="mt-0.5 block text-sm text-slate-600">
+                  {option.description}
+                </span>
+              ) : null}
+            </span>
+          </label>
+        );
+      })}
+    </div>
+  );
+}
+
+type ToggleFieldProps = {
+  label: string;
+  description?: string;
+  checked: boolean;
+  onChange: (checked: boolean) => void;
+};
+
+export function ToggleField({
+  label,
+  description,
+  checked,
+  onChange,
+}: ToggleFieldProps) {
+  return (
+    <label
+      className={`flex cursor-pointer gap-3 rounded-lg border p-4 transition-colors ${
+        checked
+          ? "border-emerald-600 bg-emerald-50"
+          : "border-slate-200 bg-white hover:border-slate-300"
+      }`}
+    >
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(event) => onChange(event.target.checked)}
+        className="mt-1 h-4 w-4 shrink-0 rounded accent-emerald-600"
+      />
+      <span>
+        <span className="block font-medium text-slate-900">{label}</span>
+        {description ? (
+          <span className="mt-0.5 block text-sm text-slate-600">{description}</span>
+        ) : null}
+      </span>
+    </label>
+  );
+}
+
+type ButtonProps = {
+  children: ReactNode;
+  onClick?: () => void;
+  type?: "button" | "submit";
+  variant?: "primary" | "secondary";
+  disabled?: boolean;
+};
+
+type DateFieldProps = {
+  id: string;
+  label: string;
+  value: string;
+  required?: boolean;
+  description?: string;
+  onChange: (value: string) => void;
+  onFocus?: () => void;
+  onBlur?: () => void;
+};
+
+export function DateField({
+  id,
+  label,
+  value,
+  required = false,
+  description,
+  onChange,
+  onFocus,
+  onBlur,
+}: DateFieldProps) {
+  return (
+    <div>
+      <label htmlFor={id} className="block text-sm font-medium text-slate-700">
+        {label} {required ? <span className="text-red-600">*</span> : null}
+      </label>
+      {description ? (
+        <p className="mt-1 text-sm text-slate-500">{description}</p>
+      ) : null}
+      <input
+        id={id}
+        type="date"
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+        onFocus={onFocus}
+        onBlur={onBlur}
+        className="mt-1 w-full max-w-xs rounded-lg border border-slate-300 px-3 py-2 text-sm text-slate-900"
+      />
+    </div>
+  );
+}
+
+export function Button({
+  children,
+  onClick,
+  type = "button",
+  variant = "primary",
+  disabled = false,
+}: ButtonProps) {
+  const base =
+    "inline-flex items-center justify-center rounded-lg px-4 py-2.5 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50";
+  const styles =
+    variant === "primary"
+      ? "bg-emerald-700 text-white hover:bg-emerald-800"
+      : "border border-slate-300 bg-white text-slate-700 hover:bg-slate-50";
+
+  return (
+    <button
+      type={type}
+      onClick={onClick}
+      disabled={disabled}
+      className={`${base} ${styles}`}
+    >
+      {children}
+    </button>
+  );
+}
diff --git a/lib/audit-items.ts b/lib/audit-items.ts
new file mode 100644
index 0000000..604f13b
--- /dev/null
+++ b/lib/audit-items.ts
@@ -0,0 +1,189 @@
+import type { BuildingAgeBand, FloodRiskZone } from "@prisma/client";
+import type {
+  AnswerableAuditItem,
+  AuditSubQuestion,
+  AuditTemplateItem,
+  AuditTemplateSections,
+} from "@/types/audit-template";
+import { isDateUploadItem, isGroupItem, isOpenTextItem } from "@/types/audit-template";
+
+export type ProfileForSections = {
+  buildingAgeBand: BuildingAgeBand;
+  hasGas: boolean;
+  hasSleeping: boolean;
+  hasCateringKitchen: boolean;
+  hasGrounds: boolean;
+  hasVehicles: boolean;
+  hasPlantMachinery: boolean;
+  hasThirdPartyUsers: boolean;
+  floodRiskZone: FloodRiskZone | null;
+};
+
+export function matchesProfileFlag(
+  flag: string,
+  profile: ProfileForSections,
+): boolean {
+  switch (flag) {
+    case "hasGas":
+      return profile.hasGas;
+    case "hasSleeping":
+      return profile.hasSleeping;
+    case "hasCateringKitchen":
+      return profile.hasCateringKitchen;
+    case "hasGrounds":
+      return profile.hasGrounds;
+    case "hasVehicles":
+      return profile.hasVehicles;
+    case "hasPlantMachinery":
+      return profile.hasPlantMachinery;
+    case "hasThirdPartyUsers":
+      return profile.hasThirdPartyUsers;
+    case "hasPaidStaff":
+      return false;
+    case "floodRisk":
+      return (
+        profile.floodRiskZone === "MEDIUM" || profile.floodRiskZone === "HIGH"
+      );
+    default:
+      return true;
+  }
+}
+
+export function isSubQuestionApplicable(
+  subQuestion: AuditSubQuestion,
+  profile: ProfileForSections,
+): boolean {
+  if (!subQuestion.profileFlag) {
+    return true;
+  }
+  return matchesProfileFlag(subQuestion.profileFlag, profile);
+}
+
+export function isAuditItemApplicable(
+  item: AuditTemplateItem,
+  profile: ProfileForSections,
+): boolean {
+  if (!item.profileFlag) {
+    return true;
+  }
+  return matchesProfileFlag(item.profileFlag, profile);
+}
+
+export function filterApplicableSubQuestions(
+  subQuestions: AuditSubQuestion[],
+  profile: ProfileForSections,
+): AuditSubQuestion[] {
+  return subQuestions.filter((subQuestion) =>
+    isSubQuestionApplicable(subQuestion, profile),
+  );
+}
+
+export function filterApplicableItems(
+  items: AuditTemplateItem[],
+  profile: ProfileForSections,
+): AuditTemplateItem[] {
+  return items
+    .filter((item) => isAuditItemApplicable(item, profile))
+    .map((item) => {
+      if (!isGroupItem(item)) {
+        return item;
+      }
+
+      const subQuestions = filterApplicableSubQuestions(
+        item.subQuestions,
+        profile,
+      );
+
+      if (subQuestions.length === 0) {
+        return null;
+      }
+
+      return {
+        ...item,
+        subQuestions,
+      };
+    })
+    .filter((item): item is AuditTemplateItem => item !== null);
+}
+
+export function getAnswerableItems(
+  items: AuditTemplateItem[],
+): AnswerableAuditItem[] {
+  const answerable: AnswerableAuditItem[] = [];
+
+  for (const item of items) {
+    if (isGroupItem(item)) {
+      answerable.push(...item.subQuestions);
+      continue;
+    }
+
+    answerable.push(item);
+  }
+
+  return answerable;
+}
+
+export function findAnswerableItem(
+  items: AuditTemplateItem[],
+  itemId: string,
+): AnswerableAuditItem | undefined {
+  return getAnswerableItems(items).find((item) => item.id === itemId);
+}
+
+export function findAnswerableItemInAudit(
+  templateSections: AuditTemplateSections,
+  profile: ProfileForSections,
+  itemId: string,
+  preferredSectionId?: string,
+): { item: AnswerableAuditItem; sectionId: string } | undefined {
+  const orderedSectionIds = preferredSectionId
+    ? [
+        preferredSectionId,
+        ...templateSections
+          .map((section) => section.id)
+          .filter((id) => id !== preferredSectionId),
+      ]
+    : templateSections.map((section) => section.id);
+
+  for (const sectionId of orderedSectionIds) {
+    const section = templateSections.find((entry) => entry.id === sectionId);
+    if (!section) {
+      continue;
+    }
+
+    const item = findAnswerableItem(
+      filterApplicableItems(section.items, profile),
+      itemId,
+    );
+
+    if (item) {
+      return { item, sectionId };
+    }
+  }
+
+  return undefined;
+}
+
+export function isAnswerComplete(
+  item: AnswerableAuditItem,
+  notes: string | null | undefined,
+  recordedDate: Date | string | null | undefined,
+): boolean {
+  if (isDateUploadItem(item)) {
+    return Boolean(recordedDate);
+  }
+
+  if (isOpenTextItem(item)) {
+    return Boolean(notes?.trim());
+  }
+
+  return false;
+}
+
+export function isTextResponseComplete(
+  item: AnswerableAuditItem,
+  notes: string | null | undefined,
+  recordedDate?: Date | string | null,
+): boolean {
+  return isAnswerComplete(item, notes, recordedDate);
+}
diff --git a/lib/audit.ts b/lib/audit.ts
new file mode 100644
index 0000000..c8ea3da
--- /dev/null
+++ b/lib/audit.ts
@@ -0,0 +1,747 @@
+import {
+  ActionSourceType,
+  ActionStatus,
+  AuditSectionStatus,
+  AuditStatus,
+  Priority,
+  ResponseValue,
+  type Action,
+  type Audit,
+  type AuditResponse,
+  type AuditSection,
+  type PremisesProfile,
+} from "@prisma/client";
+import { prisma } from "@/lib/prisma";
+import { getPremisesForOrganisation } from "@/lib/premises";
+import {
+  filterApplicableItems,
+  findAnswerableItemInAudit,
+  getAnswerableItems,
+  isAnswerComplete,
+} from "@/lib/audit-items";
+import { isInputDate, parseInputDate, toRecordedDateIso } from "@/lib/dates";
+import { computeApplicableSections } from "@/lib/sections";
+import type {
+  AuditTemplateItem,
+  AuditTemplateSection,
+  AuditTemplateSections,
+  AnswerableAuditItem,
+} from "@/types/audit-template";
+import { isDateUploadItem, isGroupItem, isOpenTextItem, isTextAnswerItem } from "@/types/audit-template";
+import type { AuditLinkedAction } from "@/types/audit";
+
+export type AuditWithRelations = Audit & {
+  sections: AuditSection[];
+  responses: AuditResponse[];
+  template: { version: string; sections: unknown };
+  premises: {
+    id: string;
+    name: string;
+    profile: PremisesProfile | null;
+  };
+};
+
+export function parseTemplateSections(sections: unknown): AuditTemplateSections {
+  return sections as AuditTemplateSections;
+}
+
+const auditWithRelationsInclude = {
+  sections: { orderBy: { sectionId: "asc" as const } },
+  responses: true,
+  template: { select: { version: true, sections: true } },
+  premises: {
+    select: {
+      id: true,
+      name: true,
+      profile: true,
+    },
+  },
+};
+
+async function fetchAuditWithRelations(
+  auditId: string,
+  organisationId: string,
+): Promise<AuditWithRelations | null> {
+  return prisma.audit.findFirst({
+    where: {
+      id: auditId,
+      premises: { organisationId },
+    },
+    include: auditWithRelationsInclude,
+  }) as Promise<AuditWithRelations | null>;
+}
+
+function applicableSectionsMatch(
+  current: string[],
+  target: string[],
+): boolean {
+  if (current.length !== target.length) {
+    return false;
+  }
+
+  return current.every((sectionId, index) => sectionId === target[index]);
+}
+
+export async function syncDraftAudit(
+  audit: AuditWithRelations,
+): Promise<AuditWithRelations> {
+  if (audit.status !== AuditStatus.DRAFT) {
+    return audit;
+  }
+
+  const profile = audit.premises.profile;
+  if (!profile) {
+    return audit;
+  }
+
+  const activeTemplate = await prisma.auditTemplate.findFirst({
+    where: { isActive: true },
+    orderBy: { publishedAt: "desc" },
+  });
+
+  if (!activeTemplate) {
+    return audit;
+  }
+
+  const applicableSections = computeApplicableSections(profile);
+  const currentSectionIds = new Set(
+    audit.sections.map((section) => section.sectionId),
+  );
+  const sectionsToRemove = audit.sections
+    .filter((section) => !applicableSections.includes(section.sectionId))
+    .map((section) => section.sectionId);
+  const sectionsToAdd = applicableSections.filter(
+    (sectionId) => !currentSectionIds.has(sectionId),
+  );
+  const profileSectionsChanged = !applicableSectionsMatch(
+    profile.applicableSections,
+    applicableSections,
+  );
+  const needsTemplateUpdate = audit.templateId !== activeTemplate.id;
+
+  if (
+    !needsTemplateUpdate &&
+    sectionsToRemove.length === 0 &&
+    sectionsToAdd.length === 0 &&
+    !profileSectionsChanged
+  ) {
+    return audit;
+  }
+
+  await prisma.$transaction(async (tx) => {
+    if (profileSectionsChanged) {
+      await tx.premisesProfile.update({
+        where: { premisesId: audit.premisesId },
+        data: { applicableSections },
+      });
+    }
+
+    if (needsTemplateUpdate) {
+      await tx.audit.update({
+        where: { id: audit.id },
+        data: { templateId: activeTemplate.id },
+      });
+    }
+
+    if (sectionsToRemove.length > 0) {
+      await tx.auditSection.deleteMany({
+        where: {
+          auditId: audit.id,
+          sectionId: { in: sectionsToRemove },
+        },
+      });
+    }
+
+    if (sectionsToAdd.length > 0) {
+      await tx.auditSection.createMany({
+        data: sectionsToAdd.map((sectionId) => ({
+          auditId: audit.id,
+          sectionId,
+          status: AuditSectionStatus.NOT_STARTED,
+        })),
+      });
+    }
+  });
+
+  const refreshed = await prisma.audit.findUnique({
+    where: { id: audit.id },
+    include: auditWithRelationsInclude,
+  });
+
+  return (refreshed ?? audit) as AuditWithRelations;
+}
+
+export async function getAuditForOrganisation(
+  auditId: string,
+  organisationId: string,
+): Promise<AuditWithRelations | null> {
+  const audit = await fetchAuditWithRelations(auditId, organisationId);
+
+  if (!audit) {
+    return null;
+  }
+
+  if (audit.status === AuditStatus.DRAFT) {
+    return syncDraftAudit(audit);
+  }
+
+  return audit;
+}
+
+export function getTemplateSection(
+  templateSections: AuditTemplateSections,
+  sectionId: string,
+): AuditTemplateSection | undefined {
+  return templateSections.find((section) => section.id === sectionId);
+}
+
+export function getApplicableItemsForSection(
+  section: AuditTemplateSection,
+  profile: PremisesProfile,
+): AuditTemplateItem[] {
+  return filterApplicableItems(section.items, profile);
+}
+
+export async function startOrResumeAudit(
+  premisesId: string,
+  organisationId: string,
+  userId: string,
+): Promise<{ audit: AuditWithRelations; created: boolean }> {
+  const premises = await getPremisesForOrganisation(premisesId, organisationId);
+
+  if (!premises) {
+    throw new Error("Premises not found");
+  }
+
+  if (!premises.profile) {
+    throw new Error("Complete the premises profile before starting an audit");
+  }
+
+  if (premises.profile.applicableSections.length === 0) {
+    throw new Error("No audit sections apply to this premises profile");
+  }
+
+  const existingDraft = await prisma.audit.findFirst({
+    where: {
+      premisesId,
+      status: AuditStatus.DRAFT,
+    },
+    include: {
+      sections: { orderBy: { sectionId: "asc" } },
+      responses: true,
+      template: { select: { version: true, sections: true } },
+      premises: {
+        select: {
+          id: true,
+          name: true,
+          profile: true,
+        },
+      },
+    },
+  });
+
+  if (existingDraft) {
+    const audit = await syncDraftAudit(existingDraft as AuditWithRelations);
+
+    return {
+      audit,
+      created: false,
+    };
+  }
+
+  const template = await prisma.auditTemplate.findFirst({
+    where: { isActive: true },
+    orderBy: { publishedAt: "desc" },
+  });
+
+  if (!template) {
+    throw new Error("No active audit template found");
+  }
+
+  const audit = await prisma.audit.create({
+    data: {
+      premisesId,
+      templateId: template.id,
+      status: AuditStatus.DRAFT,
+      startedBy: userId,
+      sections: {
+        create: premises.profile.applicableSections.map((sectionId) => ({
+          sectionId,
+          status: AuditSectionStatus.NOT_STARTED,
+        })),
+      },
+    },
+    include: {
+      sections: { orderBy: { sectionId: "asc" } },
+      responses: true,
+      template: { select: { version: true, sections: true } },
+      premises: {
+        select: {
+          id: true,
+          name: true,
+          profile: true,
+        },
+      },
+    },
+  });
+
+  return {
+    audit: audit as AuditWithRelations,
+    created: true,
+  };
+}
+
+function isResponseComplete(
+  response: AuditResponse,
+  item?: AnswerableAuditItem,
+): boolean {
+  if (item && isTextAnswerItem(item)) {
+    return isAnswerComplete(item, response.notes, response.recordedDate);
+  }
+
+  if (response.response === ResponseValue.YES) {
+    return Boolean(response.notes?.trim());
+  }
+  if (
+    response.response === ResponseValue.NO ||
+    response.response === ResponseValue.NA
+  ) {
+    return true;
+  }
+  return response.response === ResponseValue.ACTION_NEEDED;
+}
+
+function countCompleteResponses(
+  responses: AuditResponse[],
+  items: AnswerableAuditItem[],
+): number {
+  const itemsById = new Map(items.map((item) => [item.id, item]));
+  return responses.filter((response) => {
+    const item = itemsById.get(response.itemId);
+    return item ? isResponseComplete(response, item) : false;
+  }).length;
+}
+
+async function refreshSectionStatus(
+  auditId: string,
+  sectionId: string,
+  profile: PremisesProfile,
+  templateSections: AuditTemplateSections,
+): Promise<AuditSectionStatus> {
+  const section = getTemplateSection(templateSections, sectionId);
+  if (!section) {
+    return AuditSectionStatus.SKIPPED;
+  }
+
+  const applicableItems = getApplicableItemsForSection(section, profile);
+  const answerableItems = getAnswerableItems(applicableItems);
+
+  if (answerableItems.length === 0) {
+    await prisma.auditSection.updateMany({
+      where: { auditId, sectionId },
+      data: { status: AuditSectionStatus.SKIPPED },
+    });
+    return AuditSectionStatus.SKIPPED;
+  }
+
+  const responses = await prisma.auditResponse.findMany({
+    where: {
+      auditId,
+      itemId: { in: answerableItems.map((item) => item.id) },
+    },
+  });
+
+  const answeredCount = countCompleteResponses(responses, answerableItems);
+  let status: AuditSectionStatus;
+
+  if (answeredCount === 0) {
+    status = AuditSectionStatus.NOT_STARTED;
+  } else if (answeredCount < answerableItems.length) {
+    status = AuditSectionStatus.IN_PROGRESS;
+  } else {
+    status = AuditSectionStatus.COMPLETE;
+  }
+
+  await prisma.auditSection.updateMany({
+    where: { auditId, sectionId },
+    data: { status },
+  });
+
+  return status;
+}
+
+export async function saveAuditResponse(
+  auditId: string,
+  organisationId: string,
+  userId: string,
+  itemId: string,
+  sectionId: string,
+  response: ResponseValue,
+  options?: {
+    notes?: string | null;
+    needsAction?: boolean;
+    recordedDate?: string | null;
+  },
+): Promise<{
+  response: AuditResponse;
+  sectionStatus: AuditSectionStatus;
+}> {
+  const audit = await getAuditForOrganisation(auditId, organisationId);
+
+  if (!audit) {
+    throw new Error("Audit not found");
+  }
+
+  if (audit.status !== AuditStatus.DRAFT) {
+    throw new Error("Cannot edit a completed audit");
+  }
+
+  const profile = audit.premises.profile;
+  if (!profile) {
+    throw new Error("Premises profile is required");
+  }
+
+  const templateSections = parseTemplateSections(audit.template.sections);
+  const section = getTemplateSection(templateSections, sectionId);
+
+  if (!section) {
+    throw new Error("Section not found");
+  }
+
+  const located = findAnswerableItemInAudit(
+    templateSections,
+    profile,
+    itemId,
+    sectionId,
+  );
+  const item = located?.item;
+  const resolvedSectionId = located?.sectionId ?? sectionId;
+
+  if (!item) {
+    throw new Error("Question not found in this section");
+  }
+
+  let needsAction = options?.needsAction ?? false;
+  let notes = options?.notes ?? null;
+  let recordedDate: Date | null = null;
+  let storedResponse = response;
+
+  if (isDateUploadItem(item)) {
+    const dateValue = options?.recordedDate?.trim();
+    if (!dateValue || !isInputDate(dateValue)) {
+      throw new Error("A valid date is required");
+    }
+    storedResponse = ResponseValue.NA;
+    needsAction = false;
+    notes = null;
+    recordedDate = parseInputDate(dateValue);
+  } else if (isOpenTextItem(item)) {
+    if (!notes?.trim()) {
+      throw new Error("An answer is required");
+    }
+    storedResponse = ResponseValue.NA;
+    needsAction = false;
+  } else if (storedResponse === ResponseValue.YES && !notes?.trim()) {
+    throw new Error("Provide details is required when answering Yes");
+  } else if (
+    needsAction &&
+    storedResponse !== ResponseValue.YES &&
+    storedResponse !== ResponseValue.NO
+  ) {
+    throw new Error("Needs action can only be set for Yes or No answers");
+  }
+
+  const saved = await prisma.auditResponse.upsert({
+    where: {
+      auditId_itemId: { auditId, itemId },
+    },
+    create: {
+      auditId,
+      itemId,
+      response: storedResponse,
+      needsAction,
+      notes: notes?.trim() ? notes.trim() : null,
+      recordedDate,
+      respondedBy: userId,
+    },
+    update: {
+      response: storedResponse,
+      needsAction,
+      notes: notes?.trim() ? notes.trim() : null,
+      recordedDate,
+      respondedBy: userId,
+      respondedAt: new Date(),
+    },
+  });
+
+  const sectionStatus = await refreshSectionStatus(
+    auditId,
+    resolvedSectionId,
+    profile,
+    templateSections,
+  );
+
+  return { response: saved, sectionStatus };
+}
+
+export type CreateAuditActionInput = {
+  title: string;
+  description?: string;
+  priority: Priority;
+  dueDate?: string | null;
+  itemId: string;
+};
+
+export async function createAuditAction(
+  auditId: string,
+  organisationId: string,
+  userId: string,
+  input: CreateAuditActionInput,
+) {
+  const audit = await getAuditForOrganisation(auditId, organisationId);
+
+  if (!audit) {
+    throw new Error("Audit not found");
+  }
+
+  return prisma.action.create({
+    data: {
+      premisesId: audit.premisesId,
+      title: input.title,
+      description: input.description ?? null,
+      sourceType: ActionSourceType.AUDIT,
+      sourceRef: auditId,
+      sourceItemId: input.itemId,
+      priority: input.priority,
+      dueDate: input.dueDate ? new Date(input.dueDate) : null,
+      status: ActionStatus.OPEN,
+      createdBy: userId,
+    },
+  });
+}
+
+export function serializeLinkedAction(action: Action): AuditLinkedAction {
+  return {
+    id: action.id,
+    title: action.title,
+    description: action.description,
+    priority: action.priority,
+    dueDate: toRecordedDateIso(action.dueDate),
+    status: action.status,
+  };
+}
+
+async function getAuditActionsByItemId(
+  auditId: string,
+): Promise<Map<string, Action[]>> {
+  const actions = await prisma.action.findMany({
+    where: {
+      sourceType: ActionSourceType.AUDIT,
+      sourceRef: auditId,
+      sourceItemId: { not: null },
+    },
+    orderBy: { createdAt: "asc" },
+  });
+
+  const grouped = new Map<string, Action[]>();
+
+  for (const action of actions) {
+    if (!action.sourceItemId) {
+      continue;
+    }
+
+    const existing = grouped.get(action.sourceItemId) ?? [];
+    existing.push(action);
+    grouped.set(action.sourceItemId, existing);
+  }
+
+  return grouped;
+}
+
+export type UpdateAuditActionInput = {
+  title: string;
+  description?: string;
+  priority: Priority;
+  dueDate?: string | null;
+};
+
+export async function updateAuditAction(
+  actionId: string,
+  organisationId: string,
+  input: UpdateAuditActionInput,
+): Promise<Action> {
+  const existing = await prisma.action.findFirst({
+    where: {
+      id: actionId,
+      premises: { organisationId },
+    },
+  });
+
+  if (!existing) {
+    throw new Error("Action not found");
+  }
+
+  return prisma.action.update({
+    where: { id: actionId },
+    data: {
+      title: input.title,
+      description: input.description ?? null,
+      priority: input.priority,
+      dueDate: input.dueDate ? new Date(input.dueDate) : null,
+    },
+  });
+}
+
+export async function deleteAuditAction(
+  actionId: string,
+  organisationId: string,
+): Promise<void> {
+  const existing = await prisma.action.findFirst({
+    where: {
+      id: actionId,
+      premises: { organisationId },
+    },
+  });
+
+  if (!existing) {
+    throw new Error("Action not found");
+  }
+
+  await prisma.action.delete({
+    where: { id: actionId },
+  });
+}
+
+export async function buildAuditSectionPayload(
+  audit: AuditWithRelations,
+  sectionId: string,
+) {
+  const profile = audit.premises.profile;
+  if (!profile) {
+    throw new Error("Premises profile is required");
+  }
+
+  const templateSections = parseTemplateSections(audit.template.sections);
+  const section = getTemplateSection(templateSections, sectionId);
+
+  if (!section) {
+    throw new Error("Section not found");
+  }
+
+  const items = getApplicableItemsForSection(section, profile);
+  const actionsByItemId = await getAuditActionsByItemId(audit.id);
+  const responsesByItemId = Object.fromEntries(
+    audit.responses.map((response) => [response.itemId, response]),
+  );
+
+  const sectionRecord = audit.sections.find(
+    (entry) => entry.sectionId === sectionId,
+  );
+
+  const toResponseRecord = (itemId: string) => {
+    const response = responsesByItemId[itemId];
+    if (!response) return null;
+
+    return {
+      id: response.id,
+      response: response.response,
+      needsAction: response.needsAction,
+      notes: response.notes,
+      recordedDate: toRecordedDateIso(response.recordedDate),
+    };
+  };
+
+  const toLinkedActions = (itemId: string): AuditLinkedAction[] =>
+    (actionsByItemId.get(itemId) ?? []).map(serializeLinkedAction);
+
+  return {
+    section: {
+      id: section.id,
+      number: section.number,
+      title: section.title,
+      status: sectionRecord?.status ?? AuditSectionStatus.NOT_STARTED,
+    },
+    items: items.map((item) => {
+      if (isGroupItem(item)) {
+        return {
+          kind: "group" as const,
+          id: item.id,
+          label: item.label,
+          guidance: item.guidance,
+          subQuestions: item.subQuestions.map((subQuestion) => ({
+            ...subQuestion,
+            response: toResponseRecord(subQuestion.id),
+            actions: toLinkedActions(subQuestion.id),
+          })),
+        };
+      }
+
+      return {
+        kind: "atomic" as const,
+        item: {
+          ...item,
+          response: toResponseRecord(item.id),
+          actions: toLinkedActions(item.id),
+        },
+      };
+    }),
+  };
+}
+
+export function buildAuditOverview(audit: AuditWithRelations) {
+  const templateSections = parseTemplateSections(audit.template.sections);
+  const profile = audit.premises.profile;
+
+  const sections = audit.sections
+    .map((sectionRecord) => {
+      const templateSection = getTemplateSection(
+        templateSections,
+        sectionRecord.sectionId,
+      );
+
+      if (!templateSection || !profile) {
+        return null;
+      }
+
+      const applicableItems = getApplicableItemsForSection(
+        templateSection,
+        profile,
+      );
+      const answerableItems = getAnswerableItems(applicableItems);
+      const itemCount = answerableItems.length;
+      const applicableIds = new Set(answerableItems.map((item) => item.id));
+      const answeredCount = countCompleteResponses(
+        audit.responses.filter((response) =>
+          applicableIds.has(response.itemId),
+        ),
+        answerableItems,
+      );
+
+      return {
+        id: sectionRecord.sectionId,
+        number: templateSection.number,
+        title: templateSection.title,
+        status: sectionRecord.status,
+        itemCount,
+        answeredCount: Math.min(answeredCount, itemCount),
+      };
+    })
+    .filter((section): section is NonNullable<typeof section> => section !== null)
+    .sort((a, b) => a.number - b.number);
+
+  const completedSections = sections.filter(
+    (section) => section.status === AuditSectionStatus.COMPLETE,
+  ).length;
+
+  return {
+    id: audit.id,
+    status: audit.status,
+    templateVersion: audit.template.version,
+    premises: audit.premises,
+    sections,
+    progress: {
+      completedSections,
+      totalSections: sections.length,
+    },
+  };
+}
diff --git a/lib/auth.ts b/lib/auth.ts
new file mode 100644
index 0000000..795a44d
--- /dev/null
+++ b/lib/auth.ts
@@ -0,0 +1,37 @@
+import { prisma } from "@/lib/prisma";
+
+export type AuthContext = {
+  userId: string;
+  organisationId: string;
+};
+
+/** Development user ID until Supabase Auth is integrated. */
+export const DEV_USER_ID = "dev-user-scoutbase";
+
+/**
+ * Returns the authenticated user's context.
+ * TODO: Replace with Supabase Auth session.
+ */
+export async function getAuthContext(): Promise<AuthContext | null> {
+  const membership = await prisma.membership.findFirst({
+    orderBy: { createdAt: "asc" },
+    select: { userId: true, organisationId: true },
+  });
+
+  if (!membership) {
+    return null;
+  }
+
+  return {
+    userId: membership.userId,
+    organisationId: membership.organisationId,
+  };
+}
+
+export async function requireAuthContext(): Promise<AuthContext> {
+  const context = await getAuthContext();
+  if (!context) {
+    throw new Error("Unauthorized");
+  }
+  return context;
+}
diff --git a/lib/dates.ts b/lib/dates.ts
new file mode 100644
index 0000000..58f9b2e
--- /dev/null
+++ b/lib/dates.ts
@@ -0,0 +1,52 @@
+const INPUT_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+export function isInputDate(value: string): boolean {
+  if (!INPUT_DATE_PATTERN.test(value)) {
+    return false;
+  }
+
+  const [year, month, day] = value.split("-").map(Number);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+
+  return (
+    parsed.getUTCFullYear() === year &&
+    parsed.getUTCMonth() === month - 1 &&
+    parsed.getUTCDate() === day
+  );
+}
+
+export function parseInputDate(value: string): Date | null {
+  if (!isInputDate(value)) {
+    return null;
+  }
+
+  const [year, month, day] = value.split("-").map(Number);
+  return new Date(Date.UTC(year, month - 1, day));
+}
+
+export function formatInputDate(
+  value: Date | string | null | undefined,
+): string {
+  if (!value) {
+    return "";
+  }
+
+  const date = typeof value === "string" ? new Date(value) : value;
+
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+
+  return `${year}-${month}-${day}`;
+}
+
+export function toRecordedDateIso(
+  value: Date | string | null | undefined,
+): string | null {
+  const formatted = formatInputDate(value);
+  return formatted || null;
+}
diff --git a/lib/premises.ts b/lib/premises.ts
new file mode 100644
index 0000000..03e1830
--- /dev/null
+++ b/lib/premises.ts
@@ -0,0 +1,12 @@
+import type { Premises, PremisesProfile } from "@prisma/client";
+import { prisma } from "@/lib/prisma";
+
+export async function getPremisesForOrganisation(
+  premisesId: string,
+  organisationId: string,
+): Promise<(Premises & { profile: PremisesProfile | null }) | null> {
+  return prisma.premises.findFirst({
+    where: { id: premisesId, organisationId },
+    include: { profile: true },
+  });
+}
diff --git a/lib/profile-labels.ts b/lib/profile-labels.ts
new file mode 100644
index 0000000..56a3576
--- /dev/null
+++ b/lib/profile-labels.ts
@@ -0,0 +1,79 @@
+import type {
+  BuildingAgeBand,
+  FloodRiskZone,
+  OwnershipType,
+} from "@prisma/client";
+
+export const OWNERSHIP_LABELS: Record<OwnershipType, string> = {
+  OWNED: "We own the building",
+  LEASED: "We hold a long lease",
+  HIRED: "We hire or share the premises",
+};
+
+export const BUILDING_AGE_LABELS: Record<BuildingAgeBand, string> = {
+  PRE_1985: "Built before 1985",
+  Y1985_2000: "Built between 1985 and 2000",
+  POST_2000: "Built after 2000",
+};
+
+export const FLOOD_RISK_LABELS: Record<FloodRiskZone, string> = {
+  LOW: "Low flood risk",
+  MEDIUM: "Medium flood risk",
+  HIGH: "High flood risk",
+};
+
+export const PROFILE_STEPS = [
+  {
+    id: "building",
+    title: "Your building",
+    description: "Tell us about ownership and when the building was constructed.",
+  },
+  {
+    id: "utilities",
+    title: "Utilities & environment",
+    description: "Gas supply and local flood risk affect which checks apply.",
+  },
+  {
+    id: "facilities",
+    title: "Facilities on site",
+    description: "Kitchens, grounds, and sleeping accommodation change your audit.",
+  },
+  {
+    id: "operations",
+    title: "How the premises is used",
+    description: "Vehicles, machinery, and third-party hire.",
+  },
+  {
+    id: "review",
+    title: "Review & save",
+    description: "Check your answers and see which audit sections will apply.",
+  },
+] as const;
+
+export type ProfileStepId = (typeof PROFILE_STEPS)[number]["id"];
+
+export type ProfileFormData = {
+  ownershipType: OwnershipType | "";
+  buildingAgeBand: BuildingAgeBand | "";
+  hasGas: boolean;
+  floodRiskZone: FloodRiskZone | "" | null;
+  hasCateringKitchen: boolean;
+  hasGrounds: boolean;
+  hasSleeping: boolean;
+  hasVehicles: boolean;
+  hasPlantMachinery: boolean;
+  hasThirdPartyUsers: boolean;
+};
+
+export const EMPTY_PROFILE_FORM: ProfileFormData = {
+  ownershipType: "",
+  buildingAgeBand: "",
+  hasGas: false,
+  floodRiskZone: null,
+  hasCateringKitchen: false,
+  hasGrounds: false,
+  hasSleeping: false,
+  hasVehicles: false,
+  hasPlantMachinery: false,
+  hasThirdPartyUsers: false,
+};
diff --git a/lib/sections.ts b/lib/sections.ts
new file mode 100644
index 0000000..54f5d72
--- /dev/null
+++ b/lib/sections.ts
@@ -0,0 +1,64 @@
+import type { AuditTemplateSection } from "@/types/audit-template";
+import { auditTemplate202509 } from "@/prisma/data/audit-template-normalized";
+import {
+  matchesProfileFlag,
+  type ProfileForSections,
+} from "@/lib/audit-items";
+
+export type { ProfileForSections };
+
+export const AUDIT_SECTION_IDS = auditTemplate202509.map(
+  (section) => section.id,
+) as readonly string[];
+
+export type AuditSectionId = (typeof AUDIT_SECTION_IDS)[number];
+
+export function isLargerPremises(profile: ProfileForSections): boolean {
+  return (
+    profile.hasSleeping ||
+    profile.hasCateringKitchen ||
+    profile.hasGrounds ||
+    profile.hasVehicles ||
+    profile.hasPlantMachinery ||
+    profile.hasThirdPartyUsers
+  );
+}
+
+export function isSectionApplicable(
+  section: AuditTemplateSection,
+  profile: ProfileForSections,
+): boolean {
+  if (section.profileFlag && !matchesProfileFlag(section.profileFlag, profile)) {
+    return false;
+  }
+
+  if (section.scope === "all") {
+    if (section.id === "s7" && profile.buildingAgeBand === "POST_2000") {
+      return false;
+    }
+    return true;
+  }
+
+  if (section.profileFlag) {
+    return matchesProfileFlag(section.profileFlag, profile);
+  }
+
+  return isLargerPremises(profile);
+}
+
+export function computeApplicableSections(
+  profile: ProfileForSections,
+  sections: readonly AuditTemplateSection[] = auditTemplate202509,
+): string[] {
+  return sections
+    .filter((section) => isSectionApplicable(section, profile))
+    .map((section) => section.id);
+}
+
+export function countApplicableSections(profile: ProfileForSections): number {
+  return computeApplicableSections(profile).length;
+}
+
+export function getSectionById(sectionId: string): AuditTemplateSection | undefined {
+  return auditTemplate202509.find((section) => section.id === sectionId);
+}
diff --git a/prisma/data/audit-template-2025-09.ts b/prisma/data/audit-template-2025-09.ts
index d07a645..46985b6 100644
--- a/prisma/data/audit-template-2025-09.ts
+++ b/prisma/data/audit-template-2025-09.ts
@@ -1,883 +1,2197 @@
-import type { AuditTemplateSections } from "@/types/audit-template";
+/**
+ * Audit Template Seed — Scout Association Safe Scouting Premises Audit Tool
+ * Version: September 2025
+ *
+ * Use this as the single source of truth for the AuditTemplate.sections JSON.
+ * Run as a Prisma seed: `npx prisma db seed`
+ *
+ * Item shapes:
+ *   Atomic item  — { id, question, guidance?, responseType, requiresDocument, documentType?, profileFlag? }
+ *   Group item   — { id, label, guidance?, responseType: "GROUP", requiresDocument: false, profileFlag?,
+ *                    subQuestions: [{ id, question, responseType, requiresDocument, documentType? }] }
+ *
+ * ResponseType values:
+ *   YES_NO_NA_ACTION  — yes / no / not-applicable / action-needed
+ *   OPEN_TEXT         — free-text answer
+ *   DATE_UPLOAD       — date + document upload (for certificates / reports)
+ *   GROUP             — parent container; render sub-questions individually
+ *
+ * profileFlag: item shown only when premises profile has that flag = true.
+ *   Flags: hasGas, hasSleeping, hasCateringKitchen, hasGrounds, hasVehicles,
+ *          hasPlantMachinery, hasThirdPartyUsers, floodRisk
+ *
+ * requiresDocument: true → prompt user to upload a file and enter an expiry date.
+ */
+
+export const AUDIT_TEMPLATE_V2025_09 = {
+  version: "2025-09",
+  publishedAt: new Date("2025-09-01"),
+  sections: [
+
+    // ── PART 1: RELEVANT TO ALL PREMISES ──────────────────────────────────────
+
+    {
+      id: "s1",
+      number: 1,
+      title: "Organisation of safety and management",
+      scope: "ALL",
+      items: [
+        {
+          id: "s1-q1",
+          label: "Management committee and trustee responsibilities",
+          guidance: "Consider responsibilities or consequences for both action and inaction.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s1-q1a",
+              question: "Is there a management committee appointed for the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q1b",
+              question: "How often does the committee report to the relevant trustee board?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q1c",
+              question: "How are the trustees made aware of their responsibilities for the management of the premises?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s1-q2",
+          label: "Risk assessments — suitability, sharing and review",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s1-q2a",
+              question: "Are the current premises risk assessments suitable and sufficient?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q2b",
+              question: "How are risk assessments shared with team members and users?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q2c",
+              question: "Are risk assessments reviewed regularly (at least annually)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s1-q3",
+          question: "Are there suitable and sufficient safety Method Statements (operating procedures) for the tasks being carried out?",
+          guidance: "Once completed, all RAMS (Risk Assessments & Method Statements) need to be easily accessible to staff and compliance with these monitored.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s1-q4",
+          question: "How and where are records for maintenance or compliance checks stored?",
+          guidance: "Make sure these are accessible for future reference and for changes in trustees.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s1-q5",
+          question: "Is appropriate signage and other controls in place as identified through risk assessments?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s1-q6",
+          label: "Accessibility assessment and adjustments",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s1-q6a",
+              question: "What assessment has been made of the site for those with additional needs?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q6b",
+              question: "What reasonable adjustments have been put in place to assist those needs?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s1-q7",
+          label: "Notice board / safety signage",
+          guidance: "Should include: Yellow Card, Alcohol & Drug guidance, Gas Safety, Carbon Monoxide poster, Fire Evacuation Procedures, Good Hygiene, Food Hygiene, and other safety information.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s1-q7a",
+              question: "Is there a notice board or visible signage on the premises for both visitors and staff/volunteers to see?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s1-q7b",
+              question: "Are the notices regularly checked to ensure they are current?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s1-q8",
+          question: "What guidance and controls are in place for lone working for volunteers or visitors?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s2",
+      number: 2,
+      title: "Monitoring and Incident Reporting",
+      scope: "ALL",
+      items: [
+        {
+          id: "s2-q1",
+          question: "Are incidents and near misses recorded and reported appropriately — including RIDDOR where required?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s2-q2",
+          question: "How are trustees monitoring that processes are being followed, adequate records are being kept, and incidents are being reviewed?",
+          guidance: "See learning review guidance on the Scout website.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s2-q3",
+          question: "Do volunteers understand when incidents need to be reported and where to report them?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s3",
+      number: 3,
+      title: "Fire",
+      scope: "ALL",
+      items: [
+        {
+          id: "s3-q1",
+          label: "Fire Risk Assessment",
+          guidance: "Outstanding actions identified in the Fire RA should be recorded as actions.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q1a",
+              question: "Is a Fire Risk Assessment in place and completed by a competent person?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "FIRE_RA",
+            },
+            {
+              id: "s3-q1b",
+              question: "When was the Fire Risk Assessment last reviewed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q1c",
+              question: "Who carried out the most recent Fire Risk Assessment review?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q2",
+          label: "FRA shared with trustees and sufficiency",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q2a",
+              question: "Has the Fire Risk Assessment been shared with the Trustees?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q2b",
+              question: "Is the Fire Risk Assessment considered sufficient?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q3",
+          label: "Fire alarm system",
+          guidance: "Best practice is to test alarms weekly.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q3a",
+              question: "Are fire alarms installed, and what type are they?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q3b",
+              question: "Are smoke and/or heat detectors present?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q3c",
+              question: "Are manual call points (break-glass) present?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q3d",
+              question: "What is the testing and recording regime for the fire alarm system?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q4",
+          question: "Is the fire alarm system suitable for use when people are sleeping in the building (e.g. an automated L2 system)?",
+          guidance: "An automated alarm system (L2) should be in place where sleeping accommodation is provided.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+          profileFlag: "hasSleeping",
+        },
+        {
+          id: "s3-q5",
+          question: "Are there any additional fire safety measures put in place specifically for sleepovers?",
+          guidance: "Where sleeping is not the building's primary purpose, additional temporary measures should be considered.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+          profileFlag: "hasSleeping",
+        },
+        {
+          id: "s3-q6",
+          label: "Smoke detectors and CO monitors",
+          guidance: "Best practice is to test alarms weekly.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q6a",
+              question: "Are smoke detectors and carbon monoxide monitors in good working order and covering all hazardous zones?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q6b",
+              question: "What is the testing regime for smoke detectors and CO monitors?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q7",
+          label: "Fire extinguishers",
+          guidance: "A regular visual check by a team member as well as annual servicing is good practice.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q7a",
+              question: "Are fire extinguishers in good working order with a current service record?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "FIRE_EXTINGUISHER",
+            },
+            {
+              id: "s3-q7b",
+              question: "Are extinguishers appropriately fixed in position with correct signage?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q8",
+          question: "Is there safe access and egress from the building (able to get out quickly in an emergency)?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s3-q9",
+          label: "Emergency lighting — suitability",
+          guidance: "Any remedial actions identified in last inspection should be recorded.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q9a",
+              question: "Is the emergency lighting suitable and sufficient?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q9b",
+              question: "Does it illuminate all evacuation routes and emergency exits?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q10",
+          label: "Emergency lighting — testing regime",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q10a",
+              question: "Daily — is the visual indicator light checked to confirm the system is healthy?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q10b",
+              question: "Monthly — is a 1-minute function test carried out and recorded?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q10c",
+              question: "Annually — is a full test carried out, checking visibility of lighting, signage and fire exit routes, by a competent person?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "EMERGENCY_LIGHTING",
+            },
+            {
+              id: "s3-q10d",
+              question: "Have any remedial actions identified through testing been completed?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q11",
+          question: "If there is no automatic emergency lighting, how are users guided to emergency routes?",
+          guidance: "E.g. glow-in-the-dark signs, torches.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s3-q12",
+          question: "When was the last evacuation drill carried out?",
+          guidance: "Sections are advised to practice this each term. All unplanned evacuations/alarms should also be recorded.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s3-q13",
+          question: "What Personal Emergency Evacuation Plans (PEEPs) are in place for those with accessible needs?",
+          guidance: "An example PEEP can be found on the Scout website.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s3-q14",
+          label: "Fire doors",
+          guidance: "Fire doors protect areas from high-risk fire spread, e.g. a boiler room door in a fire escape corridor.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s3-q14a",
+              question: "Is there a register of all fire doors on the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q14b",
+              question: "How often are fire doors inspected, when was the last inspection, and who carried it out?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s3-q14c",
+              question: "What remedial actions have been identified and completed following fire door inspections?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s3-q15",
+          question: "Are door closers fitted to control the speed and weight of closing?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s3-q16",
+          question: "Are door finger guards fitted to protect hands from the hinged gap?",
+          guidance: "Make teams aware of the risks from trapped fingers.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s4",
+      number: 4,
+      title: "Emergency Procedures",
+      scope: "ALL",
+      items: [
+        {
+          id: "s4-q1",
+          question: "Are there documented procedures for the management of foreseeable emergencies, including fire, working at height, confined spaces, loss of services, and flooding?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s5",
+      number: 5,
+      title: "Electrical",
+      scope: "ALL",
+      items: [
+        {
+          id: "s5-q1",
+          label: "PAT and fixed electrical testing",
+          guidance: "Any remedial actions identified in last inspection should be recorded.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s5-q1a",
+              question: "When was portable appliance testing (PAT) last completed?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "PAT",
+            },
+            {
+              id: "s5-q1b",
+              question: "When was the Fixed Electrical Installation Condition Report (EICR) last completed?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "EICR",
+            },
+            {
+              id: "s5-q1c",
+              question: "Have any remedial works identified from these tests been completed?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s5-q2",
+          label: "Electrical boards and cupboards",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s5-q2a",
+              question: "Are electrical boards and cupboards secure with access restricted?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s5-q2b",
+              question: "Have electrical boards been included in the EICR inspection?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s5-q3",
+          question: "Are wall sockets flush to the wall, screwed in well, and with casing in good condition?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s5-q4",
+          label: "General lighting",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s5-q4a",
+              question: "Is general lighting working inside the building?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s5-q4b",
+              question: "Is external and security lighting working?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s5-q4c",
+              question: "Is all lighting suitable and sufficient for its purpose?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s5-q5",
+          question: "Where lightning protection is installed, has it had its annual inspection and certification?",
+          guidance: null,
+          responseType: "DATE_UPLOAD",
+          requiresDocument: true,
+          documentType: "OTHER",
+        },
+      ],
+    },
+
+    {
+      id: "s6",
+      number: 6,
+      title: "Gas",
+      scope: "ALL",
+      profileFlag: "hasGas",
+      items: [
+        {
+          id: "s6-q1",
+          question: "Have all gas appliances been serviced as required by a Gas Safe registered contractor? Provide a list of all appliances with check dates.",
+          guidance: "Note name of Gas Safe contractor used.",
+          responseType: "DATE_UPLOAD",
+          requiresDocument: true,
+          documentType: "GAS_SAFE",
+        },
+        {
+          id: "s6-q2",
+          question: "Are interlocks in place between cooker, extractors and alarm?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+          profileFlag: "hasCateringKitchen",
+        },
+        {
+          id: "s6-q3",
+          label: "Carbon monoxide monitors and chimneys",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s6-q3a",
+              question: "Are carbon monoxide monitors and alarms fitted and regularly checked?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s6-q3b",
+              question: "If fireplaces are present, have the chimneys been swept recently?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s6-q4",
+          question: "When did extraction units and cooker hoods last receive annual independent inspection and cleaning?",
+          guidance: "Any remedial actions identified in last inspection should be recorded.",
+          responseType: "DATE_UPLOAD",
+          requiresDocument: false,
+          profileFlag: "hasCateringKitchen",
+        },
+        {
+          id: "s6-q5",
+          label: "Bulk gas",
+          guidance: "Record who carried out the checks.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s6-q5a",
+              question: "Is bulk gas stored or used on this site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s6-q5b",
+              question: "When was the bulk gas installation last checked for compliance, and by whom?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s6-q6",
+          label: "Bottled gas storage",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s6-q6a",
+              question: "Is bottled gas stored on site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s6-q6b",
+              question: "How is it stored safely (e.g. locked exterior cage, upright and secured)?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s7",
+      number: 7,
+      title: "Asbestos Management",
+      scope: "ALL",
+      items: [
+        {
+          id: "s7-q1",
+          label: "Asbestos survey",
+          guidance: "How is the survey accessible to the trustees?",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s7-q1a",
+              question: "Has an asbestos survey been carried out for the site?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "ASBESTOS",
+            },
+            {
+              id: "s7-q1b",
+              question: "How is the asbestos survey made accessible to trustees and future maintainers?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s7-q2",
+          label: "Asbestos Management Plan",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s7-q2a",
+              question: "What is the date of the current Asbestos Management Plan (AMP)?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s7-q2b",
+              question: "When was the AMP last reviewed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s7-q3",
+          label: "Asbestos inspections",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s7-q3a",
+              question: "Have regular inspections of identified asbestos been carried out?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s7-q3b",
+              question: "How are asbestos inspection records kept and stored?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s8",
+      number: 8,
+      title: "Water Quality (Legionella)",
+      scope: "ALL",
+      items: [
+        {
+          id: "s8-q1",
+          label: "Legionella Management Plan and risk assessment",
+          guidance: "Recommended every 2 years for more complex water systems. HSE guidance — ACOP L8 + HSG274.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s8-q1a",
+              question: "Is there a Legionella Management Plan (LMP) in place?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s8-q1b",
+              question: "When was the last Water Quality Risk Assessment completed?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "LEGIONELLA",
+            },
+          ],
+        },
+        {
+          id: "s8-q2",
+          label: "Legionella checks — routine monitoring",
+          guidance: "An example LMP is available on the Scout website. Section 6.0 gives the full list of checks required.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s8-q2a",
+              question: "Weekly — are all taps, showers and standpipes flushed as required?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s8-q2b",
+              question: "Monthly — are temperature checks carried out at sentinel outlets?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s8-q2c",
+              question: "Quarterly — are shower heads cleaned and descaled?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s8-q2d",
+              question: "Annually — are all outlets checked?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s8-q2e",
+              question: "How are all Legionella monitoring checks recorded?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s9",
+      number: 9,
+      title: "Use by third parties",
+      scope: "ALL",
+      items: [
+        {
+          id: "s9-q1",
+          question: "Do other groups or third parties also use the site?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s9-q2",
+          question: "What naturally occurring hazards on the site do visitors need to be made aware of?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s9-q3",
+          question: "Are there maintenance tasks being carried out that could affect visitors or others in your area of operation?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s9-q4",
+          question: "What Scout activities at the premises may present a hazard to visitors or others not actively involved (e.g. pioneering structures, climbing equipment, campfires)?",
+          guidance: "E.g. pioneering structures disassembled after session; climbing equipment returned to locked storage; campfires doused and checked before leaving.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s9-q5",
+          question: "What controls are in place to remove or reduce risks to other users and casual visitors?",
+          guidance: "Are necessary signage or barriers in place?",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s10",
+      number: 10,
+      title: "Access to the premises",
+      scope: "ALL",
+      items: [
+        {
+          id: "s10-q1",
+          question: "How is access to the premises controlled for both pedestrians and vehicles?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s10-q2",
+          question: "How do you know who is on the premises at any point in time?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s10-q3",
+          label: "Public access",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s10-q3a",
+              question: "Is there public access to the site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s10-q3b",
+              question: "How is public access managed when no representative is on site?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s10-q4",
+          label: "CCTV",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s10-q4a",
+              question: "Is CCTV installed on the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s10-q4b",
+              question: "How is CCTV managed (data retention, access controls, GDPR compliance)?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s10-q5",
+          label: "Paths and access routes",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s10-q5a",
+              question: "What condition are the paths and access roads in, and what regular checks are made?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s10-q5b",
+              question: "Do they present any risk of hazard or damage to pedestrians or vehicles?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s10-q5c",
+              question: "Is there adequate lighting for paths and access routes?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s10-q6",
+          question: "Are there any parts of the site that are derelict or hidden away? Consider physical dangers and unseen spaces for inappropriate behaviour (e.g. drugs, alcohol, safeguarding issues).",
+          guidance: "Consider fencing, signage and regular checks for these areas.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s10-q7",
+          label: "Disability access",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s10-q7a",
+              question: "Is there disability access to the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s10-q7b",
+              question: "How often is disability access checked to ensure it remains fit for use?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s11",
+      number: 11,
+      title: "Chemicals and hazardous substances (COSHH)",
+      scope: "ALL",
+      items: [
+        {
+          id: "s11-q1",
+          question: "What chemicals or hazardous substances are present on the premises?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s11-q2",
+          question: "How and where are hazardous substances stored securely and appropriately?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s11-q3",
+          label: "Material Safety Data Sheets",
+          guidance: "Domestic products may have the necessary information on the label.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s11-q3a",
+              question: "Are Material Safety Data Sheets (SDS) available for all chemicals on site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s11-q3b",
+              question: "When were the data sheets last reviewed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s11-q4",
+          label: "COSHH Risk Assessments",
+          guidance: "Domestic products may have the necessary information on the label.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s11-q4a",
+              question: "Have COSHH Risk Assessments been produced for all hazardous substances in use?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s11-q4b",
+              question: "Have these assessments been made available to staff and users?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s11-q4c",
+              question: "When were the COSHH assessments last reviewed, and by whom?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s12",
+      number: 12,
+      title: "Equipment",
+      scope: "ALL",
+      items: [
+        {
+          id: "s12-q1",
+          question: "Has camping and Group-type equipment been checked and serviced for safety issues (e.g. gas or petrol stoves, lamps)?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s12-q2",
+          question: "Who oversees and maintains this equipment?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s12-q3",
+          question: "How is equipment safely stored?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s12-q4",
+          label: "Equipment inventory",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s12-q4a",
+              question: "Is there an inventory of all equipment and tools?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s12-q4b",
+              question: "Who maintains the inventory and how often is it updated?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s12-q5",
+          label: "Equipment servicing and external inspection",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s12-q5a",
+              question: "Has all equipment been regularly serviced and maintained in accordance with manufacturer's recommendations?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s12-q5b",
+              question: "Does any equipment require external or statutory inspection, and if so is this up to date?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s12-q6",
+          label: "Pioneering equipment",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s12-q6a",
+              question: "Do you have pioneering equipment (ropes, spars, lashings, etc.)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s12-q6b",
+              question: "Is the pioneering equipment in safe condition?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s12-q6c",
+              question: "Are there suitable and safe areas designated for its use?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s13",
+      number: 13,
+      title: "Flood Risk",
+      scope: "ALL",
+      items: [
+        {
+          id: "s13-q1",
+          question: "Are you aware of the flood risk for your property (surface water, river, sea)?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s13-q2",
+          question: "If your property has a medium or higher flood risk, do you have a flood risk management plan in place?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+          profileFlag: "floodRisk",
+        },
+        {
+          id: "s13-q3",
+          question: "Is your property insurer aware of the flooding risk?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+          profileFlag: "floodRisk",
+        },
+      ],
+    },
+
+    // ── PART 2: LARGER PREMISES, CAMPSITES AND ACTIVITY CENTRES ──────────────
+
+    {
+      id: "s14",
+      number: 14,
+      title: "Staff and volunteers",
+      scope: "EXTENDED",
+      subsections: [
+        {
+          id: "s14a",
+          title: "Staff and volunteers — general",
+          items: [
+            {
+              id: "s14-q1",
+              question: "Are there paid staff employed or used at the premises?",
+              guidance: "E.g. part-time cleaners or activity staff.",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s14-q2",
+              question: "Is there a process in place for the recruitment of staff and volunteers, and is this being followed consistently?",
+              guidance: null,
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s14-q3",
+              question: "Have appropriate vetting and disclosure checks been undertaken on those involved at the premises?",
+              guidance: null,
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s14-q4",
+              label: "Membership system records",
+              guidance: null,
+              responseType: "GROUP",
+              requiresDocument: false,
+              subQuestions: [
+                {
+                  id: "s14-q4a",
+                  question: "Are all staff and volunteers with premises roles recorded on the national membership system?",
+                  responseType: "YES_NO_NA_ACTION",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q4b",
+                  question: "How is this managed and kept up to date when people join or leave?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+              ],
+            },
+            {
+              id: "s14-q5",
+              label: "Staff and volunteer policies",
+              guidance: "Policies should cover: Yellow Card (safeguarding), Code of conduct, Alcohol & Drugs, Accommodation use, Manager reviews, Concern reporting, Dress code, Site sign-in, Lone working, Health & Safety.",
+              responseType: "GROUP",
+              requiresDocument: false,
+              subQuestions: [
+                {
+                  id: "s14-q5a",
+                  question: "Are the required policies in place for staff and volunteers (Yellow Card, Code of Conduct, Alcohol & Drugs, Lone Working, H&S, etc.)?",
+                  responseType: "YES_NO_NA_ACTION",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q5b",
+                  question: "Are these policies regularly reviewed and readily available to all staff and volunteers?",
+                  responseType: "YES_NO_NA_ACTION",
+                  requiresDocument: false,
+                },
+              ],
+            },
+            {
+              id: "s14-q6",
+              label: "Training and competency",
+              guidance: "Training areas: Safeguarding, Safety, First Aid, GDPR, activity-specific, maintenance-specific.",
+              responseType: "GROUP",
+              requiresDocument: false,
+              subQuestions: [
+                {
+                  id: "s14-q6a",
+                  question: "What training is provided for staff and volunteers (Safeguarding, Safety, First Aid, GDPR, activity-specific, maintenance-specific)?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q6b",
+                  question: "How is training recorded?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q6c",
+                  question: "How is ongoing competency monitored, and by whom?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+              ],
+            },
+            {
+              id: "s14-q7",
+              label: "Safety induction",
+              guidance: null,
+              responseType: "GROUP",
+              requiresDocument: false,
+              subQuestions: [
+                {
+                  id: "s14-q7a",
+                  question: "What safety induction is provided when staff or volunteers take up a new role?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q7b",
+                  question: "Is the induction suitable and sufficient?",
+                  responseType: "YES_NO_NA_ACTION",
+                  requiresDocument: false,
+                },
+              ],
+            },
+            {
+              id: "s14-q8",
+              question: "Are staff and volunteers easily recognisable to visitors and each other?",
+              guidance: null,
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s14-q9",
+              question: "How are language barriers managed for vital communications?",
+              guidance: "Pictograms can be used to help.",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s14b",
+          title: "Staff and volunteer accommodation",
+          items: [
+            {
+              id: "s14-q10",
+              label: "Staff area boundaries and under-18 accommodation",
+              guidance: "Safeguarding Code of Practice: provide separate sleeping accommodation for young people, adults and Young Leaders working with a younger section.",
+              responseType: "GROUP",
+              requiresDocument: false,
+              profileFlag: "hasSleeping",
+              subQuestions: [
+                {
+                  id: "s14-q10a",
+                  question: "What clear boundaries are in place for staff-only areas, for both welfare and safeguarding?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+                {
+                  id: "s14-q10b",
+                  question: "How is separate sleeping accommodation provided for those under 18 who are supporting the premises?",
+                  responseType: "OPEN_TEXT",
+                  requiresDocument: false,
+                },
+              ],
+            },
+            {
+              id: "s14-q11",
+              question: "How are checks on upkeep, welfare and appropriate behaviour of staff in accommodation monitored and managed?",
+              guidance: null,
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+              profileFlag: "hasSleeping",
+            },
+          ],
+        },
+      ],
+      items: [],
+    },
+
+    {
+      id: "s15",
+      number: 15,
+      title: "Guests and visitors",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s15-q1",
+          question: "How do visiting groups notify the centre of changes in numbers and participants?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s15-q2",
+          question: "What checks are carried out on visitors during their stay to ensure their comfort and safety?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s15-q3",
+          label: "Visitor checkout",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s15-q3a",
+              question: "What process is in place for visiting groups to check out?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s15-q3b",
+              question: "How do you confirm that all visitors have left the site?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s15-q4",
+          question: "Is there a written record and agreement in place with users of the premises?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s15-q5",
+          question: "How do staff and volunteers observe and report concerns about visitor behaviour — including alcohol and drugs, young people's welfare, safeguarding, safe activities, supervision during free time, and inappropriate photography?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s15-q6",
+          label: "Non-Scout user safeguarding",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s15-q6a",
+              question: "How are non-Scout users made aware of the procedures for reporting incidents and safeguarding concerns?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s15-q6b",
+              question: "What safeguarding arrangements do non-Scout users have in place themselves?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s15-q7",
+          label: "Bunk beds",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          profileFlag: "hasSleeping",
+          subQuestions: [
+            {
+              id: "s15-q7a",
+              question: "Is guidance provided to users on bunk bed safety risks?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s15-q7b",
+              question: "Is the ladder fixed securely to the bed frame?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s15-q7c",
+              question: "Is there at least 760mm clearance between the top bunk mattress and the ceiling?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s15-q7d",
+              question: "Are all bunk bed gaps between 60mm and 75mm (no entrapment risk from gaps outside this range)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s16",
+      number: 16,
+      title: "First Aid",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s16-q1",
+          label: "First aid cover and equipment",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s16-q1a",
+              question: "Is there adequate trained first aid cover during activities?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s16-q1b",
+              question: "What first aid equipment is available on site?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s16-q1c",
+              question: "What process is in place to regularly check and restock first aid equipment?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s16-q2",
+          label: "AED, trauma, bleed and anaphylaxis kits",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s16-q2a",
+              question: "Is there a Defibrillator (AED), trauma kit, bleed kit and/or anaphylaxis kit on site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s16-q2b",
+              question: "What process is in place to regularly check and maintain these items?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s16-q3",
+          question: "How are sharp objects and large amounts of medical waste disposed of?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s17",
+      number: 17,
+      title: "Contractor management",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s17-q1",
+          label: "Contractor competency, induction and documentation",
+          guidance: "Competency evidence: references, qualifications, professional memberships.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s17-q1a",
+              question: "How are contractor competencies assessed before work begins?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s17-q1b",
+              question: "Are contractor inductions carried out and recorded?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s17-q1c",
+              question: "Has the Yellow Card (safeguarding procedures) been shared with contractors?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s17-q1d",
+              question: "What documentation is kept to evidence competency checks and inductions?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s17-q2",
+          question: "How are contractors effectively and safely managed whilst on site?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s17-q3",
+          question: "Are Risk Assessments and Method Statements (RAMS) from contractors suitable and sufficient?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s17-q4",
+          question: "Are Permit to Work requirements in place and being observed and recorded?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s18",
+      number: 18,
+      title: "Work at Height",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s18-q1",
+          label: "Falls from height and confined spaces",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s18-q1a",
+              question: "What areas on the site present a risk of falls from height (activities, roof, storage, etc.)?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s18-q1b",
+              question: "How are these fall-from-height risks managed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s18-q1c",
+              question: "Are there any below-ground areas or confined spaces, and how are these managed?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s18-q2",
+          label: "Scaffolding",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s18-q2a",
+              question: "Are there any scaffolding structures on site (permanent or temporary)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s18-q2b",
+              question: "What inspection regime is in place for scaffolding?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s18-q2c",
+              question: "What measures are in place to prevent unauthorised access or climbing on scaffolding?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s19",
+      number: 19,
+      title: "Manual Handling",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s19-q1",
+          question: "Have staff and volunteers received appropriate manual handling training for their tasks?",
+          guidance: "Those involved in regular handling activity should receive refresher training from time to time.",
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s19-q2",
+          question: "How have local handling risks (particularly in storage areas) been identified and what controls put in place?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s19-q3",
+          question: "Is there suitable and sufficient equipment to assist with safe handling?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s20",
+      number: 20,
+      title: "Catering",
+      scope: "EXTENDED",
+      profileFlag: "hasCateringKitchen",
+      items: [
+        {
+          id: "s20-q1",
+          question: "What food safety control systems are in place, and are these in line with relevant regulations?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s20-q2",
+          question: "What food safety and hygiene training has been received by staff?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s21",
+      number: 21,
+      title: "Housekeeping & General Site",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s21-q1",
+          label: "Waste management and pest control",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s21-q1a",
+              question: "Is the site tidy and free from waste and rubbish?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q1b",
+              question: "Is there a documented process for waste disposal?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q1c",
+              question: "Is an appropriate pest control system in place with records?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s21-q2",
+          question: "Is there a significant risk from items, equipment or locations that may cause slips, trips or falls?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s21-q3",
+          label: "Loft hatches",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s21-q3a",
+              question: "Are there any loft hatches on the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q3b",
+              question: "What is the process for safe use of loft hatches?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q3c",
+              question: "How are loft hatches secured when not in use to prevent unplanned access?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s21-q4",
+          question: "Are materials stored in a safe and appropriate manner?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+        {
+          id: "s21-q5",
+          label: "Workstation assessments (DSE)",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s21-q5a",
+              question: "Have Workstation Assessments been carried out for regular computer/display screen users?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q5b",
+              question: "Have any remedial actions from these assessments been completed?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s21-q6",
+          question: "What processes are in place for lone working or remote working?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s21-q7",
+          label: "Site plans",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s21-q7a",
+              question: "Are site plans available for the premises?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s21-q7b",
+              question: "Do the site plans show underground and overhead services (gas, electric, water, drainage)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s22",
+      number: 22,
+      title: "Plant, Machinery & Equipment",
+      scope: "EXTENDED",
+      profileFlag: "hasPlantMachinery",
+      items: [
+        {
+          id: "s22-q1",
+          label: "Racking and storage",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s22-q1a",
+              question: "Is racking and storage safe for use?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q1b",
+              question: "Is racking and storage regularly inspected and the results recorded?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s22-q2",
+          label: "Plant and machinery servicing and statutory inspection",
+          guidance: "Use stickers to show service dates.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s22-q2a",
+              question: "Has all plant and machinery been regularly serviced per manufacturer's recommendations?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q2b",
+              question: "Does any equipment require statutory external inspection (e.g. under LOLER or PUWER)?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q2c",
+              question: "If so, are these inspection processes in place and up to date?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s22-q3",
+          label: "Ladder register and inspections",
+          guidance: "Mark ladders with a unique ID to correspond to the register.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s22-q3a",
+              question: "Are all ladders listed on a Ladder Register with unique IDs?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q3b",
+              question: "How are pre-use checks and periodic ladder inspections managed and recorded?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s22-q4",
+          label: "Activities area and playground",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s22-q4a",
+              question: "Do you have an activities area or playground?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q4b",
+              question: "What checking and maintenance plan is in place for activities or play equipment?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q4c",
+              question: "Is access to the equipment controlled when not in supervised use?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s22-q4d",
+              question: "How is supervision of users of the activities area managed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s23",
+      number: 23,
+      title: "Vehicles",
+      scope: "EXTENDED",
+      profileFlag: "hasVehicles",
+      items: [
+        {
+          id: "s23-q1",
+          label: "Vehicle and trailer maintenance",
+          guidance: "Driving licence checks should be carried out on those driving on behalf of the site.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s23-q1a",
+              question: "Is there documentary proof that site vehicles and minibuses have been properly maintained?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: true,
+              documentType: "OTHER",
+            },
+            {
+              id: "s23-q1b",
+              question: "Have all trailers been regularly serviced and inspected?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s23-q2",
+          question: "How up to date is the list of those authorised to operate restricted vehicles?",
+          guidance: "This process needs to be robust with a way of confirming who has been checked.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s23-q3",
+          question: "What controls are in place to ensure the safe movement of vehicles on the site?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s24",
+      number: 24,
+      title: "Protective equipment (PPE)",
+      scope: "EXTENDED",
+      items: [
+        {
+          id: "s24-q1",
+          question: "What Personal Protective Equipment (PPE) is provided for maintenance tasks?",
+          guidance: "Tasks requiring PPE should be identified by the risk assessment.",
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+        {
+          id: "s24-q2",
+          label: "PPE condition, storage and fit",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s24-q2a",
+              question: "Is all PPE in usable condition?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s24-q2b",
+              question: "Is PPE stored appropriately when not in use?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s24-q2c",
+              question: "Is the PPE suitable and sufficient for the identified risks?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s24-q2d",
+              question: "Does the PPE fit its users properly?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s24-q3",
+          question: "Have users been properly trained in how to use their PPE?",
+          guidance: null,
+          responseType: "YES_NO_NA_ACTION",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+    {
+      id: "s25",
+      number: 25,
+      title: "Trees and grounds management",
+      scope: "EXTENDED",
+      profileFlag: "hasGrounds",
+      items: [
+        {
+          id: "s25-q1",
+          label: "Tree surveys and grounds management procedure",
+          guidance: "Any remedial actions identified in last inspection should be recorded.",
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s25-q1a",
+              question: "When was the last tree survey carried out on site?",
+              responseType: "DATE_UPLOAD",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q1b",
+              question: "Where are tree survey records stored and how are they accessible to trustees?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q1c",
+              question: "Are trees maintained so they pose no risk of encroachment on or damage to roads, paths or buildings?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q1d",
+              question: "Is there a documented grounds management procedure covering the use of machinery, pesticides and herbicides?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s25-q2",
+          label: "Invasive Non-Native Species (INNS)",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s25-q2a",
+              question: "Is there any Invasive Non-Native Species (INNS) present on site?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q2b",
+              question: "If so, is there a management plan in place for the INNS?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+          ],
+        },
+        {
+          id: "s25-q3",
+          label: "Grounds flooding",
+          guidance: null,
+          responseType: "GROUP",
+          requiresDocument: false,
+          subQuestions: [
+            {
+              id: "s25-q3a",
+              question: "Are any areas of the grounds prone to localised flooding?",
+              responseType: "YES_NO_NA_ACTION",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q3b",
+              question: "How is localised flooding managed?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+            {
+              id: "s25-q3c",
+              question: "How are visiting groups notified about flood-prone areas before their visit?",
+              responseType: "OPEN_TEXT",
+              requiresDocument: false,
+            },
+          ],
+        },
+      ],
+    },
+
+    {
+      id: "s26",
+      number: 26,
+      title: "And finally...",
+      scope: "ALL",
+      items: [
+        {
+          id: "s26-q1",
+          question: "Are there any other features or practices on site not covered above that should be included in this and future audits?",
+          guidance: null,
+          responseType: "OPEN_TEXT",
+          requiresDocument: false,
+        },
+      ],
+    },
+
+  ],
+} as const;
 
 /**
- * Annual safety audit template v2025-09.
- * 25 sections, ~100 check items for UK Scout hut premises.
+ * Acronyms used in this template:
+ * AED     — Automated External Defibrillator
+ * AMP     — Asbestos Management Plan
+ * COSHH   — Control of Substances Hazardous to Health
+ * DSE     — Display Screen Equipment
+ * EICR    — Electrical Installation Condition Report
+ * FRA     — Fire Risk Assessment
+ * INNS    — Invasive Non-Native Species
+ * LMP     — Legionella Management Plan
+ * LOLER   — Lifting Operations & Lifting Equipment Regulations
+ * PAT     — Portable Appliance Testing
+ * PEEP    — Personal Emergency Evacuation Plan
+ * PPE     — Personal Protective Equipment
+ * PUWER   — Provision & Use of Work Equipment Regulations
+ * RAMS    — Risk Assessments & Method Statements
+ * RIDDOR  — Reporting of Injuries, Diseases and Dangerous Occurrences Regulations
+ * SDS     — Safety Data Sheet (formerly MSDS)
  */
-export const auditTemplate202509: AuditTemplateSections = [
-  {
-    id: "governance",
-    number: 1,
-    title: "Governance and documentation",
-    items: [
-      {
-        id: "gov-1",
-        question: "Is there a current premises management plan?",
-        guidance: "Check for a written plan covering maintenance, inspections, and responsibilities.",
-        responseType: "yes_no_na_action",
-        tags: ["governance"],
-      },
-      {
-        id: "gov-2",
-        question: "Are trustee meeting minutes available for the last 12 months?",
-        guidance: "Minutes should record premises-related decisions and actions.",
-        responseType: "yes_no_na_action",
-        tags: ["governance"],
-      },
-      {
-        id: "gov-3",
-        question: "Is premises insurance current and adequate?",
-        guidance: "Verify policy covers buildings, contents, and public liability.",
-        responseType: "yes_no_na_action",
-        tags: ["governance", "insurance"],
-      },
-      {
-        id: "gov-4",
-        question: "Is there a designated premises manager with documented responsibilities?",
-        guidance: "Role should be assigned and communicated to the trustee board.",
-        responseType: "yes_no_na_action",
-        tags: ["governance"],
-      },
-    ],
-  },
-  {
-    id: "fire-general",
-    number: 2,
-    title: "Fire safety — general",
-    items: [
-      {
-        id: "fire-1",
-        question: "Is a current fire risk assessment available?",
-        guidance: "FRA should be reviewed annually or after significant changes.",
-        responseType: "yes_no_na_action",
-        tags: ["fire"],
-      },
-      {
-        id: "fire-2",
-        question: "Are fire escape routes clearly marked and unobstructed?",
-        guidance: "Check all exit routes during a walk-through.",
-        responseType: "yes_no_na_action",
-        tags: ["fire"],
-      },
-      {
-        id: "fire-3",
-        question: "Are fire doors self-closing and in good condition?",
-        guidance: "Do not wedge fire doors open. Check seals and closers.",
-        responseType: "yes_no_na_action",
-        tags: ["fire"],
-      },
-      {
-        id: "fire-4",
-        question: "Is the fire assembly point clearly signed and accessible?",
-        guidance: "Assembly point should be away from the building and known to leaders.",
-        responseType: "yes_no_na_action",
-        tags: ["fire"],
-      },
-    ],
-  },
-  {
-    id: "fire-sleeping",
-    number: 3,
-    title: "Fire safety — sleeping accommodation",
-    items: [
-      {
-        id: "fire-slp-1",
-        question: "Are sleeping areas excluded from the audit premises profile if not applicable?",
-        guidance: "This section applies only when hasSleeping is true on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["fire", "sleeping", "profile:hasSleeping"],
-      },
-      {
-        id: "fire-slp-2",
-        question: "Are smoke detectors installed in all sleeping areas?",
-        guidance: "Mains-wired with battery backup is preferred for sleeping accommodation.",
-        responseType: "yes_no_na_action",
-        tags: ["fire", "sleeping", "profile:hasSleeping"],
-      },
-      {
-        id: "fire-slp-3",
-        question: "Is a night-time evacuation plan documented and practised?",
-        guidance: "Include roles for waking young people and accounting for all occupants.",
-        responseType: "yes_no_na_action",
-        tags: ["fire", "sleeping", "profile:hasSleeping"],
-      },
-      {
-        id: "fire-slp-4",
-        question: "Are portable heaters prohibited in sleeping areas?",
-        guidance: "Fixed heating only in sleeping accommodation.",
-        responseType: "yes_no_na_action",
-        tags: ["fire", "sleeping", "profile:hasSleeping"],
-      },
-    ],
-  },
-  {
-    id: "electrical",
-    number: 4,
-    title: "Electrical safety",
-    items: [
-      {
-        id: "elec-1",
-        question: "Is there a current EICR (Electrical Installation Condition Report)?",
-        guidance: "EICR should be within its validity period (typically 5 years).",
-        responseType: "yes_no_na_action",
-        tags: ["electrical", "eicr"],
-      },
-      {
-        id: "elec-2",
-        question: "Is PAT testing up to date for portable appliances?",
-        guidance: "Check PAT labels and test records for all portable equipment.",
-        responseType: "yes_no_na_action",
-        tags: ["electrical", "pat"],
-      },
-      {
-        id: "elec-3",
-        question: "Are consumer units and distribution boards accessible and labelled?",
-        guidance: "No obstructions; circuits should be labelled.",
-        responseType: "yes_no_na_action",
-        tags: ["electrical"],
-      },
-      {
-        id: "elec-4",
-        question: "Are extension leads and multi-way adapters used safely?",
-        guidance: "No daisy-chaining; avoid overload.",
-        responseType: "yes_no_na_action",
-        tags: ["electrical"],
-      },
-    ],
-  },
-  {
-    id: "gas",
-    number: 5,
-    title: "Gas safety",
-    items: [
-      {
-        id: "gas-1",
-        question: "Does this premises have gas installations?",
-        guidance: "Skip if hasGas is false on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["gas", "profile:hasGas"],
-      },
-      {
-        id: "gas-2",
-        question: "Is there a current Gas Safe certificate?",
-        guidance: "Annual inspection by a Gas Safe registered engineer.",
-        responseType: "yes_no_na_action",
-        tags: ["gas", "profile:hasGas"],
-      },
-      {
-        id: "gas-3",
-        question: "Are gas appliances serviced annually?",
-        guidance: "Check service records for boilers, heaters, and cookers.",
-        responseType: "yes_no_na_action",
-        tags: ["gas", "profile:hasGas"],
-      },
-      {
-        id: "gas-4",
-        question: "Is the gas emergency shut-off valve accessible and labelled?",
-        guidance: "All users should know the location of the emergency control.",
-        responseType: "yes_no_na_action",
-        tags: ["gas", "profile:hasGas"],
-      },
-    ],
-  },
-  {
-    id: "water-legionella",
-    number: 6,
-    title: "Water and legionella",
-    items: [
-      {
-        id: "leg-1",
-        question: "Is there a legionella risk assessment for water systems?",
-        guidance: "Required where stored water or infrequent use creates risk.",
-        responseType: "yes_no_na_action",
-        tags: ["legionella", "water"],
-      },
-      {
-        id: "leg-2",
-        question: "Are little-used outlets flushed regularly?",
-        guidance: "Run taps/showers weekly in little-used areas.",
-        responseType: "yes_no_na_action",
-        tags: ["legionella", "water"],
-      },
-      {
-        id: "leg-3",
-        question: "Are water temperatures at outlets appropriate?",
-        guidance: "Hot water should reach 50°C+ at outlets; cold below 20°C.",
-        responseType: "yes_no_na_action",
-        tags: ["legionella", "water"],
-      },
-      {
-        id: "leg-4",
-        question: "Is dead leg pipework identified and managed?",
-        guidance: "Remove or flush redundant pipework.",
-        responseType: "yes_no_na_action",
-        tags: ["legionella", "water"],
-      },
-    ],
-  },
-  {
-    id: "asbestos",
-    number: 7,
-    title: "Asbestos management",
-    items: [
-      {
-        id: "asb-1",
-        question: "Has an asbestos survey been carried out for pre-2000 buildings?",
-        guidance: "Required for buildingAgeBand PRE_1985 or Y1985_2000.",
-        responseType: "yes_no_na_action",
-        tags: ["asbestos", "profile:buildingAgeBand"],
-      },
-      {
-        id: "asb-2",
-        question: "Is there an asbestos management plan if ACMs are present?",
-        guidance: "Plan should include monitoring and control measures.",
-        responseType: "yes_no_na_action",
-        tags: ["asbestos"],
-      },
-      {
-        id: "asb-3",
-        question: "Are contractors informed of asbestos status before works?",
-        guidance: "Provide asbestos register to all contractors.",
-        responseType: "yes_no_na_action",
-        tags: ["asbestos"],
-      },
-      {
-        id: "asb-4",
-        question: "Are damaged asbestos-containing materials reported and managed?",
-        guidance: "Do not disturb; seek specialist advice immediately.",
-        responseType: "yes_no_na_action",
-        tags: ["asbestos"],
-      },
-    ],
-  },
-  {
-    id: "coshh",
-    number: 8,
-    title: "COSHH and hazardous substances",
-    items: [
-      {
-        id: "coshh-1",
-        question: "Are cleaning chemicals stored securely with COSHH assessments?",
-        guidance: "Safety data sheets should be available on site.",
-        responseType: "yes_no_na_action",
-        tags: ["coshh"],
-      },
-      {
-        id: "coshh-2",
-        question: "Are hazardous substances labelled and in original containers?",
-        guidance: "No decanting into unlabelled containers.",
-        responseType: "yes_no_na_action",
-        tags: ["coshh"],
-      },
-      {
-        id: "coshh-3",
-        question: "Is PPE available where required by COSHH assessments?",
-        guidance: "Gloves, goggles, etc. as specified on SDS.",
-        responseType: "yes_no_na_action",
-        tags: ["coshh"],
-      },
-      {
-        id: "coshh-4",
-        question: "Are spill kits available for chemical storage areas?",
-        guidance: "Particularly relevant for kitchen and cleaning stores.",
-        responseType: "yes_no_na_action",
-        tags: ["coshh"],
-      },
-    ],
-  },
-  {
-    id: "first-aid",
-    number: 9,
-    title: "First aid",
-    items: [
-      {
-        id: "fa-1",
-        question: "Are first aid kits stocked and accessible?",
-        guidance: "Check contents against a checklist; replace used items.",
-        responseType: "yes_no_na_action",
-        tags: ["first_aid"],
-      },
-      {
-        id: "fa-2",
-        question: "Is there a documented first aid needs assessment?",
-        guidance: "Consider number of users, activities, and remoteness.",
-        responseType: "yes_no_na_action",
-        tags: ["first_aid"],
-      },
-      {
-        id: "fa-3",
-        question: "Are sufficient trained first aiders available during activities?",
-        guidance: "At least one first aider should be present during section meetings.",
-        responseType: "yes_no_na_action",
-        tags: ["first_aid"],
-      },
-      {
-        id: "fa-4",
-        question: "Is an accident book maintained and reviewed?",
-        guidance: "Record all incidents; review trends at trustee meetings.",
-        responseType: "yes_no_na_action",
-        tags: ["first_aid"],
-      },
-    ],
-  },
-  {
-    id: "safeguarding",
-    number: 10,
-    title: "Safeguarding",
-    items: [
-      {
-        id: "sg-1",
-        question: "Are safeguarding policies displayed and accessible?",
-        guidance: "Yellow Card and safeguarding contacts should be visible.",
-        responseType: "yes_no_na_action",
-        tags: ["safeguarding"],
-      },
-      {
-        id: "sg-2",
-        question: "Are changing and toilet facilities appropriate and supervised?",
-        guidance: "Consider ratios and layout for young people.",
-        responseType: "yes_no_na_action",
-        tags: ["safeguarding"],
-      },
-      {
-        id: "sg-3",
-        question: "Is the premises layout conducive to good safeguarding practice?",
-        guidance: "Avoid isolated areas without oversight.",
-        responseType: "yes_no_na_action",
-        tags: ["safeguarding"],
-      },
-      {
-        id: "sg-4",
-        question: "Are external groups using the premises vetted appropriately?",
-        guidance: "Applies when hasThirdPartyUsers is true.",
-        responseType: "yes_no_na_action",
-        tags: ["safeguarding", "profile:hasThirdPartyUsers"],
-      },
-    ],
-  },
-  {
-    id: "security",
-    number: 11,
-    title: "Security",
-    items: [
-      {
-        id: "sec-1",
-        question: "Are external doors and windows secure when the premises is unoccupied?",
-        guidance: "Check locks, shutters, and access control.",
-        responseType: "yes_no_na_action",
-        tags: ["security"],
-      },
-      {
-        id: "sec-2",
-        question: "Is there a key/asset management system?",
-        guidance: "Keys should be issued to authorised persons only.",
-        responseType: "yes_no_na_action",
-        tags: ["security"],
-      },
-      {
-        id: "sec-3",
-        question: "Is external lighting adequate for evening use?",
-        guidance: "Car park and entrance routes should be lit.",
-        responseType: "yes_no_na_action",
-        tags: ["security"],
-      },
-      {
-        id: "sec-4",
-        question: "Is there an intruder alarm or CCTV where justified by risk?",
-        guidance: "Document the rationale if not installed.",
-        responseType: "yes_no_na_action",
-        tags: ["security"],
-      },
-    ],
-  },
-  {
-    id: "access-egress",
-    number: 12,
-    title: "Access and egress",
-    items: [
-      {
-        id: "acc-1",
-        question: "Are access routes free from trip hazards?",
-        guidance: "Check paths, steps, and ramps.",
-        responseType: "yes_no_na_action",
-        tags: ["access"],
-      },
-      {
-        id: "acc-2",
-        question: "Is disabled access provided where reasonably practicable?",
-        guidance: "Consider ramps, door widths, and toilet facilities.",
-        responseType: "yes_no_na_action",
-        tags: ["access"],
-      },
-      {
-        id: "acc-3",
-        question: "Are handrails provided and secure on stairs and ramps?",
-        guidance: "Check fixings and condition.",
-        responseType: "yes_no_na_action",
-        tags: ["access"],
-      },
-      {
-        id: "acc-4",
-        question: "Is emergency egress available from all occupied areas?",
-        guidance: "No dead ends without alternative escape.",
-        responseType: "yes_no_na_action",
-        tags: ["access", "fire"],
-      },
-    ],
-  },
-  {
-    id: "structural",
-    number: 13,
-    title: "Structural and building fabric",
-    items: [
-      {
-        id: "str-1",
-        question: "Are roofs, gutters, and downpipes in good repair?",
-        guidance: "Look for leaks, missing tiles, and blocked gutters.",
-        responseType: "yes_no_na_action",
-        tags: ["structural"],
-      },
-      {
-        id: "str-2",
-        question: "Are internal and external walls free from significant defects?",
-        guidance: "Cracks, damp, and bowing should be investigated.",
-        responseType: "yes_no_na_action",
-        tags: ["structural"],
-      },
-      {
-        id: "str-3",
-        question: "Are floors level and free from significant damage?",
-        guidance: "Trip hazards and soft spots should be addressed.",
-        responseType: "yes_no_na_action",
-        tags: ["structural"],
-      },
-      {
-        id: "str-4",
-        question: "Is a planned maintenance schedule in place?",
-        guidance: "Schedule should cover fabric, services, and grounds.",
-        responseType: "yes_no_na_action",
-        tags: ["structural", "governance"],
-      },
-    ],
-  },
-  {
-    id: "kitchen",
-    number: 14,
-    title: "Kitchen and catering",
-    items: [
-      {
-        id: "kit-1",
-        question: "Does this premises have a catering kitchen?",
-        guidance: "Skip if hasCateringKitchen is false on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["kitchen", "profile:hasCateringKitchen"],
-      },
-      {
-        id: "kit-2",
-        question: "Is food hygiene training current for food handlers?",
-        guidance: "Level 2 Food Safety certificate recommended.",
-        responseType: "yes_no_na_action",
-        tags: ["kitchen", "profile:hasCateringKitchen"],
-      },
-      {
-        id: "kit-3",
-        question: "Are kitchen surfaces, equipment, and storage hygienic?",
-        guidance: "Check cleanliness, fridge temperatures, and pest control.",
-        responseType: "yes_no_na_action",
-        tags: ["kitchen", "profile:hasCateringKitchen"],
-      },
-      {
-        id: "kit-4",
-        question: "Is extraction and ventilation adequate in the kitchen?",
-        guidance: "Canopy and filters should be cleaned regularly.",
-        responseType: "yes_no_na_action",
-        tags: ["kitchen", "profile:hasCateringKitchen"],
-      },
-    ],
-  },
-  {
-    id: "grounds",
-    number: 15,
-    title: "Grounds and external areas",
-    items: [
-      {
-        id: "grd-1",
-        question: "Does this premises include external grounds?",
-        guidance: "Skip if hasGrounds is false on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["grounds", "profile:hasGrounds"],
-      },
-      {
-        id: "grd-2",
-        question: "Are paths, car parks, and play areas maintained safely?",
-        guidance: "Check for potholes, uneven surfaces, and debris.",
-        responseType: "yes_no_na_action",
-        tags: ["grounds", "profile:hasGrounds"],
-      },
-      {
-        id: "grd-3",
-        question: "Are trees and vegetation managed to reduce risk?",
-        guidance: "Overhanging branches and deadwood should be addressed.",
-        responseType: "yes_no_na_action",
-        tags: ["grounds", "profile:hasGrounds"],
-      },
-      {
-        id: "grd-4",
-        question: "Is external waste storage secure and compliant?",
-        guidance: "Bins should not obstruct fire routes.",
-        responseType: "yes_no_na_action",
-        tags: ["grounds", "profile:hasGrounds"],
-      },
-    ],
-  },
-  {
-    id: "vehicles",
-    number: 16,
-    title: "Vehicles and transport",
-    items: [
-      {
-        id: "veh-1",
-        question: "Are vehicles stored or maintained on site?",
-        guidance: "Skip if hasVehicles is false on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["vehicles", "profile:hasVehicles"],
-      },
-      {
-        id: "veh-2",
-        question: "Is vehicle storage area segregated from pedestrian routes?",
-        guidance: "Minimise interaction between vehicles and young people.",
-        responseType: "yes_no_na_action",
-        tags: ["vehicles", "profile:hasVehicles"],
-      },
-      {
-        id: "veh-3",
-        question: "Are fuel and oil stored safely with spill containment?",
-        guidance: "Use appropriate containers and bunding.",
-        responseType: "yes_no_na_action",
-        tags: ["vehicles", "profile:hasVehicles"],
-      },
-      {
-        id: "veh-4",
-        question: "Are minibus and trailer checks documented if applicable?",
-        guidance: "Daily walk-around checks and MOT/service records.",
-        responseType: "yes_no_na_action",
-        tags: ["vehicles", "profile:hasVehicles"],
-      },
-    ],
-  },
-  {
-    id: "plant-machinery",
-    number: 17,
-    title: "Plant and machinery",
-    items: [
-      {
-        id: "plt-1",
-        question: "Is plant or machinery used on site?",
-        guidance: "Skip if hasPlantMachinery is false on the premises profile.",
-        responseType: "yes_no_na",
-        tags: ["plant", "profile:hasPlantMachinery"],
-      },
-      {
-        id: "plt-2",
-        question: "Are risk assessments in place for plant and machinery?",
-        guidance: "Include training requirements and safe systems of work.",
-        responseType: "yes_no_na_action",
-        tags: ["plant", "profile:hasPlantMachinery"],
-      },
-      {
-        id: "plt-3",
-        question: "Are guards and safety devices in place and functional?",
-        guidance: "Do not operate machinery with guards removed.",
-        responseType: "yes_no_na_action",
-        tags: ["plant", "profile:hasPlantMachinery"],
-      },
-      {
-        id: "plt-4",
-        question: "Is maintenance and inspection documented?",
-        guidance: "LOLER checks where applicable for lifting equipment.",
-        responseType: "yes_no_na_action",
-        tags: ["plant", "profile:hasPlantMachinery"],
-      },
-    ],
-  },
-  {
-    id: "flood-risk",
-    number: 18,
-    title: "Flood risk",
-    items: [
-      {
-        id: "fld-1",
-        question: "Has a flood risk assessment been completed?",
-        guidance: "Required for MEDIUM or HIGH floodRiskZone on the profile.",
-        responseType: "yes_no_na_action",
-        tags: ["flood", "profile:floodRiskZone"],
-      },
-      {
-        id: "fld-2",
-        question: "Are flood resilience measures in place where required?",
-        guidance: "Flood gates, raised electrics, sandbag stores as appropriate.",
-        responseType: "yes_no_na_action",
-        tags: ["flood", "profile:floodRiskZone"],
-      },
-      {
-        id: "fld-3",
-        question: "Is there a flood emergency plan?",
-        guidance: "Include evacuation triggers and contact numbers.",
-        responseType: "yes_no_na_action",
-        tags: ["flood", "profile:floodRiskZone"],
-      },
-      {
-        id: "fld-4",
-        question: "Are drains and gullies maintained to reduce surface water risk?",
-        guidance: "Clear blockages before winter months.",
-        responseType: "yes_no_na_action",
-        tags: ["flood"],
-      },
-    ],
-  },
-  {
-    id: "emergency-lighting",
-    number: 19,
-    title: "Emergency lighting",
-    items: [
-      {
-        id: "eml-1",
-        question: "Is emergency lighting installed where required?",
-        guidance: "Required on escape routes and open areas.",
-        responseType: "yes_no_na_action",
-        tags: ["emergency_lighting", "fire"],
-      },
-      {
-        id: "eml-2",
-        question: "Has annual emergency lighting testing been completed?",
-        guidance: "Monthly flick tests and annual duration test.",
-        responseType: "yes_no_na_action",
-        tags: ["emergency_lighting"],
-      },
-      {
-        id: "eml-3",
-        question: "Are emergency lighting test records available?",
-        guidance: "Log book should show monthly and annual tests.",
-        responseType: "yes_no_na_action",
-        tags: ["emergency_lighting"],
-      },
-      {
-        id: "eml-4",
-        question: "Are all emergency luminaires unobstructed?",
-        guidance: "No stored items blocking light output.",
-        responseType: "yes_no_na_action",
-        tags: ["emergency_lighting"],
-      },
-    ],
-  },
-  {
-    id: "fire-extinguishers",
-    number: 20,
-    title: "Fire extinguishers",
-    items: [
-      {
-        id: "ext-1",
-        question: "Are fire extinguishers provided at appropriate locations?",
-        guidance: "Type and siting should match the fire risk assessment.",
-        responseType: "yes_no_na_action",
-        tags: ["fire_extinguisher", "fire"],
-      },
-      {
-        id: "ext-2",
-        question: "Have extinguishers been serviced within the last 12 months?",
-        guidance: "Annual service by a competent contractor.",
-        responseType: "yes_no_na_action",
-        tags: ["fire_extinguisher"],
-      },
-      {
-        id: "ext-3",
-        question: "Are extinguishers mounted correctly and signed?",
-        guidance: "Red signage at each extinguisher location.",
-        responseType: "yes_no_na_action",
-        tags: ["fire_extinguisher"],
-      },
-      {
-        id: "ext-4",
-        question: "Are staff/volunteers aware of extinguisher locations?",
-        guidance: "Brief new leaders as part of premises induction.",
-        responseType: "yes_no_na_action",
-        tags: ["fire_extinguisher"],
-      },
-    ],
-  },
-  {
-    id: "contractors",
-    number: 21,
-    title: "Contractors and third-party users",
-    items: [
-      {
-        id: "con-1",
-        question: "Is contractor insurance verified before work commences?",
-        guidance: "Public liability minimum £5m recommended.",
-        responseType: "yes_no_na_action",
-        tags: ["contractors", "profile:hasThirdPartyUsers"],
-      },
-      {
-        id: "con-2",
-        question: "Are hot work permits used where applicable?",
-        guidance: "Required for welding, cutting, and other ignition sources.",
-        responseType: "yes_no_na_action",
-        tags: ["contractors"],
-      },
-      {
-        id: "con-3",
-        question: "Are hire agreements in place for third-party users?",
-        guidance: "Applies when hasThirdPartyUsers is true.",
-        responseType: "yes_no_na_action",
-        tags: ["contractors", "profile:hasThirdPartyUsers"],
-      },
-      {
-        id: "con-4",
-        question: "Are lone working procedures in place for contractors?",
-        guidance: "Check-in arrangements for out-of-hours work.",
-        responseType: "yes_no_na_action",
-        tags: ["contractors"],
-      },
-    ],
-  },
-  {
-    id: "lone-working",
-    number: 22,
-    title: "Lone working and out-of-hours use",
-    items: [
-      {
-        id: "lw-1",
-        question: "Is there a lone working policy for premises volunteers?",
-        guidance: "Define when lone working is permitted and controls required.",
-        responseType: "yes_no_na_action",
-        tags: ["lone_working"],
-      },
-      {
-        id: "lw-2",
-        question: "Are out-of-hours access arrangements documented?",
-        guidance: "Key holders and alarm codes should be controlled.",
-        responseType: "yes_no_na_action",
-        tags: ["lone_working"],
-      },
-      {
-        id: "lw-3",
-        question: "Is adequate lighting available for lone workers?",
-        guidance: "Internal and external lighting on timers or sensors.",
-        responseType: "yes_no_na_action",
-        tags: ["lone_working"],
-      },
-      {
-        id: "lw-4",
-        question: "Is a check-in procedure in place for lone workers?",
-        guidance: "Buddy system or scheduled contact checks.",
-        responseType: "yes_no_na_action",
-        tags: ["lone_working"],
-      },
-    ],
-  },
-  {
-    id: "welfare",
-    number: 23,
-    title: "Welfare facilities",
-    items: [
-      {
-        id: "wel-1",
-        question: "Are toilet and wash facilities adequate and clean?",
-        guidance: "Sufficient for peak occupancy; hot water available.",
-        responseType: "yes_no_na_action",
-        tags: ["welfare"],
-      },
-      {
-        id: "wel-2",
-        question: "Is drinking water available?",
-        guidance: "Mains supply or bottled water for events.",
-        responseType: "yes_no_na_action",
-        tags: ["welfare"],
-      },
-      {
-        id: "wel-3",
-        question: "Are heating and ventilation systems maintained?",
-        guidance: "Annual service for boilers; filters cleaned.",
-        responseType: "yes_no_na_action",
-        tags: ["welfare"],
-      },
-      {
-        id: "wel-4",
-        question: "Is the premises free from excessive cold, heat, or draughts?",
-        guidance: "Comfortable for activities year-round.",
-        responseType: "yes_no_na_action",
-        tags: ["welfare"],
-      },
-    ],
-  },
-  {
-    id: "housekeeping",
-    number: 24,
-    title: "Housekeeping and general safety",
-    items: [
-      {
-        id: "hk-1",
-        question: "Are corridors and storage areas free from clutter?",
-        guidance: "Combustible storage should not block escape routes.",
-        responseType: "yes_no_na_action",
-        tags: ["housekeeping"],
-      },
-      {
-        id: "hk-2",
-        question: "Are cleaning schedules documented and followed?",
-        guidance: "Include toilets, kitchen, and communal areas.",
-        responseType: "yes_no_na_action",
-        tags: ["housekeeping"],
-      },
-      {
-        id: "hk-3",
-        question: "Is pest control managed effectively?",
-        guidance: "No evidence of infestation; contract in place if needed.",
-        responseType: "yes_no_na_action",
-        tags: ["housekeeping"],
-      },
-      {
-        id: "hk-4",
-        question: "Are glass doors and low-level glazing marked or protected?",
-        guidance: "Manifestation at eye level to prevent impact injuries.",
-        responseType: "yes_no_na_action",
-        tags: ["housekeeping"],
-      },
-    ],
-  },
-  {
-    id: "signage",
-    number: 25,
-    title: "Signage and information",
-    items: [
-      {
-        id: "sig-1",
-        question: "Are statutory signs displayed (fire, first aid, no smoking)?",
-        guidance: "Signs should be legible and up to date.",
-        responseType: "yes_no_na_action",
-        tags: ["signage"],
-      },
-      {
-        id: "sig-2",
-        question: "Are maximum occupancy limits displayed where set?",
-        guidance: "Based on fire risk assessment and licensing.",
-        responseType: "yes_no_na_action",
-        tags: ["signage"],
-      },
-      {
-        id: "sig-3",
-        question: "Is emergency contact information displayed?",
-        guidance: "Include NHS, gas emergency, and trustee contacts.",
-        responseType: "yes_no_na_action",
-        tags: ["signage"],
-      },
-      {
-        id: "sig-4",
-        question: "Are premises rules and hire conditions visible to users?",
-        guidance: "Displayed at entrance or in hire pack.",
-        responseType: "yes_no_na_action",
-        tags: ["signage"],
-      },
-    ],
-  },
-];
diff --git a/prisma/data/audit-template-normalized.ts b/prisma/data/audit-template-normalized.ts
new file mode 100644
index 0000000..a040da6
--- /dev/null
+++ b/prisma/data/audit-template-normalized.ts
@@ -0,0 +1,103 @@
+import type {
+  AuditSubQuestion,
+  AuditTemplateItem,
+  AuditTemplateSection,
+  AuditTemplateSections,
+  AnswerableResponseType,
+} from "@/types/audit-template";
+import { AUDIT_TEMPLATE_V2025_09 } from "./audit-template-2025-09";
+
+type RawSubQuestion = {
+  id: string;
+  question: string;
+  responseType: AnswerableResponseType;
+  requiresDocument: boolean;
+  documentType?: string;
+  profileFlag?: string;
+};
+
+type RawItem = {
+  id: string;
+  question?: string;
+  label?: string;
+  guidance: string | null;
+  responseType: AuditTemplateItem["responseType"];
+  requiresDocument: boolean;
+  profileFlag?: string;
+  documentType?: string;
+  subQuestions?: readonly RawSubQuestion[];
+};
+
+type RawSubsection = {
+  id: string;
+  title: string;
+  items: readonly RawItem[];
+};
+
+type RawSection = {
+  id: string;
+  number: number;
+  title: string;
+  scope: "ALL" | "EXTENDED";
+  profileFlag?: string;
+  items: readonly RawItem[];
+  subsections?: readonly RawSubsection[];
+};
+
+function normalizeSubQuestion(item: RawSubQuestion): AuditSubQuestion {
+  return {
+    id: item.id,
+    question: item.question,
+    responseType: item.responseType,
+    requiresDocument: item.requiresDocument,
+    documentType: item.documentType,
+    profileFlag: item.profileFlag,
+  };
+}
+
+function normalizeItem(item: RawItem): AuditTemplateItem {
+  if (item.responseType === "GROUP") {
+    return {
+      id: item.id,
+      label: item.label ?? item.question ?? "",
+      guidance: item.guidance ?? "",
+      responseType: "GROUP",
+      requiresDocument: false,
+      profileFlag: item.profileFlag,
+      subQuestions: (item.subQuestions ?? []).map(normalizeSubQuestion),
+    };
+  }
+
+  return {
+    id: item.id,
+    question: item.question ?? "",
+    guidance: item.guidance ?? "",
+    responseType: item.responseType,
+    requiresDocument: item.requiresDocument,
+    documentType: item.documentType,
+    profileFlag: item.profileFlag,
+  };
+}
+
+function flattenSection(section: RawSection): AuditTemplateSection {
+  const items = section.subsections
+    ? section.subsections.flatMap((subsection) => subsection.items)
+    : section.items;
+
+  return {
+    id: section.id,
+    number: section.number,
+    title: section.title,
+    scope: section.scope === "ALL" ? "all" : "extended",
+    profileFlag: section.profileFlag,
+    items: items.map(normalizeItem),
+  };
+}
+
+/** Normalized sections for seeding and runtime use. */
+export const auditTemplate202509: AuditTemplateSections = (
+  AUDIT_TEMPLATE_V2025_09.sections as readonly RawSection[]
+).map(flattenSection);
+
+export const AUDIT_TEMPLATE_VERSION = AUDIT_TEMPLATE_V2025_09.version;
+export const AUDIT_TEMPLATE_PUBLISHED_AT = AUDIT_TEMPLATE_V2025_09.publishedAt;
diff --git a/prisma/migrations/20250701170000_add_audit_response_needs_action/migration.sql b/prisma/migrations/20250701170000_add_audit_response_needs_action/migration.sql
new file mode 100644
index 0000000..0653875
--- /dev/null
+++ b/prisma/migrations/20250701170000_add_audit_response_needs_action/migration.sql
@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "AuditResponse" ADD COLUMN "needsAction" BOOLEAN NOT NULL DEFAULT false;
+
+-- Backfill legacy responses
+UPDATE "AuditResponse" SET "needsAction" = true WHERE "response" = 'ACTION_NEEDED';
diff --git a/prisma/migrations/20250701180000_add_audit_response_recorded_date/migration.sql b/prisma/migrations/20250701180000_add_audit_response_recorded_date/migration.sql
new file mode 100644
index 0000000..e20735c
--- /dev/null
+++ b/prisma/migrations/20250701180000_add_audit_response_recorded_date/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "AuditResponse" ADD COLUMN "recordedDate" DATE;
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index c93407e..6cd59e1 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -109,14 +109,16 @@ model AuditSection {
 }
 
 model AuditResponse {
-  id          String        @id @default(cuid())
-  auditId     String
-  audit       Audit         @relation(fields: [auditId], references: [id], onDelete: Cascade)
-  itemId      String
-  response    ResponseValue
-  notes       String?
-  respondedBy String
-  respondedAt DateTime      @default(now())
+  id           String        @id @default(cuid())
+  auditId      String
+  audit        Audit         @relation(fields: [auditId], references: [id], onDelete: Cascade)
+  itemId       String
+  response     ResponseValue
+  needsAction  Boolean       @default(false)
+  notes        String?
+  recordedDate DateTime?     @db.Date
+  respondedBy  String
+  respondedAt  DateTime      @default(now())
 
   @@unique([auditId, itemId])
   @@index([auditId])
diff --git a/prisma/seed.ts b/prisma/seed.ts
index bc7c1e8..6487cff 100644
--- a/prisma/seed.ts
+++ b/prisma/seed.ts
@@ -1,8 +1,16 @@
-import { PrismaClient } from "@prisma/client";
-import { auditTemplate202509 } from "./data/audit-template-2025-09";
+import { OrgType, Role, PrismaClient, OwnershipType, BuildingAgeBand, FloodRiskZone } from "@prisma/client";
+import { DEV_USER_ID } from "../lib/auth";
+import { computeApplicableSections } from "../lib/sections";
+import {
+  auditTemplate202509,
+  AUDIT_TEMPLATE_PUBLISHED_AT,
+} from "./data/audit-template-normalized";
 
 const prisma = new PrismaClient();
 
+const DEV_ORG_ID = "dev-org-3rd-southfield";
+const DEV_PREMISES_ID = "dev-premises-hut";
+
 async function main() {
   console.log("Seeding database...");
 
@@ -10,12 +18,12 @@ async function main() {
     where: { version: "2025-09" },
     update: {
       sections: auditTemplate202509,
-      publishedAt: new Date("2025-09-01T00:00:00.000Z"),
+      publishedAt: AUDIT_TEMPLATE_PUBLISHED_AT,
       isActive: true,
     },
     create: {
       version: "2025-09",
-      publishedAt: new Date("2025-09-01T00:00:00.000Z"),
+      publishedAt: AUDIT_TEMPLATE_PUBLISHED_AT,
       sections: auditTemplate202509,
       isActive: true,
     },
@@ -23,8 +31,83 @@ async function main() {
 
   console.log(`Audit template seeded: ${template.version} (${template.id})`);
   console.log(
-    `  Sections: ${auditTemplate202509.length}, Items: ${auditTemplate202509.reduce((n, s) => n + s.items.length, 0)}`,
+    `  Sections: ${auditTemplate202509.length}, Top-level items: ${auditTemplate202509.reduce((n, s) => n + s.items.length, 0)}, Answerable questions: ${auditTemplate202509.reduce((n, s) => n + s.items.reduce((count, item) => count + (item.responseType === "GROUP" ? item.subQuestions.length : 1), 0), 0)}`,
   );
+
+  const organisation = await prisma.organisation.upsert({
+    where: { id: DEV_ORG_ID },
+    update: {
+      name: "3rd Southfield Scout Group",
+      type: OrgType.GROUP,
+    },
+    create: {
+      id: DEV_ORG_ID,
+      name: "3rd Southfield Scout Group",
+      type: OrgType.GROUP,
+    },
+  });
+
+  await prisma.membership.upsert({
+    where: {
+      userId_organisationId: {
+        userId: DEV_USER_ID,
+        organisationId: organisation.id,
+      },
+    },
+    update: { role: Role.ADMIN },
+    create: {
+      userId: DEV_USER_ID,
+      organisationId: organisation.id,
+      role: Role.ADMIN,
+    },
+  });
+
+  const premises = await prisma.premises.upsert({
+    where: { id: DEV_PREMISES_ID },
+    update: {
+      name: "3rd Southfield Scout Hut",
+      address: "12 Oak Lane, Southfield, SF1 2AB",
+      organisationId: organisation.id,
+    },
+    create: {
+      id: DEV_PREMISES_ID,
+      name: "3rd Southfield Scout Hut",
+      address: "12 Oak Lane, Southfield, SF1 2AB",
+      organisationId: organisation.id,
+    },
+  });
+
+  const profileInput = {
+    buildingAgeBand: BuildingAgeBand.PRE_1985,
+    hasGas: true,
+    hasSleeping: false,
+    hasCateringKitchen: false,
+    hasGrounds: true,
+    hasVehicles: false,
+    hasPlantMachinery: false,
+    hasThirdPartyUsers: false,
+    floodRiskZone: FloodRiskZone.LOW,
+  };
+
+  await prisma.premisesProfile.upsert({
+    where: { premisesId: premises.id },
+    update: {
+      ownershipType: OwnershipType.OWNED,
+      ...profileInput,
+      applicableSections: computeApplicableSections(profileInput),
+    },
+    create: {
+      premisesId: premises.id,
+      ownershipType: OwnershipType.OWNED,
+      ...profileInput,
+      applicableSections: computeApplicableSections(profileInput),
+    },
+  });
+
+  console.log(`Dev organisation: ${organisation.name} (${organisation.id})`);
+  console.log(`Dev premises: ${premises.name} (${premises.id})`);
+  console.log(`  Profile wizard: /premises/${premises.id}/profile`);
+  console.log(`  Audit wizard:   /premises/${premises.id}/audit`);
 }
 
 main()
diff --git a/types/audit-template.ts b/types/audit-template.ts
index b1be4b3..9f9950d 100644
--- a/types/audit-template.ts
+++ b/types/audit-template.ts
@@ -1,16 +1,77 @@
-export type AuditTemplateItem = {
+export type AuditResponseType =
+  | "YES_NO_NA_ACTION"
+  | "OPEN_TEXT"
+  | "DATE_UPLOAD"
+  | "GROUP";
+
+export type AnswerableResponseType = Exclude<AuditResponseType, "GROUP">;
+
+export type AuditSubQuestion = {
   id: string;
   question: string;
+  responseType: AnswerableResponseType;
+  requiresDocument: boolean;
+  documentType?: string;
+  profileFlag?: string;
+};
+
+export type AtomicAuditTemplateItem = {
+  id: string;
+  question: string;
+  guidance: string;
+  responseType: AnswerableResponseType;
+  requiresDocument: boolean;
+  documentType?: string;
+  profileFlag?: string;
+};
+
+export type GroupAuditTemplateItem = {
+  id: string;
+  label: string;
   guidance: string;
-  responseType: "yes_no_na" | "yes_no_na_action";
-  tags: string[];
+  responseType: "GROUP";
+  requiresDocument: false;
+  profileFlag?: string;
+  subQuestions: AuditSubQuestion[];
 };
 
+export type AuditTemplateItem = AtomicAuditTemplateItem | GroupAuditTemplateItem;
+
+export type AnswerableAuditItem = AtomicAuditTemplateItem | AuditSubQuestion;
+
+export type AuditSectionScope = "all" | "extended";
+
 export type AuditTemplateSection = {
   id: string;
   number: number;
   title: string;
+  scope: AuditSectionScope;
+  profileFlag?: string;
   items: AuditTemplateItem[];
 };
 
 export type AuditTemplateSections = AuditTemplateSection[];
+
+export function isGroupItem(
+  item: AuditTemplateItem,
+): item is GroupAuditTemplateItem {
+  return item.responseType === "GROUP";
+}
+
+export function isYesNoItem(item: AnswerableAuditItem): boolean {
+  return item.responseType === "YES_NO_NA_ACTION";
+}
+
+export function isOpenTextItem(item: AnswerableAuditItem): boolean {
+  return item.responseType === "OPEN_TEXT";
+}
+
+export function isDateUploadItem(item: AnswerableAuditItem): boolean {
+  return item.responseType === "DATE_UPLOAD";
+}
+
+export function isTextAnswerItem(item: {
+  responseType: AuditResponseType;
+}): boolean {
+  return item.responseType === "OPEN_TEXT" || item.responseType === "DATE_UPLOAD";
+}
diff --git a/types/audit.ts b/types/audit.ts
new file mode 100644
index 0000000..dd3c3fb
--- /dev/null
+++ b/types/audit.ts
@@ -0,0 +1,108 @@
+import type { AuditSectionStatus, ResponseValue, ActionStatus, Priority } from "@prisma/client";
+import type { AnswerableResponseType } from "@/types/audit-template";
+
+export type AuditLinkedAction = {
+  id: string;
+  title: string;
+  description: string | null;
+  priority: Priority;
+  dueDate: string | null;
+  status: ActionStatus;
+};
+
+export type AuditSectionSummary = {
+  id: string;
+  number: number;
+  title: string;
+  status: AuditSectionStatus;
+  itemCount: number;
+  answeredCount: number;
+};
+
+export type AuditOverview = {
+  id: string;
+  status: string;
+  templateVersion: string;
+  premises: {
+    id: string;
+    name: string;
+    profile: unknown;
+  };
+  sections: AuditSectionSummary[];
+  progress: {
+    completedSections: number;
+    totalSections: number;
+  };
+};
+
+export type AuditResponseRecord = {
+  id: string;
+  response: ResponseValue;
+  needsAction: boolean;
+  notes: string | null;
+  recordedDate: string | null;
+};
+
+export type AuditItemWithResponse = {
+  id: string;
+  question: string;
+  guidance: string;
+  responseType: AnswerableResponseType;
+  requiresDocument: boolean;
+  documentType?: string;
+  profileFlag?: string;
+  response: AuditResponseRecord | null;
+  actions: AuditLinkedAction[];
+};
+
+export type AuditSubQuestionWithResponse = {
+  id: string;
+  question: string;
+  responseType: AnswerableResponseType;
+  requiresDocument: boolean;
+  documentType?: string;
+  profileFlag?: string;
+  response: AuditResponseRecord | null;
+  actions: AuditLinkedAction[];
+};
+
+export type AuditAtomicSectionItem = {
+  kind: "atomic";
+  item: AuditItemWithResponse;
+};
+
+export type AuditGroupSectionItem = {
+  kind: "group";
+  id: string;
+  label: string;
+  guidance: string;
+  subQuestions: AuditSubQuestionWithResponse[];
+};
+
+export type AuditSectionItem =
+  | AuditAtomicSectionItem
+  | AuditGroupSectionItem;
+
+export type AuditSectionPayload = {
+  section: {
+    id: string;
+    number: number;
+    title: string;
+    status: AuditSectionStatus;
+  };
+  items: AuditSectionItem[];
+};
+
+export const RESPONSE_LABELS: Record<ResponseValue, string> = {
+  YES: "Yes",
+  NO: "No",
+  NA: "Not applicable",
+  ACTION_NEEDED: "Needs action",
+};
+
+export const SECTION_STATUS_LABELS: Record<AuditSectionStatus, string> = {
+  NOT_STARTED: "Not started",
+  IN_PROGRESS: "In progress",
+  COMPLETE: "Complete",
+  SKIPPED: "Skipped",
+};
diff --git a/types/index.ts b/types/index.ts
index 5efb5a1..b7e1d7e 100644
--- a/types/index.ts
+++ b/types/index.ts
@@ -1,5 +1,15 @@
 export type { AuditTemplateItem, AuditTemplateSection, AuditTemplateSections } from "./audit-template";
 
+export type {
+  AuditOverview,
+  AuditSectionPayload,
+  AuditSectionSummary,
+  AuditItemWithResponse,
+} from "./audit";
+export { RESPONSE_LABELS, SECTION_STATUS_LABELS } from "./audit";
+
+export type { ProfileForSections } from "@/lib/audit-items";
+
 export {
   OrgType,
   Role,