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 2fcc03c3de..3ba495ce53 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
@@ -7,18 +7,19 @@ 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 { 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>({
@@ -39,7 +40,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) => ({
@@ -66,14 +67,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();
@@ -81,6 +90,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;
     },
   });
@@ -160,19 +173,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)"
@@ -180,8 +194,9 @@ 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} />
@@ -189,4 +204,4 @@ export const ChecklistComponent: React.FC<ChecklistProps> = (props) => {
   );
 };
 
-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 388c021dac..c5fa9ee02b 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,6 +12,7 @@ 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";
 
@@ -17,6 +21,14 @@ import type { Group } from "../model";
 import ChecklistOptionsEditor from "./OptionsEditor";
 
 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;
+
   return (
     <ModalSectionContent subtitle="Options">
       {formik.values.groupedOptions ? (
@@ -42,7 +54,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"
@@ -57,7 +69,7 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
                     onChange={(newOptions) => {
                       formik.setFieldValue(
                         `groupedOptions[${groupIndex}].children`,
-                        newOptions,
+                        newOptions
                       );
                     }}
                     newValue={() =>
@@ -76,7 +88,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(
@@ -87,27 +99,27 @@ 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
                       ),
                     }}
                   />
                 </Box>
               </Box>
-            ),
+            )
           )}
           <Box mt={1}>
             <Button
@@ -128,9 +140,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={() =>
@@ -146,6 +163,39 @@ export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
           editorExtraProps={{ showValueField: !!formik.values.fn }}
         />
       )}
+      {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 }}
+            />
+        </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..2e5a08ded6 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
@@ -1,5 +1,6 @@
 import Box from "@mui/material/Box";
 import Grid from "@mui/material/Grid";
+import Typography from "@mui/material/Typography";
 import { visuallyHidden } from "@mui/utils";
 import {
   checklistValidationSchema,
@@ -10,6 +11,7 @@ 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 { partition } from "lodash";
 import { useStore } from "pages/FlowEditor/lib/store";
 import React, { useState } from "react";
 import { ExpandableList, ExpandableListItem } from "ui/public/ExpandableList";
@@ -19,9 +21,14 @@ import ChecklistItem from "ui/shared/ChecklistItem/ChecklistItem";
 import ErrorWrapper from "ui/shared/ErrorWrapper";
 import { object } from "yup";
 
+import { Option } from "../../shared";
 import { Props } from "../types";
 import { AutoAnsweredChecklist } from "./AutoAnsweredChecklist";
-import { getInitialExpandedGroups, toggleInArray } from "./helpers";
+import {
+  getInitialExpandedGroups,
+  toggleInArray,
+  toggleNonExclusiveCheckbox,
+} from "./helpers";
 
 export enum ChecklistLayout {
   Basic,
@@ -31,7 +38,7 @@ export enum ChecklistLayout {
 
 const ChecklistComponent: React.FC<Props> = (props) => {
   const autoAnswerableOptions = useStore(
-    (state) => state.autoAnswerableOptions,
+    (state) => state.autoAnswerableOptions
   );
 
   if (props.neverAutoAnswer) {
@@ -78,30 +85,59 @@ const VisibleChecklist: React.FC<Props> = (props) => {
     }),
   });
 
+  const setCheckedFieldValue = (optionIds: string[]) => {
+    const sortedCheckedIds = sortCheckedIds(optionIds);
+    formik.setFieldValue("checked", sortedCheckedIds);
+  };
+
   const initialExpandedGroups = getInitialExpandedGroups(
     groupedOptions,
-    previouslySubmittedData,
+    previouslySubmittedData
   );
 
   const [expandedGroups, setExpandedGroups] = useState<Array<number>>(
-    initialExpandedGroups,
+    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);
-      }),
+  const sortCheckedIds = (ids: string[]): string[] => {
+    const originalIds = flatOptions.map((cb) => cb.id);
+    return ids.sort((a, b) => originalIds.indexOf(a) - originalIds.indexOf(b));
+  };
+
+  const [exclusiveOptions, nonExclusiveOptions]: Option[][] = partition(
+    options,
+    (option) => option.data.exclusive
+  );
+
+  const exclusiveOrOption = exclusiveOptions[0];
+
+  const exclusiveOptionIsChecked =
+    exclusiveOrOption && formik.values.checked.includes(exclusiveOrOption.id);
+
+  const toggleExclusiveCheckbox = (checkboxId: string) => {
+    return exclusiveOptionIsChecked ? [] : [checkboxId];
+  };
+
+  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 (
@@ -122,7 +158,7 @@ const VisibleChecklist: React.FC<Props> = (props) => {
             component="fieldset"
           >
             <legend style={visuallyHidden}>{text}</legend>
-            {options?.map((option) =>
+            {nonExclusiveOptions.map((option) =>
               layout === ChecklistLayout.Basic ? (
                 <FormWrapper key={option.id}>
                   <Grid item xs={12} key={option.data.text}>
@@ -130,7 +166,10 @@ const VisibleChecklist: React.FC<Props> = (props) => {
                       onChange={changeCheckbox(option.id)}
                       label={option.data.text}
                       id={option.id}
-                      checked={formik.values.checked.includes(option.id)}
+                      checked={
+                        formik.values.checked.includes(option.id) &&
+                        !exclusiveOptionIsChecked
+                      }
                     />
                   </Grid>
                 </FormWrapper>
@@ -151,7 +190,25 @@ const VisibleChecklist: React.FC<Props> = (props) => {
                     checkbox
                   />
                 </Grid>
-              ),
+              )
+            )}
+            {exclusiveOrOption && (
+              <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>
             )}
 
             {groupedOptions && (
@@ -166,7 +223,7 @@ const VisibleChecklist: React.FC<Props> = (props) => {
                           expanded={isExpanded}
                           onToggle={() => {
                             setExpandedGroups((previous) =>
-                              toggleInArray(index, previous),
+                              toggleInArray(index, previous)
                             );
                           }}
                           headingId={`group-${index}-heading`}
@@ -189,7 +246,7 @@ const VisibleChecklist: React.FC<Props> = (props) => {
                                 label={option.data.text}
                                 id={option.id}
                                 checked={formik.values.checked.includes(
-                                  option.id,
+                                  option.id
                                 )}
                               />
                             ))}
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/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..1fbc9de324 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,8 +1,4 @@
 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";
@@ -10,6 +6,7 @@ import { axe } from "vitest-axe";
 
 import Checklist, { ChecklistLayout } 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 +142,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..c0b269a996 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
@@ -63,6 +63,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..d5ade4d68e 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/model.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/model.ts
@@ -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/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/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 />