diff --git a/api.planx.uk/modules/analytics/metabase/collection/collection.test.ts b/api.planx.uk/modules/analytics/metabase/collection/collection.test.ts
index 1b66e90a88..4b9829dd69 100644
--- a/api.planx.uk/modules/analytics/metabase/collection/collection.test.ts
+++ b/api.planx.uk/modules/analytics/metabase/collection/collection.test.ts
@@ -1 +1,92 @@
-test.todo("should test collection check and creation");
+import { $api } from "../../../../client/index.js";
+import { updateMetabaseId } from "./updateMetabaseId.js";
+import { getTeamIdAndMetabaseId } from "./getTeamIdAndMetabaseId.js";
+
+describe("getTeamIdAndMetabaseId", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("successfully gets team and existing metabase id", async () => {
+    vi.spyOn($api.client, "request").mockResolvedValue({
+      teams: [
+        {
+          id: 26,
+          slug: "barnet",
+          metabaseId: 20,
+        },
+      ],
+    });
+
+    const teamAndMetabaseId = await getTeamIdAndMetabaseId("barnet");
+
+    expect(teamAndMetabaseId.id).toEqual(26);
+    expect(teamAndMetabaseId.metabaseId).toEqual(20);
+  });
+
+  test("handles team with null metabase id", async () => {
+    vi.spyOn($api.client, "request").mockResolvedValue({
+      teams: [
+        {
+          id: 26,
+          slug: "barnet",
+          metabaseId: null,
+        },
+      ],
+    });
+
+    const teamAndMetabaseId = await getTeamIdAndMetabaseId("Barnet");
+
+    expect(teamAndMetabaseId.id).toEqual(26);
+    expect(teamAndMetabaseId.metabaseId).toBeNull();
+  });
+});
+
+describe("updateMetabaseId", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("successfully updates metabase ID", async () => {
+    // Mock the GraphQL request
+    vi.spyOn($api.client, "request").mockResolvedValue({
+      update_teams: {
+        returning: [
+          {
+            id: 1,
+            slug: "testteam",
+            metabase_id: 123,
+          },
+        ],
+      },
+    });
+
+    const result = await updateMetabaseId(1, 123);
+
+    expect(result).toEqual({
+      update_teams: {
+        returning: [
+          {
+            id: 1,
+            slug: "testteam",
+            metabase_id: 123,
+          },
+        ],
+      },
+    });
+
+    expect($api.client.request).toHaveBeenCalledWith(expect.any(String), {
+      id: 1,
+      metabaseId: 123,
+    });
+  });
+
+  test("handles GraphQL error", async () => {
+    // Mock a failed GraphQL request
+    vi.spyOn($api.client, "request").mockRejectedValue(
+      new Error("GraphQL error"),
+    );
+
+    await expect(updateMetabaseId(1, 123)).rejects.toThrow("GraphQL error");
+  });
+});
diff --git a/api.planx.uk/modules/analytics/metabase/collection/getTeamIdAndMetabaseId.ts b/api.planx.uk/modules/analytics/metabase/collection/getTeamIdAndMetabaseId.ts
new file mode 100644
index 0000000000..4007bfef64
--- /dev/null
+++ b/api.planx.uk/modules/analytics/metabase/collection/getTeamIdAndMetabaseId.ts
@@ -0,0 +1,38 @@
+import { gql } from "graphql-request";
+import { $api } from "../../../../client/index.js";
+
+interface GetMetabaseId {
+  teams: {
+    id: number;
+    slug: string;
+    metabaseId: number | null;
+  }[];
+}
+
+export const getTeamIdAndMetabaseId = async (slug: string) => {
+  try {
+    const response = await $api.client.request<GetMetabaseId>(
+      gql`
+        query GetTeamAndMetabaseId($slug: String!) {
+          teams(where: { slug: { _eq: $slug } }) {
+            id
+            slug
+            metabaseId: metabase_id
+          }
+        }
+      `,
+      {
+        slug: slug,
+      },
+    );
+
+    const result = response.teams[0];
+    return result;
+  } catch (e) {
+    console.error(
+      "Error fetching team's ID / Metabase ID from PlanX DB:",
+      (e as Error).stack,
+    );
+    throw e;
+  }
+};
diff --git a/api.planx.uk/modules/analytics/metabase/collection/updateMetabaseId.ts b/api.planx.uk/modules/analytics/metabase/collection/updateMetabaseId.ts
new file mode 100644
index 0000000000..93ffe1042d
--- /dev/null
+++ b/api.planx.uk/modules/analytics/metabase/collection/updateMetabaseId.ts
@@ -0,0 +1,43 @@
+import { gql } from "graphql-request";
+import { $api } from "../../../../client/index.js";
+
+interface UpdateMetabaseId {
+  teams: {
+    id: number;
+    slug: string;
+    metabaseId: number;
+  };
+}
+
+/** Updates column `metabase_id` in the Planx DB `teams` table */
+export const updateMetabaseId = async (teamId: number, metabaseId: number) => {
+  try {
+    const response = await $api.client.request<UpdateMetabaseId>(
+      gql`
+        mutation UpdateTeamMetabaseId($id: Int!, $metabaseId: Int!) {
+          update_teams(
+            where: { id: { _eq: $id } }
+            _set: { metabase_id: $metabaseId }
+          ) {
+            returning {
+              id
+              slug
+              metabase_id
+            }
+          }
+        }
+      `,
+      {
+        id: teamId,
+        metabaseId: metabaseId,
+      },
+    );
+    return response;
+  } catch (e) {
+    console.error(
+      "There's been an error while updating the Metabase ID for this team",
+      (e as Error).stack,
+    );
+    throw e;
+  }
+};
diff --git a/e2e/tests/ui-driven/src/create-flow-with-geospatial.spec.ts b/e2e/tests/ui-driven/src/create-flow-with-geospatial.spec.ts
index 8bc6fe181b..02ecfbc29e 100644
--- a/e2e/tests/ui-driven/src/create-flow-with-geospatial.spec.ts
+++ b/e2e/tests/ui-driven/src/create-flow-with-geospatial.spec.ts
@@ -19,11 +19,24 @@ import {
 } from "./helpers/navigateAndPublish";
 import { TestContext } from "./helpers/types";
 import { serviceProps } from "./helpers/serviceData";
-import { checkGeoJsonContent } from "./helpers/geospatialChecks";
 import {
-  mockMapGeoJson,
+  alterDrawGeoJson,
+  checkGeoJsonContent,
+  checkUploadFileAltRoute,
+  getMapProperties,
+  resetMapBoundary,
+  waitForMapComponent,
+} from "./helpers/geospatialChecks";
+import {
+  GeoJsonChangeHandler,
+  mockChangedMapGeoJson,
   mockPropertyTypeOptions,
+  mockTitleBoundaryGeoJson,
 } from "./mocks/geospatialMocks";
+import {
+  setupOSMapsStyles,
+  setupOSMapsVectorTiles,
+} from "./mocks/osMapsResponse";
 
 test.describe("Flow creation, publish and preview", () => {
   let context: TestContext = {
@@ -72,8 +85,7 @@ test.describe("Flow creation, publish and preview", () => {
     await editor.createInternalPortal();
     await editor.populateInternalPortal();
     await page.getByRole("link", { name: "start" }).click(); // return to main flow
-    await editor.createUploadAndLabel();
-    // TODO: editor.createPropertyInfo()
+    // await editor.createUploadAndLabel();
     await editor.createDrawBoundary();
     await editor.createPlanningConstraints();
     // await editor.createFileUpload();
@@ -81,7 +93,6 @@ test.describe("Flow creation, publish and preview", () => {
     await expect(editor.nodeList).toContainText([
       "Find property",
       "an internal portalEdit Portal",
-      "Upload and label",
       "Confirm your location plan",
       "Planning constraints",
       // "File upload",
@@ -119,6 +130,9 @@ test.describe("Flow creation, publish and preview", () => {
       `/${context.team.slug}/${serviceProps.slug}/published?analytics=false`,
     );
 
+    setupOSMapsStyles(page);
+    setupOSMapsVectorTiles(page);
+
     await expect(
       page.locator("h1", { hasText: "Find the property" }),
     ).toBeVisible();
@@ -130,7 +144,7 @@ test.describe("Flow creation, publish and preview", () => {
     ).toBeVisible();
 
     // Check map component has geoJson content
-    await checkGeoJsonContent(page, mockMapGeoJson);
+    await checkGeoJsonContent(page, "geojsondata", mockTitleBoundaryGeoJson);
 
     // Check property info is being shown
     await expect(page.getByText("Test Street, Testville")).toBeVisible();
@@ -169,7 +183,49 @@ test.describe("Flow creation, publish and preview", () => {
     ).toBeVisible();
     await clickContinue({ page });
 
+    const drawBoundaryTitle = page.getByRole("heading", {
+      name: "Confirm your location plan",
+    });
+    await expect(drawBoundaryTitle).toBeVisible();
+
+    await checkGeoJsonContent(
+      page,
+      "drawgeojsondata",
+      mockTitleBoundaryGeoJson,
+    );
+
+    const area = "The property boundary you have drawn is 490.37";
+
+    await expect(page.getByText(area)).toBeVisible();
+
+    // navigate to upload file page and back
+    await checkUploadFileAltRoute(page);
+
+    await expect(
+      drawBoundaryTitle,
+      "We have navigated back to the map component",
+    ).toBeVisible();
+
+    // ensure map has loaded correctly
+    await waitForMapComponent(page);
+
+    await resetMapBoundary(page);
+
+    await alterDrawGeoJson(page);
+
+    // extract new GeoJSON data
+    const newGeoJson = await getMapProperties(page, "drawgeojsondata");
+    const parsedJson: GeoJsonChangeHandler = JSON.parse(newGeoJson!);
+
+    // check it matches our static mock
+    await checkGeoJsonContent(page, "drawgeojsondata", mockChangedMapGeoJson);
+
+    await expect(
+      page.getByText(`${parsedJson.properties!["area.squareMetres"]}`),
+      "The correct value for area comes from the map properties ",
+    ).toBeVisible();
+
     // TODO: answer uploadAndLabel
-    // TODO: answerPropertyInfo, answerDrawBoundary, answerPlanningConstraints
+    // TODO: answerPropertyInfo, answerPlanningConstraints
   });
 });
diff --git a/e2e/tests/ui-driven/src/helpers/geospatialChecks.ts b/e2e/tests/ui-driven/src/helpers/geospatialChecks.ts
index 7b55e01997..ea13894975 100644
--- a/e2e/tests/ui-driven/src/helpers/geospatialChecks.ts
+++ b/e2e/tests/ui-driven/src/helpers/geospatialChecks.ts
@@ -1,12 +1,87 @@
 import { expect, Page } from "@playwright/test";
 import { Feature } from "geojson";
 
-export const checkGeoJsonContent = async (page: Page, geoJson: Feature) => {
+export const waitForMapComponent = async (page: Page) => {
+  await page.waitForFunction(() => {
+    const map = document.getElementById("draw-boundary-map");
+    return map;
+  });
+};
+
+export const getMapProperties = async (
+  page: Page,
+  attribute: "geojsondata" | "drawgeojsondata",
+) => {
+  const mapComponent = await page.waitForSelector("my-map");
+  return await mapComponent.getAttribute(attribute);
+};
+
+export const alterDrawGeoJson = async (page: Page) => {
+  const map = page.getByTestId("map-test-id");
+
+  await map.click({ button: "left", position: { x: 100, y: 200 } });
+  await map.click({ button: "left", position: { x: 150, y: 250 } });
+  await map.click({ button: "left", position: { x: 200, y: 250 } });
+  await map.click({ button: "left", position: { x: 100, y: 200 } });
+};
+
+export const resetMapBoundary = async (page: Page) => {
+  const resetButton = page.getByLabel("Reset map view");
+  await resetButton.click();
+
+  const resetGeoJson = await getMapProperties(page, "drawgeojsondata");
+
+  expect(resetGeoJson, "drawGeoJsonData should be reset").toEqual(null);
+};
+
+export const checkGeoJsonContent = async (
+  page: Page,
+  attribute: "geojsondata" | "drawgeojsondata",
+  geoJson: Feature,
+) => {
   // Wait for the map component to be present
   const mapComponent = await page.waitForSelector("my-map");
 
+  await page.waitForFunction(() => customElements.get("my-map"));
+  await expect(
+    page.getByTestId("map-test-id"),
+    "Check we can see the map",
+  ).toBeVisible();
+
   // Get the geojsonData attribute
-  const geojsonData = await mapComponent.getAttribute("geojsondata");
+  const geojsonData = await mapComponent.getAttribute(attribute);
+
+  expect(
+    JSON.parse(geojsonData!),
+    "map attribute matches expected mock attribute",
+  ).toEqual(geoJson);
+};
+
+export const checkUploadFileAltRoute = async (page: Page) => {
+  const uploadButton = page.getByTestId("upload-file-button");
+
+  await expect(
+    uploadButton,
+    "We can see a button to upload a file instead",
+  ).toBeVisible();
+
+  await uploadButton.click();
+
+  await expect(
+    page.getByRole("heading", { name: "Upload a location plan" }),
+    "Should be in a page for uploading a file",
+  ).toBeVisible();
+
+  await expect(
+    page.getByRole("button", { name: "Drop file here or choose" }),
+    "A button for uploading files is visible",
+  ).toBeVisible();
+
+  await page.getByTestId("continue-button").click();
+
+  await page.getByTestId("error-message-upload-location-plan").isVisible();
+
+  const useMapButton = page.getByTestId("use-map-button");
 
-  expect(JSON.parse(geojsonData!)).toEqual(geoJson);
+  await useMapButton.click();
 };
diff --git a/e2e/tests/ui-driven/src/mocks/geospatialMocks.ts b/e2e/tests/ui-driven/src/mocks/geospatialMocks.ts
index fb26308b1d..e923545f46 100644
--- a/e2e/tests/ui-driven/src/mocks/geospatialMocks.ts
+++ b/e2e/tests/ui-driven/src/mocks/geospatialMocks.ts
@@ -1,13 +1,21 @@
 import { OptionWithDataValues } from "../helpers/types";
+import { Feature, Polygon } from "geojson";
+
+type ChangeHandlerProperties = {
+  label: string;
+  "area.squareMetres": number;
+  "area.hectares": number;
+};
+
+export type GeoJsonChangeHandler = Feature<Polygon, ChangeHandlerProperties>;
 
 export const mockPropertyTypeOptions: OptionWithDataValues[] = [
   { optionText: "Residential", dataValue: "residential" },
   { optionText: "Commercial", dataValue: "commercial" },
 ];
 
-import { Feature } from "geojson";
-
-export const mockMapGeoJson: Feature = {
+export const mockTitleBoundaryGeoJson: Feature = {
+  type: "Feature",
   geometry: {
     type: "MultiPolygon",
     coordinates: [
@@ -23,7 +31,6 @@ export const mockMapGeoJson: Feature = {
       ],
     ],
   },
-  type: "Feature",
   properties: {
     "entry-date": "2024-05-06",
     "start-date": "2010-05-12",
@@ -37,3 +44,23 @@ export const mockMapGeoJson: Feature = {
     "organisation-entity": "13",
   },
 };
+
+export const mockChangedMapGeoJson: GeoJsonChangeHandler = {
+  type: "Feature",
+  geometry: {
+    type: "Polygon",
+    coordinates: [
+      [
+        [-0.6341888375038146, 51.60562241658701],
+        [-0.6341217822784424, 51.605580770520504],
+        [-0.63405472705307, 51.605580770520504],
+        [-0.6341888375038146, 51.60562241658701],
+      ],
+    ],
+  },
+  properties: {
+    label: "1",
+    "area.squareMetres": 10.72,
+    "area.hectares": 0.001072,
+  },
+};
diff --git a/e2e/tests/ui-driven/src/mocks/osMapsMockData.ts b/e2e/tests/ui-driven/src/mocks/osMapsMockData.ts
new file mode 100644
index 0000000000..b99f14f4d3
--- /dev/null
+++ b/e2e/tests/ui-driven/src/mocks/osMapsMockData.ts
@@ -0,0 +1,22 @@
+export const osMapsStylesResponse = {
+  version: 8,
+  sprite:
+    "https://api.os.uk/maps/vector/v1/vts/resources/sprites/sprite?key=YOUR_KEY&srs=3857",
+  glyphs:
+    "https://api.os.uk/maps/vector/v1/vts/resources/fonts/{fontstack}/{range}.pbf?key=YOUR_KEY&srs=3857",
+  sources: {
+    esri: {
+      type: "vector",
+      url: "https://api.os.uk/maps/vector/v1/vts?key=YOUR_KEY&srs=3857",
+    },
+  },
+  layers: [
+    {
+      id: "background",
+      type: "background",
+      paint: {
+        "background-color": "#0437F2",
+      },
+    },
+  ],
+};
diff --git a/e2e/tests/ui-driven/src/mocks/osMapsResponse.ts b/e2e/tests/ui-driven/src/mocks/osMapsResponse.ts
new file mode 100644
index 0000000000..ccd6f6de6f
--- /dev/null
+++ b/e2e/tests/ui-driven/src/mocks/osMapsResponse.ts
@@ -0,0 +1,27 @@
+import { Page } from "@playwright/test";
+import { osMapsStylesResponse } from "./osMapsMockData";
+
+export async function setupOSMapsStyles(page: Page) {
+  const ordnanceSurveyMapsStyles = new RegExp(
+    /\/proxy\/ordnance-survey\/maps\/vector\/v1\/vts\/resources\/styles.*/,
+  );
+  await page.route(ordnanceSurveyMapsStyles, async (route) => {
+    await route.fulfill({
+      status: 200,
+      body: JSON.stringify(osMapsStylesResponse),
+    });
+  });
+}
+
+export async function setupOSMapsVectorTiles(page: Page) {
+  const ordnanceSurveyVectorTiles = new RegExp(
+    /\/proxy\/ordnance-survey\/maps\/vector\/v1\/vts\/tile/,
+  );
+
+  await page.route(ordnanceSurveyVectorTiles, async (route) => {
+    await route.fulfill({
+      status: 200,
+      body: Buffer.from([]),
+    });
+  });
+}
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx b/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
index 4034072d8f..662f2a25b4 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
@@ -7,20 +7,21 @@ import { ModalFooter } from "ui/editor/ModalFooter";
 import ModalSection from "ui/editor/ModalSection";
 import ModalSectionContent from "ui/editor/ModalSectionContent";
 import RichTextInput from "ui/editor/RichTextInput/RichTextInput";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
 import Input from "ui/shared/Input/Input";
 import InputRow from "ui/shared/InputRow";
 import { Switch } from "ui/shared/Switch";
 
 import { DataFieldAutocomplete } from "@planx/components/shared/DataFieldAutocomplete";
 import { useStore } from "pages/FlowEditor/lib/store";
-import { parseBaseNodeData } from "../../shared";
+import { Option, parseBaseNodeData } from "../../shared";
 import { ICONS } from "../../shared/icons";
 import type { Checklist } from "../model";
 import { toggleExpandableChecklist } from "../model";
 import { ChecklistProps } from "../types";
 import { Options } from "./Options";
 
-export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
+export const ChecklistEditor: React.FC<ChecklistProps> = (props) => {
   const type = TYPES.Checklist;
 
   const formik = useFormik<Checklist>({
@@ -41,7 +42,7 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
         : groupedOptions?.flatMap((group) => group.children);
 
       const filteredOptions = (sourceOptions || []).filter(
-        (option) => option.data.text,
+        (option) => option.data.text
       );
 
       const processedOptions = filteredOptions.map((option) => ({
@@ -68,14 +69,22 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
                   }),
             },
           },
-          processedOptions,
+          processedOptions
         );
       } else {
         alert(JSON.stringify({ type, ...values, options }, null, 2));
       }
     },
-    validate: ({ options, groupedOptions, ...values }) => {
+    validate: ({ options, groupedOptions, allRequired, ...values }) => {
       const errors: FormikErrors<FormikValues> = {};
+
+      const exclusiveOptions: Option[] | undefined = options?.filter(
+        (option) => option.data.exclusive
+      );
+      if (allRequired && exclusiveOptions && exclusiveOptions.length > 0) {
+        errors.allRequired =
+          'Cannot configure exclusive "or" option alongside "all required" setting';
+      }
       // Account for flat or expandable Checklist options
       options =
         options || groupedOptions?.map((group) => group.children)?.flat();
@@ -83,6 +92,10 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
         errors.fn =
           "At least one option must set a data value when the checklist has a data field";
       }
+      if (exclusiveOptions && exclusiveOptions.length > 1) {
+        errors.options =
+          "There should be a maximum of one exclusive option configured";
+      }
       return errors;
     },
   });
@@ -155,19 +168,20 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
                 onChange={() =>
                   formik.setFieldValue(
                     "allRequired",
-                    !formik.values.allRequired,
+                    !formik.values.allRequired
                   )
                 }
                 label="All required"
               />
             </InputRow>
+
             <InputRow>
               <Switch
                 checked={formik.values.neverAutoAnswer}
                 onChange={() =>
                   formik.setFieldValue(
                     "neverAutoAnswer",
-                    !formik.values.neverAutoAnswer,
+                    !formik.values.neverAutoAnswer
                   )
                 }
                 label="Always put to user (forgo automation)"
@@ -175,11 +189,13 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
             </InputRow>
           </InputGroup>
         </ModalSectionContent>
-        <Options formik={formik} />
+        <ErrorWrapper error={formik.errors.options}>
+          <Options formik={formik} />
+        </ErrorWrapper>
       </ModalSection>
       <ModalFooter formik={formik} />
     </form>
   );
 };
 
-export default ChecklistComponent;
+export default ChecklistEditor;
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx b/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx
index e3202d6331..13d2afa804 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx
@@ -2,6 +2,9 @@ import Delete from "@mui/icons-material/Delete";
 import Box from "@mui/material/Box";
 import Button from "@mui/material/Button";
 import IconButton from "@mui/material/IconButton";
+import { BaseOptionsEditor } from "@planx/components/shared/BaseOptionsEditor";
+import { hasFeatureFlag } from "lib/featureFlags";
+import { partition } from "lodash";
 import adjust from "ramda/src/adjust";
 import compose from "ramda/src/compose";
 import remove from "ramda/src/remove";
@@ -9,16 +12,25 @@ import React from "react";
 import { FormikHookReturn } from "types";
 import ListManager from "ui/editor/ListManager/ListManager";
 import ModalSectionContent from "ui/editor/ModalSectionContent";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
 import Input from "ui/shared/Input/Input";
 import InputRow from "ui/shared/InputRow";
 
+import { getOptionsSchemaByFn } from "@planx/components/shared/utils";
 import { useStore } from "pages/FlowEditor/lib/store";
 import { Option } from "../../shared";
 import type { Group } from "../model";
 import ChecklistOptionsEditor from "./OptionsEditor";
-import { getOptionsSchemaByFn } from "@planx/components/shared/utils";
 
 export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
+  const [exclusiveOptions, nonExclusiveOptions]: Option[][] = partition(
+    formik.values.options,
+    (option) => option.data.exclusive
+  );
+
+  const exclusiveOrOptionManagerShouldRender =
+    hasFeatureFlag("EXCLUSIVE_OR") && nonExclusiveOptions.length;
+  
   const schema = useStore().getFlowSchema()?.options;
   const initialOptions: Option[] | undefined = formik.initialValues.options || formik.initialValues.groupedOptions?.map((group: Group<Option>) => group.children)?.flat();
   const initialOptionVals = initialOptions?.map((option) => option.data?.val);
@@ -48,7 +60,7 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
                       onClick={() => {
                         formik.setFieldValue(
                           `groupedOptions`,
-                          remove(groupIndex, 1, formik.values.groupedOptions),
+                          remove(groupIndex, 1, formik.values.groupedOptions)
                         );
                       }}
                       size="large"
@@ -63,7 +75,7 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
                     onChange={(newOptions) => {
                       formik.setFieldValue(
                         `groupedOptions[${groupIndex}].children`,
-                        newOptions,
+                        newOptions
                       );
                     }}
                     newValue={() =>
@@ -82,7 +94,7 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
                       showValueField: !!formik.values.fn,
                       onMoveToGroup: (
                         movedItemIndex: number,
-                        moveToGroupIndex: number,
+                        moveToGroupIndex: number
                       ) => {
                         const item = groupedOption.children[movedItemIndex];
                         formik.setFieldValue(
@@ -93,28 +105,28 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
                               (option: Group<Option>) => ({
                                 ...option,
                                 children: [...option.children, item],
-                              }),
+                              })
                             ),
                             adjust(groupIndex, (option: Group<Option>) => ({
                               ...option,
                               children: remove(
                                 movedItemIndex,
                                 1,
-                                option.children,
+                                option.children
                               ),
-                            })),
-                          )(formik.values.groupedOptions),
+                            }))
+                          )(formik.values.groupedOptions)
                         );
                       },
                       groups: formik.values.groupedOptions.map(
-                        (opt: Group<Option>) => opt.title,
+                        (opt: Group<Option>) => opt.title
                       ),
                       schema: getOptionsSchemaByFn(formik.values.fn, schema, initialOptionVals),
                     }}
                   />
                 </Box>
               </Box>
-            ),
+            )
           )}
           <Box mt={1}>
             <Button
@@ -135,9 +147,14 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
         </Box>
       ) : (
         <ListManager
-          values={formik.values.options || []}
+          values={nonExclusiveOptions || []}
           onChange={(newOptions) => {
-            formik.setFieldValue("options", newOptions);
+            const newCombinedOptions =
+              newOptions.length === 0
+                ? []
+                : [...exclusiveOptions, ...newOptions];
+
+            formik.setFieldValue("options", newCombinedOptions);
           }}
           newValueLabel="add new option"
           newValue={() =>
@@ -156,6 +173,42 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
           }}
         />
       )}
+      {exclusiveOrOptionManagerShouldRender ? (
+        <Box mt={1}>
+            <ErrorWrapper error={formik.errors.allRequired as string}>
+            <ListManager
+              values={exclusiveOptions || []}
+              onChange={(newExclusiveOptions) => {
+                const newCombinedOptions = [
+                  ...nonExclusiveOptions,
+                  ...newExclusiveOptions,
+                ];
+                formik.setFieldValue("options", newCombinedOptions);
+              }}
+              newValueLabel='add "or" option'
+              maxItems={1}
+              disableDragAndDrop
+              newValue={() =>
+                ({
+                  data: {
+                    text: "",
+                    description: "",
+                    val: "",
+                    exclusive: true,
+                  },
+                }) as Option
+              }
+              Editor={BaseOptionsEditor}
+              editorExtraProps={{ 
+                showValueField: !!formik.values.fn,
+                schema: getOptionsSchemaByFn(formik.values.fn, schema, initialOptionVals),
+             }}
+            />
+        </ErrorWrapper>
+          </Box>
+      ) : (
+        <></>
+      )}
     </ModalSectionContent>
   );
 };
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
index 23d9bdd2e4..fa60443d44 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
@@ -1,37 +1,13 @@
-import Box from "@mui/material/Box";
-import Grid from "@mui/material/Grid";
-import { visuallyHidden } from "@mui/utils";
-import {
-  checklistValidationSchema,
-  getFlatOptions,
-  getLayout,
-} from "@planx/components/Checklist/model";
-import ImageButton from "@planx/components/shared/Buttons/ImageButton";
-import Card from "@planx/components/shared/Preview/Card";
-import { CardHeader } from "@planx/components/shared/Preview/CardHeader/CardHeader";
-import { getIn, useFormik } from "formik";
 import { useStore } from "pages/FlowEditor/lib/store";
-import React, { useState } from "react";
-import { ExpandableList, ExpandableListItem } from "ui/public/ExpandableList";
-import FormWrapper from "ui/public/FormWrapper";
-import FullWidthWrapper from "ui/public/FullWidthWrapper";
-import ChecklistItem from "ui/shared/ChecklistItem/ChecklistItem";
-import ErrorWrapper from "ui/shared/ErrorWrapper";
-import { object } from "yup";
+import React from "react";
 
 import { Props } from "../types";
-import { AutoAnsweredChecklist } from "./AutoAnsweredChecklist";
-import { getInitialExpandedGroups, toggleInArray } from "./helpers";
-
-export enum ChecklistLayout {
-  Basic,
-  Grouped,
-  Images,
-}
+import { AutoAnsweredChecklist } from "./components/AutoAnsweredChecklist";
+import { VisibleChecklist } from "./components/VisibleChecklist";
 
 const ChecklistComponent: React.FC<Props> = (props) => {
   const autoAnswerableOptions = useStore(
-    (state) => state.autoAnswerableOptions,
+    (state) => state.autoAnswerableOptions
   );
 
   if (props.neverAutoAnswer) {
@@ -49,162 +25,4 @@ const ChecklistComponent: React.FC<Props> = (props) => {
   return <VisibleChecklist {...props} />;
 };
 
-const VisibleChecklist: React.FC<Props> = (props) => {
-  const {
-    description = "",
-    groupedOptions,
-    handleSubmit,
-    howMeasured,
-    info,
-    options,
-    policyRef,
-    text,
-    img,
-    previouslySubmittedData,
-    id,
-  } = props;
-
-  const formik = useFormik<{ checked: Array<string> }>({
-    initialValues: {
-      checked: previouslySubmittedData?.answers || [],
-    },
-    onSubmit: (values) => {
-      handleSubmit?.({ answers: values.checked });
-    },
-    validateOnBlur: false,
-    validateOnChange: false,
-    validationSchema: object({
-      checked: checklistValidationSchema(props),
-    }),
-  });
-
-  const initialExpandedGroups = getInitialExpandedGroups(
-    groupedOptions,
-    previouslySubmittedData,
-  );
-
-  const [expandedGroups, setExpandedGroups] = useState<Array<number>>(
-    initialExpandedGroups,
-  );
-
-  const layout = getLayout({ options, groupedOptions });
-  const flatOptions = getFlatOptions({ options, groupedOptions });
-
-  const changeCheckbox = (id: string) => (_checked: any) => {
-    const newCheckedIds = formik.values.checked.includes(id)
-      ? formik.values.checked.filter((x) => x !== id)
-      : [...formik.values.checked, id];
-
-    formik.setFieldValue(
-      "checked",
-      newCheckedIds.sort((a, b) => {
-        const originalIds = flatOptions.map((cb) => cb.id);
-        return originalIds.indexOf(a) - originalIds.indexOf(b);
-      }),
-    );
-  };
-
-  return (
-    <Card handleSubmit={formik.handleSubmit} isValid>
-      <CardHeader
-        title={text}
-        description={description}
-        info={info}
-        policyRef={policyRef}
-        howMeasured={howMeasured}
-        img={img}
-      />
-      <FullWidthWrapper>
-        <ErrorWrapper error={getIn(formik.errors, "checked")} id={id}>
-          <Grid
-            container
-            spacing={layout === ChecklistLayout.Images ? 2 : 0}
-            component="fieldset"
-          >
-            <legend style={visuallyHidden}>{text}</legend>
-            {options?.map((option) =>
-              layout === ChecklistLayout.Basic ? (
-                <FormWrapper key={option.id}>
-                  <Grid item xs={12} key={option.data.text}>
-                    <ChecklistItem
-                      onChange={changeCheckbox(option.id)}
-                      label={option.data.text}
-                      id={option.id}
-                      checked={formik.values.checked.includes(option.id)}
-                    />
-                  </Grid>
-                </FormWrapper>
-              ) : (
-                <Grid
-                  item
-                  xs={12}
-                  sm={6}
-                  contentWrap={4}
-                  key={option.data.text}
-                >
-                  <ImageButton
-                    title={option.data.text}
-                    id={option.id}
-                    img={option.data.img}
-                    selected={formik.values.checked.includes(option.id)}
-                    onClick={changeCheckbox(option.id)}
-                    checkbox
-                  />
-                </Grid>
-              ),
-            )}
-
-            {groupedOptions && (
-              <FormWrapper>
-                <Grid item xs={12}>
-                  <ExpandableList>
-                    {groupedOptions.map((group, index) => {
-                      const isExpanded = expandedGroups.includes(index);
-                      return (
-                        <ExpandableListItem
-                          key={index}
-                          expanded={isExpanded}
-                          onToggle={() => {
-                            setExpandedGroups((previous) =>
-                              toggleInArray(index, previous),
-                            );
-                          }}
-                          headingId={`group-${index}-heading`}
-                          groupId={`group-${index}-content`}
-                          title={group.title}
-                        >
-                          <Box
-                            pt={0.5}
-                            pb={2}
-                            aria-labelledby={`group-${index}-heading`}
-                            id={`group-${index}-content`}
-                            data-testid={`group-${index}${
-                              isExpanded ? "-expanded" : ""
-                            }`}
-                          >
-                            {group.children.map((option) => (
-                              <ChecklistItem
-                                onChange={changeCheckbox(option.id)}
-                                key={option.data.text}
-                                label={option.data.text}
-                                id={option.id}
-                                checked={formik.values.checked.includes(
-                                  option.id,
-                                )}
-                              />
-                            ))}
-                          </Box>
-                        </ExpandableListItem>
-                      );
-                    })}
-                  </ExpandableList>
-                </Grid>
-              </FormWrapper>
-            )}
-          </Grid>
-        </ErrorWrapper>
-      </FullWidthWrapper>
-    </Card>
-  );
-};
 export default ChecklistComponent;
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/AutoAnsweredChecklist.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/AutoAnsweredChecklist.tsx
similarity index 90%
rename from editor.planx.uk/src/@planx/components/Checklist/Public/AutoAnsweredChecklist.tsx
rename to editor.planx.uk/src/@planx/components/Checklist/Public/components/AutoAnsweredChecklist.tsx
index 1bb8c1ae1a..bca1b81cc4 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/AutoAnsweredChecklist.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/AutoAnsweredChecklist.tsx
@@ -1,6 +1,6 @@
 import React, { useEffect } from "react";
 
-import { Props } from "../types";
+import { Props } from "../../types";
 
 // An auto-answered Checklist won't be seen by the user, but still leaves a breadcrumb
 export const AutoAnsweredChecklist: React.FC<
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/ChecklistItems.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/ChecklistItems.tsx
new file mode 100644
index 0000000000..16f676ea8e
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/ChecklistItems.tsx
@@ -0,0 +1,56 @@
+import Grid from "@mui/material/Grid";
+import { Option } from "@planx/components/shared";
+import ImageButton from "@planx/components/shared/Buttons/ImageButton";
+import { FormikProps } from "formik";
+import React from "react";
+import FormWrapper from "ui/public/FormWrapper";
+import ChecklistItem from "ui/shared/ChecklistItem/ChecklistItem";
+
+import { ChecklistLayout } from "./VisibleChecklist";
+
+interface Props {
+  nonExclusiveOptions: Option[];
+  layout: ChecklistLayout;
+  changeCheckbox: (id: string) => () => void;
+  formik: FormikProps<{ checked: Array<string> }>;
+  exclusiveOptionIsChecked: boolean;
+}
+
+export const ChecklistItems = ({
+  nonExclusiveOptions,
+  layout,
+  changeCheckbox,
+  formik,
+  exclusiveOptionIsChecked,
+}: Props) => (
+  <>
+    {nonExclusiveOptions.map((option: Option) =>
+      layout === ChecklistLayout.Basic ? (
+        <FormWrapper key={option.id}>
+          <Grid item xs={12} key={option.data.text}>
+            <ChecklistItem
+              onChange={changeCheckbox(option.id)}
+              label={option.data.text}
+              id={option.id}
+              checked={
+                formik.values.checked.includes(option.id) &&
+                !exclusiveOptionIsChecked
+              }
+            />
+          </Grid>
+        </FormWrapper>
+      ) : (
+        <Grid item xs={12} sm={6} contentWrap={4} key={option.data.text}>
+          <ImageButton
+            title={option.data.text}
+            id={option.id}
+            img={option.data.img}
+            selected={formik.values.checked.includes(option.id)}
+            onClick={changeCheckbox(option.id)}
+            checkbox
+          />
+        </Grid>
+      )
+    )}
+  </>
+);
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/ExclusiveChecklistItem.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/ExclusiveChecklistItem.tsx
new file mode 100644
index 0000000000..05cffb287f
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/ExclusiveChecklistItem.tsx
@@ -0,0 +1,32 @@
+import Grid from "@mui/material/Grid";
+import Typography from "@mui/material/Typography";
+import { FormikProps } from "formik";
+import React from "react";
+import FormWrapper from "ui/public/FormWrapper";
+import ChecklistItem from "ui/shared/ChecklistItem/ChecklistItem";
+
+import { Option } from "../../../shared";
+
+export const ExclusiveChecklistItem = ({
+  exclusiveOrOption,
+  changeCheckbox,
+  formik,
+}: {
+  exclusiveOrOption: Option;
+  changeCheckbox: (id: string) => () => void;
+  formik: FormikProps<{ checked: Array<string> }>;
+}) => (
+  <FormWrapper key={exclusiveOrOption.id}>
+    <Grid item xs={12} key={exclusiveOrOption.data.text}>
+      <Typography width={36} display="flex" justifyContent="center">
+        or
+      </Typography>
+      <ChecklistItem
+        onChange={changeCheckbox(exclusiveOrOption.id)}
+        label={exclusiveOrOption.data.text}
+        id={exclusiveOrOption.id}
+        checked={formik.values.checked.includes(exclusiveOrOption.id)}
+      />
+    </Grid>
+  </FormWrapper>
+);
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklistOptions.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklistOptions.tsx
new file mode 100644
index 0000000000..36259966fb
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklistOptions.tsx
@@ -0,0 +1,71 @@
+import Box from "@mui/material/Box";
+import Grid from "@mui/material/Grid";
+import { Group } from "@planx/components/Checklist/model";
+import { FormikProps } from "formik";
+import { Store } from "pages/FlowEditor/lib/store";
+import React from "react";
+import { ExpandableList, ExpandableListItem } from "ui/public/ExpandableList";
+import FormWrapper from "ui/public/FormWrapper";
+import ChecklistItem from "ui/shared/ChecklistItem/ChecklistItem";
+
+import { Option } from "../../../shared";
+import { useExpandedGroups } from "../hooks/useExpandedGroups";
+
+interface GroupedChecklistOptionsProps {
+  groupedOptions: Group<Option>[];
+  previouslySubmittedData: Store.UserData | undefined;
+  changeCheckbox: (id: string) => () => void;
+  formik: FormikProps<{ checked: Array<string> }>;
+}
+
+export const GroupedChecklistOptions = ({
+  groupedOptions,
+  previouslySubmittedData,
+  changeCheckbox,
+  formik,
+}: GroupedChecklistOptionsProps) => {
+  const { expandedGroups, toggleGroup } = useExpandedGroups(
+    groupedOptions,
+    previouslySubmittedData
+  );
+
+  return (
+    <FormWrapper>
+      <Grid item xs={12}>
+        <ExpandableList>
+          {groupedOptions.map((group: Group<Option>, index: number) => {
+            const isExpanded = expandedGroups.includes(index);
+            return (
+              <ExpandableListItem
+                key={index}
+                expanded={isExpanded}
+                onToggle={() => toggleGroup(index)}
+                headingId={`group-${index}-heading`}
+                groupId={`group-${index}-content`}
+                title={group.title}
+              >
+                <Box
+                  pt={0.5}
+                  pb={2}
+                  aria-labelledby={`group-${index}-heading`}
+                  id={`group-${index}-content`}
+                  data-testid={`group-${index}${isExpanded ? "-expanded" : ""}`}
+                >
+                  {group.children.map((option) => (
+                    <ChecklistItem
+                      onChange={changeCheckbox(option.id)}
+                      key={option.data.text}
+                      label={option.data.text}
+                      id={option.id}
+                      checked={formik.values.checked.includes(option.id)}
+                    />
+                  ))}
+                </Box>
+              </ExpandableListItem>
+            );
+          })}
+        </ExpandableList>
+      </Grid>
+    </FormWrapper>
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/VisibleChecklist.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/VisibleChecklist.tsx
new file mode 100644
index 0000000000..a2d730a1f5
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/VisibleChecklist.tsx
@@ -0,0 +1,138 @@
+import Grid from "@mui/material/Grid";
+import { visuallyHidden } from "@mui/utils";
+import { checklistValidationSchema } from "@planx/components/Checklist/model";
+import Card from "@planx/components/shared/Preview/Card";
+import { CardHeader } from "@planx/components/shared/Preview/CardHeader/CardHeader";
+import { getIn, useFormik } from "formik";
+import { partition } from "lodash";
+import React from "react";
+import FullWidthWrapper from "ui/public/FullWidthWrapper";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
+import { object } from "yup";
+
+import { Option } from "../../../shared";
+import { Props } from "../../types";
+import { useExclusiveOption } from "../hooks/useExclusiveOption";
+import { useSortedOptions } from "../hooks/useSortedOptions";
+import { ChecklistItems } from "./../components/ChecklistItems";
+import { ExclusiveChecklistItem } from "./../components/ExclusiveChecklistItem";
+import { toggleNonExclusiveCheckbox } from "./../helpers";
+import { GroupedChecklistOptions } from "./GroupedChecklistOptions";
+
+export enum ChecklistLayout {
+  Basic,
+  Grouped,
+  Images,
+}
+
+export const VisibleChecklist: React.FC<Props> = (props) => {
+  const {
+    description = "",
+    groupedOptions,
+    handleSubmit,
+    howMeasured,
+    info,
+    options,
+    policyRef,
+    text,
+    img,
+    previouslySubmittedData,
+    id,
+  } = props;
+
+  const formik = useFormik<{ checked: Array<string> }>({
+    initialValues: {
+      checked: previouslySubmittedData?.answers || [],
+    },
+    onSubmit: (values) => {
+      handleSubmit?.({ answers: values.checked });
+    },
+    validateOnBlur: false,
+    validateOnChange: false,
+    validationSchema: object({
+      checked: checklistValidationSchema(props),
+    }),
+  });
+
+  const { setCheckedFieldValue, layout } = useSortedOptions(
+    options,
+    groupedOptions,
+    formik
+  );
+
+  const [exclusiveOptions, nonExclusiveOptions]: Option[][] = partition(
+    options,
+    (option) => option.data.exclusive
+  );
+
+  const {
+    exclusiveOrOption,
+    exclusiveOptionIsChecked,
+    toggleExclusiveCheckbox,
+  } = useExclusiveOption(exclusiveOptions, formik);
+
+  const changeCheckbox = (id: string) => () => {
+    const currentCheckedIds = formik.values.checked;
+
+    const currentCheckboxIsExclusiveOption =
+      exclusiveOrOption && id === exclusiveOrOption.id;
+
+    if (currentCheckboxIsExclusiveOption) {
+      const newCheckedIds = toggleExclusiveCheckbox(id);
+      setCheckedFieldValue(newCheckedIds);
+      return;
+    }
+    const newCheckedIds = toggleNonExclusiveCheckbox(
+      id,
+      currentCheckedIds,
+      exclusiveOrOption
+    );
+    setCheckedFieldValue(newCheckedIds);
+  };
+
+  return (
+    <Card handleSubmit={formik.handleSubmit} isValid>
+      <CardHeader
+        title={text}
+        description={description}
+        info={info}
+        policyRef={policyRef}
+        howMeasured={howMeasured}
+        img={img}
+      />
+      <FullWidthWrapper>
+        <ErrorWrapper error={getIn(formik.errors, "checked")} id={id}>
+          <Grid
+            container
+            spacing={layout === ChecklistLayout.Images ? 2 : 0}
+            component="fieldset"
+          >
+            <legend style={visuallyHidden}>{text}</legend>
+            <ChecklistItems
+              nonExclusiveOptions={nonExclusiveOptions}
+              layout={layout}
+              changeCheckbox={changeCheckbox}
+              formik={formik}
+              exclusiveOptionIsChecked={exclusiveOptionIsChecked}
+            />
+            {exclusiveOrOption && (
+              <ExclusiveChecklistItem
+                exclusiveOrOption={exclusiveOrOption}
+                changeCheckbox={changeCheckbox}
+                formik={formik}
+              />
+            )}
+            {groupedOptions && (
+              <GroupedChecklistOptions
+                groupedOptions={groupedOptions}
+                previouslySubmittedData={previouslySubmittedData}
+                changeCheckbox={changeCheckbox}
+                formik={formik}
+              />
+            )}
+          </Grid>
+        </ErrorWrapper>
+      </FullWidthWrapper>
+    </Card>
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts b/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts
index 7a31a32932..986465fa46 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts
@@ -11,20 +11,52 @@ export function toggleInArray<T>(value: T, arr: Array<T>): Array<T> {
 
 export function groupHasOptionSelected(
   group: Group<Option>,
-  answers: string[],
+  answers: string[]
 ) {
   return group.children.some((child) => answers.some((id) => child.id === id));
 }
 
 export function getInitialExpandedGroups(
   groupedOptions?: Array<Group<Option>>,
-  previouslySubmittedData?: Store.UserData,
+  previouslySubmittedData?: Store.UserData
 ) {
   return (groupedOptions ?? ([] as Group<Option>[])).reduce(
     (acc, group, index) =>
       groupHasOptionSelected(group, previouslySubmittedData?.answers ?? [])
         ? [...acc, index]
         : acc,
-    [] as number[],
+    [] as number[]
   );
 }
+
+export const toggleCheckbox = (
+  thisCheckboxId: string,
+  currentlyCheckedOptionIds: string[]
+) => {
+  const toggleOff = currentlyCheckedOptionIds.filter(
+    (id) => id !== thisCheckboxId
+  );
+
+  const toggleOn = [...currentlyCheckedOptionIds, thisCheckboxId];
+
+  return currentlyCheckedOptionIds.includes(thisCheckboxId)
+    ? toggleOff
+    : toggleOn;
+};
+
+export const toggleNonExclusiveCheckbox = (
+  thisCheckboxId: string,
+  currentlyCheckedOptionIds: string[],
+  exclusiveOrOption: Option
+) => {
+  const newCheckedOptionIds = toggleCheckbox(
+    thisCheckboxId,
+    currentlyCheckedOptionIds
+  );
+  if (exclusiveOrOption) {
+    return newCheckedOptionIds.filter(
+      (id: string) => exclusiveOrOption && id !== exclusiveOrOption.id
+    );
+  }
+  return newCheckedOptionIds;
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExclusiveOption.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExclusiveOption.tsx
new file mode 100644
index 0000000000..85dd1d0a4f
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExclusiveOption.tsx
@@ -0,0 +1,23 @@
+import { FormikProps } from "formik";
+
+import { Option } from "../../../shared";
+
+export const useExclusiveOption = (
+  exclusiveOptions: Option[],
+  formik: FormikProps<{ checked: Array<string> }>
+) => {
+  const [exclusiveOrOption] = exclusiveOptions;
+
+  const exclusiveOptionIsChecked =
+    exclusiveOrOption && formik.values.checked.includes(exclusiveOrOption.id);
+
+  const toggleExclusiveCheckbox = (checkboxId: string) => {
+    return exclusiveOptionIsChecked ? [] : [checkboxId];
+  };
+
+  return {
+    exclusiveOrOption,
+    exclusiveOptionIsChecked,
+    toggleExclusiveCheckbox,
+  };
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExpandedGroups.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExpandedGroups.tsx
new file mode 100644
index 0000000000..effe2b291a
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExpandedGroups.tsx
@@ -0,0 +1,26 @@
+import { Group } from "@planx/components/Checklist/model";
+import { Store } from "pages/FlowEditor/lib/store";
+import { useState } from "react";
+
+import { Option } from "../../../shared";
+import { getInitialExpandedGroups, toggleInArray } from "./../helpers";
+
+export const useExpandedGroups = (
+  groupedOptions: Group<Option>[] | undefined,
+  previouslySubmittedData: Store.UserData | undefined
+) => {
+  const initialExpandedGroups = getInitialExpandedGroups(
+    groupedOptions,
+    previouslySubmittedData
+  );
+
+  const [expandedGroups, setExpandedGroups] = useState<Array<number>>(
+    initialExpandedGroups
+  );
+
+  const toggleGroup = (index: number) => {
+    setExpandedGroups((previous) => toggleInArray(index, previous));
+  };
+
+  return { expandedGroups, toggleGroup };
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useSortedOptions.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useSortedOptions.tsx
new file mode 100644
index 0000000000..36c0d632d8
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useSortedOptions.tsx
@@ -0,0 +1,28 @@
+import { FormikProps } from "formik";
+
+import { Option } from "../../../shared";
+import { getFlatOptions, getLayout, Group } from "../../model";
+
+export const useSortedOptions = (
+  options: Option[] | undefined,
+  groupedOptions: Group<Option>[] | undefined,
+  formik: FormikProps<{ checked: Array<string> }>
+) => {
+  const setCheckedFieldValue = (optionIds: string[]) => {
+    const sortedCheckedIds = sortCheckedIds(optionIds);
+    formik.setFieldValue("checked", sortedCheckedIds);
+  };
+
+  const layout = getLayout({ options, groupedOptions });
+  const flatOptions = getFlatOptions({ options, groupedOptions });
+
+  const sortCheckedIds = (ids: string[]): string[] => {
+    const originalIds = flatOptions.map((cb) => cb.id);
+    return ids.sort((a, b) => originalIds.indexOf(a) - originalIds.indexOf(b));
+  };
+
+  return {
+    setCheckedFieldValue,
+    layout,
+  };
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.exclusiveOr.test.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.exclusiveOr.test.tsx
new file mode 100644
index 0000000000..466d465c9f
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.exclusiveOr.test.tsx
@@ -0,0 +1,101 @@
+import { screen } from "@testing-library/react";
+import React from "react";
+import { setup } from "testUtils";
+import { vi } from "vitest";
+
+import Checklist from "../Public";
+import { optionsWithExclusiveOption } from "./mockOptions";
+import { pressContinue, pressOption } from "./testUtils";
+
+describe("when a user selects the exclusive 'or' option and nothing else", () => {
+  it("does not throw an error on submit", async () => {
+    const handleSubmit = vi.fn();
+
+    setup(
+      <Checklist
+        allRequired={false}
+        description=""
+        text="Which permanent structures have you lived in?"
+        handleSubmit={handleSubmit}
+        options={optionsWithExclusiveOption}
+      />,
+    );
+    expect(screen.getByRole("heading")).toHaveTextContent(
+      "Which permanent structures have you lived in?",
+    );
+
+    await pressOption("Tent");
+
+    await pressContinue();
+
+    expect(handleSubmit).toHaveBeenCalledWith({
+      answers: ["tent_id"],
+    });
+  });
+});
+
+describe.each([
+  {
+    optionType: "a non-exclusive",
+    optionLabelText: "Caravan",
+    oppositeOptionLabelText: "Tent",
+  },
+  {
+    optionType: "an exclusive",
+    optionLabelText: "Tent",
+    oppositeOptionLabelText: "Caravan",
+  },
+])(
+  "when a user selects $optionType option",
+  ({ oppositeOptionLabelText, optionLabelText }) => {
+    it("deselects it when the opposite type of option is selected", async () => {
+      const { getByLabelText } = setup(
+        <Checklist
+          allRequired={false}
+          description=""
+          text="Which permanent structures have you lived in?"
+          options={optionsWithExclusiveOption}
+        />,
+      );
+      const firstSelectedOption = getByLabelText(optionLabelText);
+      const secondSelectedOption = getByLabelText(oppositeOptionLabelText);
+
+      await pressOption(optionLabelText);
+
+      expect(firstSelectedOption).toHaveAttribute("checked");
+
+      await pressOption(oppositeOptionLabelText);
+
+      expect(firstSelectedOption).not.toHaveAttribute("checked");
+      expect(secondSelectedOption).toHaveAttribute("checked");
+    });
+  },
+);
+
+describe("when an exclusiveOr option is configured", () => {
+  it("does not affect the user's ability to select multiple other options", async () => {
+    const handleSubmit = vi.fn();
+
+    setup(
+      <Checklist
+        allRequired={false}
+        description=""
+        text="Which permanent structures have you lived in?"
+        handleSubmit={handleSubmit}
+        options={optionsWithExclusiveOption}
+      />,
+    );
+    expect(screen.getByRole("heading")).toHaveTextContent(
+      "Which permanent structures have you lived in?",
+    );
+
+    await pressOption("Caravan");
+    await pressOption("House");
+
+    await pressContinue();
+
+    expect(handleSubmit).toHaveBeenCalledWith({
+      answers: ["caravan_id", "house_id"],
+    });
+  });
+});
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.test.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.test.tsx
index c7a6804537..896dfe5d15 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.test.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/Public.test.tsx
@@ -1,15 +1,13 @@
 import { screen } from "@testing-library/react";
-// eslint-disable-next-line no-restricted-imports
-import userEvent, {
-  PointerEventsCheckLevel,
-} from "@testing-library/user-event";
 import React from "react";
 import { setup } from "testUtils";
 import { vi } from "vitest";
 import { axe } from "vitest-axe";
 
-import Checklist, { ChecklistLayout } from "../Public";
+import { ChecklistLayout } from "../components/VisibleChecklist";
+import Checklist from "../Public";
 import { groupedOptions, options } from "./mockOptions";
+import { pressContinue, pressOption } from "./testUtils";
 
 describe("Checklist Component - Grouped Layout", () => {
   it("answers are submitted in order they were supplied", async () => {
@@ -145,20 +143,11 @@ describe("Checklist Component - Basic & Images Layout", () => {
 
       expect(screen.getByRole("heading")).toHaveTextContent("home type?");
 
-      // Disabling pointerEventsCheck here allows us to bypass a false negative thrown by react-testing-library
-      // Tests fail to click the text elements when using ChecklistLayout.Images due to the pointerEvents: "none" style applied to textLabelWrapper, but the element can be clicked in all tested browsers
-      await userEvent.click(screen.getByText("Spaceship"), {
-        pointerEventsCheck: PointerEventsCheckLevel.Never,
-      });
-      await userEvent.click(screen.getByText("Flat"), {
-        pointerEventsCheck: PointerEventsCheckLevel.Never,
-      });
-      await userEvent.click(screen.getByText("House"), {
-        pointerEventsCheck: PointerEventsCheckLevel.Never,
-      });
-      await userEvent.click(screen.getByTestId("continue-button"), {
-        pointerEventsCheck: PointerEventsCheckLevel.Never,
-      });
+      await pressOption("Spaceship");
+      await pressOption("Flat");
+      await pressOption("House");
+
+      await pressContinue();
 
       // order matches the order of the options, not order they were clicked
       expect(handleSubmit).toHaveBeenCalledWith({
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/mockOptions.ts b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/mockOptions.ts
index 520ee04739..a5fc1a0074 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/mockOptions.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/mockOptions.ts
@@ -1,7 +1,8 @@
 import { Option } from "@planx/components/shared";
 
 import { Group } from "../../model";
-import { ChecklistLayout } from "../Public";
+import { ChecklistLayout } from "../components/VisibleChecklist";
+
 
 export const options: {
   [key in ChecklistLayout]?: Array<Option>;
@@ -63,6 +64,12 @@ export const options: {
     },
   ],
 };
+
+export const optionsWithExclusiveOption: Array<Option> = [
+  ...(options[ChecklistLayout.Basic] || []),
+  { id: "tent_id", data: { text: "Tent", exclusive: true } },
+];
+
 export const groupedOptions: Array<Group<Option>> = [
   {
     title: "Section 1",
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/tests/testUtils.ts b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/testUtils.ts
new file mode 100644
index 0000000000..b765ed7ee3
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/tests/testUtils.ts
@@ -0,0 +1,20 @@
+import { screen } from "@testing-library/react";
+// eslint-disable-next-line no-restricted-imports
+import userEvent, {
+  PointerEventsCheckLevel,
+} from "@testing-library/user-event";
+
+// Disabling pointerEventsCheck here allows us to bypass a false negative thrown by react-testing-library
+// Tests fail to click the text elements when using ChecklistLayout.Images due to the pointerEvents: "none" style applied to textLabelWrapper, but the element can be clicked in all tested browsers
+
+export const pressContinue = async () => {
+  await userEvent.click(screen.getByTestId("continue-button"), {
+    pointerEventsCheck: PointerEventsCheckLevel.Never,
+  });
+};
+
+export const pressOption = async (optionText: string) => {
+  await userEvent.click(screen.getByText(optionText), {
+    pointerEventsCheck: PointerEventsCheckLevel.Never,
+  });
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/model.ts b/editor.planx.uk/src/@planx/components/Checklist/model.ts
index 1ac40a10ee..67ab2f694c 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/model.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/model.ts
@@ -1,7 +1,7 @@
 import { array } from "yup";
 
 import { BaseNodeData, Option } from "../shared";
-import { ChecklistLayout } from "./Public/Public";
+import { ChecklistLayout } from "./Public/components/VisibleChecklist";
 
 export interface Group<T> {
   title: string;
@@ -31,7 +31,7 @@ interface ChecklistExpandableProps {
 }
 
 export const toggleExpandableChecklist = (
-  checklist: ChecklistExpandableProps,
+  checklist: ChecklistExpandableProps
 ): ChecklistExpandableProps => {
   if (checklist.options !== undefined && checklist.options.length > 0) {
     return {
@@ -102,8 +102,10 @@ export const checklistValidationSchema = ({
   allRequired,
   options,
   groupedOptions,
-}: Checklist) =>
-  array()
+}: Checklist) => {
+  const flatOptions = getFlatOptions({ options, groupedOptions });
+
+  return array()
     .required()
     .test({
       name: "atLeastOneChecked",
@@ -119,8 +121,8 @@ export const checklistValidationSchema = ({
         if (!allRequired) {
           return true;
         }
-        const flatOptions = getFlatOptions({ options, groupedOptions });
         const allChecked = checked && checked.length === flatOptions.length;
         return Boolean(allChecked);
       },
     });
+};
diff --git a/editor.planx.uk/src/@planx/components/PropertyInformation/model.ts b/editor.planx.uk/src/@planx/components/PropertyInformation/model.ts
index 1d4fc94794..ebb955a5e2 100644
--- a/editor.planx.uk/src/@planx/components/PropertyInformation/model.ts
+++ b/editor.planx.uk/src/@planx/components/PropertyInformation/model.ts
@@ -10,9 +10,9 @@ export const parseContent = (
   data: Record<string, any> | undefined,
 ): PropertyInformation => ({
   title: data?.title || "About the property",
-  description:
-    data?.description ||
-    "This is the information we currently have about the property, including its title boundary shown in blue from the Land Registry",
+  description: data?.description || defaultDescription,
   showPropertyTypeOverride: data?.showPropertyTypeOverride || false,
   ...parseBaseNodeData(data),
 });
+
+const defaultDescription = "<p>This is the information we currently have about the property.</p><p>The blue line shows the <strong>outline</strong> of the property (known as the title boundary). If this looks incorrect, go back a step and <strong>check you have selected the correct address</strong>.</p><p>We use this outline to create the site boundary where the project will take place. If your project covers a different area, you can change or redraw the site boundary on the next page.</p>";
diff --git a/editor.planx.uk/src/@planx/components/shared/index.ts b/editor.planx.uk/src/@planx/components/shared/index.ts
index 357548ee1e..529522b989 100644
--- a/editor.planx.uk/src/@planx/components/shared/index.ts
+++ b/editor.planx.uk/src/@planx/components/shared/index.ts
@@ -32,6 +32,7 @@ export interface Option {
     img?: string;
     text: string;
     val?: string;
+    exclusive?: true;
   };
 }
 
diff --git a/editor.planx.uk/src/@planx/graph/index.ts b/editor.planx.uk/src/@planx/graph/index.ts
index ce944f2857..cfdda42da7 100644
--- a/editor.planx.uk/src/@planx/graph/index.ts
+++ b/editor.planx.uk/src/@planx/graph/index.ts
@@ -188,21 +188,21 @@ const _add = (
   });
 };
 
+type NodeDataWithId = { id?: string; type?: number; data?: object };
+type AddContext = {
+  children?: Child[];
+  parent?: string;
+  before?: string;
+};
+
 export const add =
   (
-    {
-      id = uniqueId(),
-      ...nodeData
-    }: { id?: string; type?: number; data?: object },
+    { id = uniqueId(), ...nodeData }: NodeDataWithId,
     {
       children = [],
       parent = ROOT_NODE_KEY,
       before = undefined,
-    }: {
-      children?: Child[];
-      parent?: string;
-      before?: string;
-    } = {},
+    }: AddContext = {},
   ) =>
   (graph: Graph = {}): [Graph, Array<OT.Op>] =>
     wrap(graph, (draft) => {
diff --git a/editor.planx.uk/src/lib/featureFlags.ts b/editor.planx.uk/src/lib/featureFlags.ts
index 1e34728156..a3b30b5a0d 100644
--- a/editor.planx.uk/src/lib/featureFlags.ts
+++ b/editor.planx.uk/src/lib/featureFlags.ts
@@ -1,5 +1,5 @@
 // add/edit/remove feature flags in array below
-const AVAILABLE_FEATURE_FLAGS = ["FEE_BREAKDOWN"] as const;
+const AVAILABLE_FEATURE_FLAGS = ["FEE_BREAKDOWN", "EXCLUSIVE_OR"] as const;
 
 type FeatureFlag = (typeof AVAILABLE_FEATURE_FLAGS)[number];
 
diff --git a/editor.planx.uk/src/pages/FlowEditor/components/Flow/FeedbackLog/components/CollapsibleRow.tsx b/editor.planx.uk/src/pages/FlowEditor/components/Flow/FeedbackLog/components/CollapsibleRow.tsx
index 7103438632..cff2315916 100644
--- a/editor.planx.uk/src/pages/FlowEditor/components/Flow/FeedbackLog/components/CollapsibleRow.tsx
+++ b/editor.planx.uk/src/pages/FlowEditor/components/Flow/FeedbackLog/components/CollapsibleRow.tsx
@@ -167,7 +167,7 @@ export const CollapsibleRow: React.FC<CollapsibleRowProps> = (item) => {
         </TableCell>
       </TableRow>
       <TableRow sx={{ background: (theme) => theme.palette.background.paper }}>
-        <TableCell sx={{ padding: 0, border: "none" }} colSpan={4}>
+        <TableCell sx={{ padding: 0, border: "none" }} colSpan={5}>
           <Collapse
             in={open}
             timeout="auto"
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/getFlowSchema.test.ts b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/getFlowSchema.test.ts
new file mode 100644
index 0000000000..5124d35441
--- /dev/null
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/getFlowSchema.test.ts
@@ -0,0 +1,255 @@
+import { Store, useStore } from "../store";
+import { ComponentType as TYPES } from "@opensystemslab/planx-core/types";
+
+const { getState, setState } = useStore;
+const { getFlowSchema } = getState();
+
+describe("generating the schema for a flow", () => {
+  test("a unique ordered set of all component type data fields (fn) are returned as schema.nodes", () => {
+    setState({ flow });
+    expect(getFlowSchema()?.nodes).toEqual([
+      "property.type",
+      "proposal.projectType",
+      "proposal.startDate",
+    ]);
+  });
+
+  test("a unique ordered set of all answer type data values (val) are returned as schema.options", () => {
+    setState({ flow });
+    expect(getFlowSchema()?.options).toEqual([
+      "alter",
+      "changeOfUse",
+      "demolish",
+      "extend",
+      "internal",
+      "new",
+      "other",
+      "residential",
+      "residential.HMO",
+      "residential.dwelling.flat",
+      "residential.dwelling.house",
+      "unit",
+    ]);
+  });
+
+  test("filters and their flag values are omitted from the schema", () => {
+    setState({ flow: flowWithFilter });
+    expect(getFlowSchema()).toEqual({ nodes: [], options: [] });
+  });
+
+  test("an empty flow returns an empty schema", () => {
+    setState({ flow: {} });
+    expect(getFlowSchema()).toEqual({ nodes: [], options: [] });
+  });
+});
+
+const flow: Store.Flow = {
+  "_root": {
+    "edges": [
+      "PropertyQuestion",
+      "ProjectQuestion",
+      "DateInput"
+    ]
+  },
+  "0mUjzeoySp": {
+    "data": {
+      "val": "residential.dwelling.flat",
+      "text": "Flat"
+    },
+    "type": TYPES.Answer
+  },
+  "ProjectQuestion": {
+    "data": {
+      "fn": "proposal.projectType",
+      "text": "Do you have any supported project?"
+    },
+    "type": TYPES.Question,
+    "edges": [
+      "TtjHD8V5Z9",
+      "FPHuxFvNmb",
+      "lOtvc52uBR",
+      "ZI4h6FLszP",
+      "X1YhLhqImI",
+      "hWyONP37gE",
+      "7TBRnmE54E",
+      "NWR7GMCibW"
+    ]
+  },
+  "7TBRnmE54E": {
+    "data": {
+      "val": "unit",
+      "text": "Unit conversion"
+    },
+    "type": TYPES.Answer
+  },
+  "GranularPropertyQuestion": {
+    "data": {
+      "fn": "property.type",
+      "text": "What type of property is it?"
+    },
+    "type": TYPES.Question,
+    "edges": [
+      "vNV3AeoySp",
+      "0mUjzeoySp",
+      "r3dAheoySp"
+    ]
+  },
+  "FPHuxFvNmb": {
+    "data": {
+      "val": "alter",
+      "text": "Alteration"
+    },
+    "type": TYPES.Answer
+  },
+  "NWR7GMCibW": {
+    "data": {
+      "val": "other",
+      "text": "No"
+    },
+    "type": TYPES.Answer
+  },
+  "PropertyQuestion": {
+    "data": {
+      "fn": "property.type",
+      "text": "What type of property is it?",
+      "neverAutoAnswer": false,
+      "tags": []
+    },
+    "type": TYPES.Question,
+    "edges": [
+      "n14BneoySp",
+      "ZptuQeoySp"
+    ]
+  },
+  "TtjHD8V5Z9": {
+    "data": {
+      "val": "extend",
+      "text": "Extension"
+    },
+    "type": TYPES.Answer
+  },
+  "X1YhLhqImI": {
+    "data": {
+      "val": "new",
+      "text": "New build"
+    },
+    "type": TYPES.Answer
+  },
+  "ZI4h6FLszP": {
+    "data": {
+      "val": "changeOfUse",
+      "text": "Change of Use"
+    },
+    "type": TYPES.Answer
+  },
+  "ZptuQeoySp": {
+    "data": {
+      "text": "Something else",
+      "val": "other"
+    },
+    "type": TYPES.Answer
+  },
+  "hWyONP37gE": {
+    "data": {
+      "val": "demolish",
+      "text": "Demolition"
+    },
+    "type": TYPES.Answer
+  },
+  "lOtvc52uBR": {
+    "data": {
+      "val": "internal",
+      "text": "Internal"
+    },
+    "type": TYPES.Answer
+  },
+  "n14BneoySp": {
+    "data": {
+      "val": "residential",
+      "text": "Residential"
+    },
+    "type": TYPES.Answer,
+    "edges": [
+      "GranularPropertyQuestion"
+    ]
+  },
+  "r3dAheoySp": {
+    "data": {
+      "val": "residential.HMO",
+      "text": "HMO"
+    },
+    "type": TYPES.Answer
+  },
+  "vNV3AeoySp": {
+    "data": {
+      "val": "residential.dwelling.house",
+      "text": "House"
+    },
+    "type": TYPES.Answer
+  },
+  "DateInput": {
+    "type": TYPES.DateInput,
+    "data": {
+      "title": "When will the works begin?",
+      "fn": "proposal.startDate",
+      "min": "2024-01-01",
+      "max": "2050-01-01"
+    }
+  }
+};
+
+const flowWithFilter: Store.Flow = {
+  "_root": {
+    "edges": [
+      "Filter"
+    ]
+  },
+  "96L5yOhBQJ": {
+    "data": {
+      "val": "TR-DE_MINIMIS",
+      "text": "De minimis"
+    },
+    "type": TYPES.Answer
+  },
+  "G404TmcPne": {
+    "data": {
+      "val": "TR-MISSING_INFO",
+      "text": "Missing information"
+    },
+    "type": TYPES.Answer
+  },
+  "Filter": {
+    "data": {
+      "fn": "flag",
+      "category": "Works to trees & hedges"
+    },
+    "type": TYPES.Filter,
+    "edges": [
+      "G404TmcPne",
+      "UXbWvxQMPF",
+      "96L5yOhBQJ",
+      "W3ovRimuF3",
+      "xkiC61BIiG"
+    ]
+  },
+  "UXbWvxQMPF": {
+    "data": {
+      "val": "TR-REQUIRED",
+      "text": "Required"
+    },
+    "type": TYPES.Answer
+  },
+  "W3ovRimuF3": {
+    "data": {
+      "val": "TR-NOT_REQUIRED",
+      "text": "Not required"
+    },
+    "type": TYPES.Answer
+  },
+  "xkiC61BIiG": {
+    "data": {
+      "text": "No flag result"
+    },
+    "type": TYPES.Answer
+  }
+};
diff --git a/editor.planx.uk/src/ui/editor/ListManager/ListManager.tsx b/editor.planx.uk/src/ui/editor/ListManager/ListManager.tsx
index 1f8fc49f1c..1697254c4a 100644
--- a/editor.planx.uk/src/ui/editor/ListManager/ListManager.tsx
+++ b/editor.planx.uk/src/ui/editor/ListManager/ListManager.tsx
@@ -84,11 +84,7 @@ export default function ListManager<T, EditorExtraProps>(
                   }}
                   aria-label="Delete"
                   size="large"
-                  disabled={
-                    isViewOnly ||
-                    (props?.isFieldDisabled &&
-                      props.isFieldDisabled(item, index))
-                  }
+                  disabled={isViewOnly || props?.isFieldDisabled?.(item, index)}
                 >
                   <Delete />
                 </IconButton>
@@ -137,9 +133,9 @@ export default function ListManager<T, EditorExtraProps>(
                       <Box>
                         <IconButton
                           disableRipple
-                          {...(!props.disableDragAndDrop
-                            ? provided.dragHandleProps
-                            : { disabled: true || isViewOnly })}
+                          {...(props.disableDragAndDrop
+                            ? { disabled: true || isViewOnly }
+                            : provided.dragHandleProps)}
                           aria-label="Drag"
                           size="large"
                           disabled={isViewOnly}
@@ -163,9 +159,7 @@ export default function ListManager<T, EditorExtraProps>(
                           aria-label="Delete"
                           size="large"
                           disabled={
-                            isViewOnly ||
-                            (props?.isFieldDisabled &&
-                              props.isFieldDisabled(item, index))
+                            isViewOnly || props?.isFieldDisabled?.(item, index)
                           }
                         >
                           <Delete />
diff --git a/hasura.planx.uk/metadata/tables.yaml b/hasura.planx.uk/metadata/tables.yaml
index fe53e49f90..2557257e6c 100644
--- a/hasura.planx.uk/metadata/tables.yaml
+++ b/hasura.planx.uk/metadata/tables.yaml
@@ -2370,6 +2370,7 @@
           - created_at
           - domain
           - id
+          - metabase_id
           - name
           - slug
           - updated_at
@@ -2422,6 +2423,13 @@
           - updated_at
         filter: {}
   update_permissions:
+    - role: api
+      permission:
+        columns:
+          - metabase_id
+        filter: {}
+        check: {}
+      comment: ""
     - role: platformAdmin
       permission:
         columns:
diff --git a/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/down.sql b/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/down.sql
new file mode 100644
index 0000000000..c620678461
--- /dev/null
+++ b/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/down.sql
@@ -0,0 +1 @@
+alter table "public"."teams" drop column "metabase_id";
diff --git a/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/up.sql b/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/up.sql
new file mode 100644
index 0000000000..8ab49dd71b
--- /dev/null
+++ b/hasura.planx.uk/migrations/1733738650997_alter_table_public_teams_add_column_metabase_id/up.sql
@@ -0,0 +1,2 @@
+alter table "public"."teams" add column "metabase_id" integer
+ null;
diff --git a/hasura.planx.uk/tests/teams.test.js b/hasura.planx.uk/tests/teams.test.js
index 0c2aa8e35b..53defcf1b0 100644
--- a/hasura.planx.uk/tests/teams.test.js
+++ b/hasura.planx.uk/tests/teams.test.js
@@ -98,8 +98,15 @@ describe("teams", () => {
       expect(i.queries).toContain("teams");
     });
 
-    test("cannot create, update, or delete teams", () => {
-      expect(i).toHaveNoMutationsFor("teams");
+    test("can update teams", () => { 
+      expect(i.mutations).toContain("update_teams");
+      expect(i.mutations).toContain("update_teams_by_pk"); 
+      expect(i.mutations).toContain("update_teams_many"); 
+    }); 
+
+    test("cannot create or delete teams", () => {
+      expect(i.mutations).not.toContain("insert_teams"); 
+      expect(i.mutations).not.toContain("delete_teams");
     });
   });
 });