diff --git a/api.planx.uk/package.json b/api.planx.uk/package.json
index f16e2697d2..3a09be8110 100644
--- a/api.planx.uk/package.json
+++ b/api.planx.uk/package.json
@@ -13,7 +13,7 @@
     "@airbrake/node": "^2.1.8",
     "@aws-sdk/client-s3": "^3.696.0",
     "@aws-sdk/s3-request-presigner": "^3.701.0",
-    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#574df5e",
+    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#ae6e7f4",
     "@types/isomorphic-fetch": "^0.0.36",
     "adm-zip": "^0.5.10",
     "axios": "^1.7.4",
diff --git a/api.planx.uk/pnpm-lock.yaml b/api.planx.uk/pnpm-lock.yaml
index 94cea064b8..b834c86383 100644
--- a/api.planx.uk/pnpm-lock.yaml
+++ b/api.planx.uk/pnpm-lock.yaml
@@ -21,8 +21,8 @@ dependencies:
     specifier: ^3.701.0
     version: 3.701.0
   '@opensystemslab/planx-core':
-    specifier: git+https://github.com/theopensystemslab/planx-core#574df5e
-    version: github.com/theopensystemslab/planx-core/574df5e
+    specifier: git+https://github.com/theopensystemslab/planx-core#ae6e7f4
+    version: github.com/theopensystemslab/planx-core/ae6e7f4
   '@types/isomorphic-fetch':
     specifier: ^0.0.36
     version: 0.0.36
@@ -7312,8 +7312,8 @@ packages:
     resolution: {integrity: sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==}
     dev: false
 
-  github.com/theopensystemslab/planx-core/574df5e:
-    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/574df5e}
+  github.com/theopensystemslab/planx-core/ae6e7f4:
+    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/ae6e7f4}
     name: '@opensystemslab/planx-core'
     version: 1.0.0
     prepare: true
diff --git a/e2e/tests/api-driven/package.json b/e2e/tests/api-driven/package.json
index 27ef5a4fb5..e9ab935b08 100644
--- a/e2e/tests/api-driven/package.json
+++ b/e2e/tests/api-driven/package.json
@@ -8,7 +8,7 @@
   "packageManager": "pnpm@8.6.6",
   "dependencies": {
     "@cucumber/cucumber": "^11.1.1",
-    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#574df5e",
+    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#ae6e7f4",
     "axios": "^1.7.4",
     "dotenv": "^16.3.1",
     "dotenv-expand": "^10.0.0",
diff --git a/e2e/tests/api-driven/pnpm-lock.yaml b/e2e/tests/api-driven/pnpm-lock.yaml
index 6dd53a997e..ba10cbeda0 100644
--- a/e2e/tests/api-driven/pnpm-lock.yaml
+++ b/e2e/tests/api-driven/pnpm-lock.yaml
@@ -9,8 +9,8 @@ dependencies:
     specifier: ^11.1.1
     version: 11.1.1
   '@opensystemslab/planx-core':
-    specifier: git+https://github.com/theopensystemslab/planx-core#574df5e
-    version: github.com/theopensystemslab/planx-core/574df5e
+    specifier: git+https://github.com/theopensystemslab/planx-core#ae6e7f4
+    version: github.com/theopensystemslab/planx-core/ae6e7f4
   axios:
     specifier: ^1.7.4
     version: 1.7.4
@@ -1137,7 +1137,7 @@ packages:
     dev: false
 
   /concat-map@0.0.1:
-    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+    resolution: {integrity: sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=}
     dev: false
 
   /convert-source-map@1.9.0:
@@ -3052,8 +3052,8 @@ packages:
     resolution: {integrity: sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==}
     dev: false
 
-  github.com/theopensystemslab/planx-core/574df5e:
-    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/574df5e}
+  github.com/theopensystemslab/planx-core/ae6e7f4:
+    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/ae6e7f4}
     name: '@opensystemslab/planx-core'
     version: 1.0.0
     prepare: true
diff --git a/e2e/tests/ui-driven/package.json b/e2e/tests/ui-driven/package.json
index 4b6a1da298..cea648c7ae 100644
--- a/e2e/tests/ui-driven/package.json
+++ b/e2e/tests/ui-driven/package.json
@@ -9,7 +9,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#574df5e",
+    "@opensystemslab/planx-core": "git+https://github.com/theopensystemslab/planx-core#ae6e7f4",
     "axios": "^1.7.4",
     "dotenv": "^16.3.1",
     "eslint": "^8.56.0",
diff --git a/e2e/tests/ui-driven/pnpm-lock.yaml b/e2e/tests/ui-driven/pnpm-lock.yaml
index a05fe5810e..098abde58a 100644
--- a/e2e/tests/ui-driven/pnpm-lock.yaml
+++ b/e2e/tests/ui-driven/pnpm-lock.yaml
@@ -6,8 +6,8 @@ settings:
 
 dependencies:
   '@opensystemslab/planx-core':
-    specifier: git+https://github.com/theopensystemslab/planx-core#574df5e
-    version: github.com/theopensystemslab/planx-core/574df5e
+    specifier: git+https://github.com/theopensystemslab/planx-core#ae6e7f4
+    version: github.com/theopensystemslab/planx-core/ae6e7f4
   axios:
     specifier: ^1.7.4
     version: 1.7.4
@@ -2601,8 +2601,8 @@ packages:
     resolution: {integrity: sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==}
     dev: false
 
-  github.com/theopensystemslab/planx-core/574df5e:
-    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/574df5e}
+  github.com/theopensystemslab/planx-core/ae6e7f4:
+    resolution: {tarball: https://codeload.github.com/theopensystemslab/planx-core/tar.gz/ae6e7f4}
     name: '@opensystemslab/planx-core'
     version: 1.0.0
     prepare: true
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 a197a89170..07aec4b9a0 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/Editor.tsx
@@ -1,4 +1,5 @@
 import { ComponentType as TYPES } from "@opensystemslab/planx-core/types";
+import { DataFieldAutocomplete } from "@planx/components/shared/DataFieldAutocomplete";
 import { FormikErrors, FormikValues, useFormik } from "formik";
 import React, { useEffect, useRef } from "react";
 import ImgInput from "ui/editor/ImgInput/ImgInput";
@@ -12,7 +13,6 @@ 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 { Option, parseBaseNodeData } from "../../shared";
 import { ICONS } from "../../shared/icons";
 import type { Checklist } from "../model";
@@ -41,7 +41,7 @@ export const ChecklistEditor: 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,7 +68,7 @@ export const ChecklistEditor: React.FC<ChecklistProps> = (props) => {
                   }),
             },
           },
-          processedOptions
+          processedOptions,
         );
       } else {
         alert(JSON.stringify({ type, ...values, options }, null, 2));
@@ -77,16 +77,16 @@ export const ChecklistEditor: React.FC<ChecklistProps> = (props) => {
     validate: ({ options, groupedOptions, allRequired, ...values }) => {
       const errors: FormikErrors<FormikValues> = {};
 
+      // Account for flat or expandable Checklist options
+      options = options || groupedOptions?.flatMap((group) => group.children);
+
       const exclusiveOptions: Option[] | undefined = options?.filter(
-        (option) => option.data.exclusive
+        (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();
       if (values.fn && !options?.some((option) => option.data.val)) {
         errors.fn =
           "At least one option must set a data value when the checklist has a data field";
@@ -164,7 +164,7 @@ export const ChecklistEditor: React.FC<ChecklistProps> = (props) => {
                 onChange={() =>
                   formik.setFieldValue(
                     "allRequired",
-                    !formik.values.allRequired
+                    !formik.values.allRequired,
                   )
                 }
                 label="All required"
@@ -177,7 +177,7 @@ export const ChecklistEditor: React.FC<ChecklistProps> = (props) => {
                 onChange={() =>
                   formik.setFieldValue(
                     "neverAutoAnswer",
-                    !formik.values.neverAutoAnswer
+                    !formik.values.neverAutoAnswer,
                   )
                 }
                 label="Always put to user (forgo automation)"
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 13d2afa804..232f9f7039 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/Options.tsx
@@ -1,213 +1,74 @@
-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 { getOptionsSchemaByFn } from "@planx/components/shared/utils";
 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";
 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 { useInitialOptions } from "../Public/hooks/useInitialOptions";
+import { ExclusiveOrOptionManager } from "./components/ExclusiveOrOptionManager";
+import { GroupedOptions } from "./components/GroupedOptions";
+import ChecklistOptionsEditor from "./components/OptionsEditor";
 
 export const Options: React.FC<{ formik: FormikHookReturn }> = ({ formik }) => {
   const [exclusiveOptions, nonExclusiveOptions]: Option[][] = partition(
     formik.values.options,
-    (option) => option.data.exclusive
+    (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);
+    hasFeatureFlag("EXCLUSIVE_OR") && nonExclusiveOptions.length > 0;
+
+  const { schema, initialOptionVals } = useInitialOptions(formik);
 
   return (
     <ModalSectionContent subtitle="Options">
       {formik.values.groupedOptions ? (
-        <Box>
-          {formik.values.groupedOptions.map(
-            (groupedOption: Group<Option>, groupIndex: number) => (
-              <Box key={groupIndex} mt={groupIndex === 0 ? 0 : 4}>
-                <Box display="flex" pb={1}>
-                  <InputRow>
-                    <Input
-                      required
-                      format="bold"
-                      name={`groupedOptions[${groupIndex}].title`}
-                      value={groupedOption.title}
-                      placeholder="Section Title"
-                      onChange={formik.handleChange}
-                    />
-                  </InputRow>
-                  <Box flex={0}>
-                    <IconButton
-                      title="Delete group"
-                      aria-label="Delete group"
-                      onClick={() => {
-                        formik.setFieldValue(
-                          `groupedOptions`,
-                          remove(groupIndex, 1, formik.values.groupedOptions)
-                        );
-                      }}
-                      size="large"
-                    >
-                      <Delete />
-                    </IconButton>
-                  </Box>
-                </Box>
-                <Box pl={{ md: 2 }}>
-                  <ListManager
-                    values={groupedOption.children}
-                    onChange={(newOptions) => {
-                      formik.setFieldValue(
-                        `groupedOptions[${groupIndex}].children`,
-                        newOptions
-                      );
-                    }}
-                    newValue={() =>
-                      ({
-                        data: {
-                          text: "",
-                          description: "",
-                          val: "",
-                        },
-                      }) as Option
-                    }
-                    newValueLabel="add new option"
-                    Editor={ChecklistOptionsEditor}
-                    editorExtraProps={{
-                      groupIndex,
-                      showValueField: !!formik.values.fn,
-                      onMoveToGroup: (
-                        movedItemIndex: number,
-                        moveToGroupIndex: number
-                      ) => {
-                        const item = groupedOption.children[movedItemIndex];
-                        formik.setFieldValue(
-                          "groupedOptions",
-                          compose(
-                            adjust(
-                              moveToGroupIndex,
-                              (option: Group<Option>) => ({
-                                ...option,
-                                children: [...option.children, item],
-                              })
-                            ),
-                            adjust(groupIndex, (option: Group<Option>) => ({
-                              ...option,
-                              children: remove(
-                                movedItemIndex,
-                                1,
-                                option.children
-                              ),
-                            }))
-                          )(formik.values.groupedOptions)
-                        );
-                      },
-                      groups: formik.values.groupedOptions.map(
-                        (opt: Group<Option>) => opt.title
-                      ),
-                      schema: getOptionsSchemaByFn(formik.values.fn, schema, initialOptionVals),
-                    }}
-                  />
-                </Box>
-              </Box>
-            )
-          )}
-          <Box mt={1}>
-            <Button
-              size="large"
-              onClick={() => {
-                formik.setFieldValue(`groupedOptions`, [
-                  ...formik.values.groupedOptions,
-                  {
-                    title: "",
-                    children: [],
-                  },
-                ]);
-              }}
-            >
-              add new group
-            </Button>
-          </Box>
-        </Box>
+        <GroupedOptions formik={formik} />
       ) : (
-        <ListManager
-          values={nonExclusiveOptions || []}
-          onChange={(newOptions) => {
-            const newCombinedOptions =
-              newOptions.length === 0
-                ? []
-                : [...exclusiveOptions, ...newOptions];
+        <>
+          <ListManager
+            values={nonExclusiveOptions || []}
+            onChange={(newOptions) => {
+              const newCombinedOptions =
+                newOptions.length === 0
+                  ? []
+                  : [...exclusiveOptions, ...newOptions];
 
-            formik.setFieldValue("options", newCombinedOptions);
-          }}
-          newValueLabel="add new option"
-          newValue={() =>
-            ({
-              data: {
-                text: "",
-                description: "",
-                val: "",
-              },
-            }) as Option
-          }
-          Editor={ChecklistOptionsEditor}
-          editorExtraProps={{ 
-            showValueField: !!formik.values.fn,
-            schema: getOptionsSchemaByFn(formik.values.fn, schema, initialOptionVals),
-          }}
-        />
-      )}
-      {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),
-             }}
+              formik.setFieldValue("options", newCombinedOptions);
+            }}
+            newValueLabel="add new option"
+            newValue={() =>
+              ({
+                data: {
+                  text: "",
+                  description: "",
+                  val: "",
+                },
+              }) as Option
+            }
+            Editor={ChecklistOptionsEditor}
+            editorExtraProps={{
+              showValueField: !!formik.values.fn,
+              schema: getOptionsSchemaByFn(
+                formik.values.fn,
+                schema,
+                initialOptionVals,
+              ),
+            }}
+          />
+          {exclusiveOrOptionManagerShouldRender ? (
+            <ExclusiveOrOptionManager
+              formik={formik}
+              exclusiveOptions={exclusiveOptions}
+              nonExclusiveOptions={nonExclusiveOptions}
             />
-        </ErrorWrapper>
-          </Box>
-      ) : (
-        <></>
+          ) : (
+            <></>
+          )}
+        </>
       )}
     </ModalSectionContent>
   );
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Editor/components/ExclusiveOrOptionManager.tsx b/editor.planx.uk/src/@planx/components/Checklist/Editor/components/ExclusiveOrOptionManager.tsx
new file mode 100644
index 0000000000..594022c06a
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/components/ExclusiveOrOptionManager.tsx
@@ -0,0 +1,85 @@
+import Box from "@mui/material/Box";
+import { BaseOptionsEditor } from "@planx/components/shared/BaseOptionsEditor";
+import { getOptionsSchemaByFn } from "@planx/components/shared/utils";
+import React from "react";
+import { FormikHookReturn } from "types";
+import ListManager from "ui/editor/ListManager/ListManager";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
+
+import { Option } from "../../../shared";
+import { Group } from "../../model";
+import { useInitialOptions } from "../../Public/hooks/useInitialOptions";
+
+interface Props {
+  formik: FormikHookReturn;
+  exclusiveOptions: Option[];
+  nonExclusiveOptions: Option[] | Array<Group<Option>>;
+  groupIndex?: number;
+  grouped?: true;
+}
+
+export const ExclusiveOrOptionManager = ({
+  formik,
+  exclusiveOptions,
+  nonExclusiveOptions,
+  groupIndex,
+  grouped,
+}: Props) => {
+  const { schema, initialOptionVals } = useInitialOptions(formik);
+
+  return (
+    <Box mt={2}>
+      <ErrorWrapper error={formik.errors.allRequired as string}>
+        <Box mt={1}>
+          <ListManager
+            values={exclusiveOptions || []}
+            onChange={(newExclusiveOptions) => {
+              if (grouped) {
+                const exclusiveOptionGroup = {
+                  title: "Or",
+                  exclusive: true,
+                  children: newExclusiveOptions,
+                };
+                const newCombinedOptions = [
+                  ...nonExclusiveOptions,
+                  exclusiveOptionGroup,
+                ];
+                formik.setFieldValue("groupedOptions", newCombinedOptions);
+                return;
+              }
+              const newCombinedOptions = [
+                ...nonExclusiveOptions,
+                ...newExclusiveOptions,
+              ];
+              formik.setFieldValue("options", newCombinedOptions);
+            }}
+            newValueLabel='add "or" option'
+            maxItems={1}
+            disableDragAndDrop
+            newValue={() => {
+              return {
+                data: {
+                  text: "",
+                  description: "",
+                  val: "",
+                  exclusive: true,
+                },
+              } as Option;
+            }}
+            Editor={BaseOptionsEditor}
+            editorExtraProps={{
+              showValueField: !!formik.values.fn,
+              groupIndex,
+              optionPlaceholder: "Exclusive 'or' option",
+              schema: getOptionsSchemaByFn(
+                formik.values.fn,
+                schema,
+                initialOptionVals,
+              ),
+            }}
+          />
+        </Box>
+      </ErrorWrapper>
+    </Box>
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Editor/components/GroupedOptions.tsx b/editor.planx.uk/src/@planx/components/Checklist/Editor/components/GroupedOptions.tsx
new file mode 100644
index 0000000000..e817264790
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Editor/components/GroupedOptions.tsx
@@ -0,0 +1,154 @@
+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 { getOptionsSchemaByFn } from "@planx/components/shared/utils";
+import { hasFeatureFlag } from "lib/featureFlags";
+import adjust from "ramda/src/adjust";
+import compose from "ramda/src/compose";
+import remove from "ramda/src/remove";
+import React from "react";
+import { FormikHookReturn } from "types";
+import ListManager from "ui/editor/ListManager/ListManager";
+import Input from "ui/shared/Input/Input";
+import InputRow from "ui/shared/InputRow";
+
+import { Option } from "../../../shared";
+import type { Group } from "../../model";
+import { partitionGroupedOptions } from "../../Public/helpers";
+import { useInitialOptions } from "../../Public/hooks/useInitialOptions";
+import { ExclusiveOrOptionManager } from "./ExclusiveOrOptionManager";
+import ChecklistOptionsEditor from "./OptionsEditor";
+
+interface Props {
+  formik: FormikHookReturn;
+}
+
+export const GroupedOptions = ({ formik }: Props) => {
+  const { schema, initialOptionVals } = useInitialOptions(formik);
+
+  const [exclusiveOptions, nonExclusiveOptionGroups] = partitionGroupedOptions(
+    formik.values.groupedOptions,
+  );
+
+  const exclusiveOrOptionManagerShouldRender =
+    hasFeatureFlag("EXCLUSIVE_OR") && nonExclusiveOptionGroups.length > 0;
+
+  return (
+    <Box>
+      {nonExclusiveOptionGroups.map(
+        (groupedOption: Group<Option>, groupIndex: number) => (
+          <Box key={groupIndex} mt={groupIndex === 0 ? 0 : 4}>
+            <Box display="flex" pb={1}>
+              <InputRow>
+                <Input
+                  required
+                  format="bold"
+                  name={`groupedOptions[${groupIndex}].title`}
+                  value={groupedOption.title}
+                  placeholder="Section Title"
+                  onChange={formik.handleChange}
+                />
+              </InputRow>
+              <Box flex={0}>
+                <IconButton
+                  title="Delete group"
+                  aria-label="Delete group"
+                  onClick={() => {
+                    formik.setFieldValue(
+                      `groupedOptions`,
+                      remove(groupIndex, 1, formik.values.groupedOptions),
+                    );
+                  }}
+                  size="large"
+                >
+                  <Delete />
+                </IconButton>
+              </Box>
+            </Box>
+            <Box pl={{ md: 2 }}>
+              <ListManager
+                values={groupedOption.children}
+                onChange={(newOptions) => {
+                  formik.setFieldValue(
+                    `groupedOptions[${groupIndex}].children`,
+                    newOptions,
+                  );
+                }}
+                newValue={() =>
+                  ({
+                    data: {
+                      text: "",
+                      description: "",
+                      val: "",
+                    },
+                  }) as Option
+                }
+                newValueLabel="add new option"
+                Editor={ChecklistOptionsEditor}
+                editorExtraProps={{
+                  groupIndex,
+                  showValueField: !!formik.values.fn,
+                  onMoveToGroup: (
+                    movedItemIndex: number,
+                    moveToGroupIndex: number,
+                  ) => {
+                    const item = groupedOption.children[movedItemIndex];
+                    formik.setFieldValue(
+                      "groupedOptions",
+                      compose(
+                        adjust(moveToGroupIndex, (option: Group<Option>) => ({
+                          ...option,
+                          children: [...option.children, item],
+                        })),
+                        adjust(groupIndex, (option: Group<Option>) => ({
+                          ...option,
+                          children: remove(movedItemIndex, 1, option.children),
+                        })),
+                      )(formik.values.groupedOptions),
+                    );
+                  },
+                  groups: nonExclusiveOptionGroups.map(
+                    (opt: Group<Option>) => opt.title,
+                  ),
+                  schema: getOptionsSchemaByFn(
+                    formik.values.fn,
+                    schema,
+                    initialOptionVals,
+                  ),
+                }}
+              />
+            </Box>
+          </Box>
+        ),
+      )}
+      <Box mt={1}>
+        <Button
+          size="large"
+          onClick={() => {
+            formik.setFieldValue(`groupedOptions`, [
+              ...nonExclusiveOptionGroups,
+              {
+                title: "",
+                children: [],
+              },
+              ...exclusiveOptions,
+            ]);
+          }}
+        >
+          add new group
+        </Button>
+      </Box>
+      {exclusiveOrOptionManagerShouldRender ? (
+        <ExclusiveOrOptionManager
+          formik={formik}
+          grouped
+          exclusiveOptions={exclusiveOptions[0]?.children}
+          nonExclusiveOptions={nonExclusiveOptionGroups}
+        />
+      ) : (
+        <></>
+      )}
+    </Box>
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Editor/OptionsEditor.tsx b/editor.planx.uk/src/@planx/components/Checklist/Editor/components/OptionsEditor.tsx
similarity index 100%
rename from editor.planx.uk/src/@planx/components/Checklist/Editor/OptionsEditor.tsx
rename to editor.planx.uk/src/@planx/components/Checklist/Editor/components/OptionsEditor.tsx
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 73710bb574..7a23842d9d 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/Public.tsx
@@ -1,152 +1,17 @@
-import Grid from "@mui/material/Grid";
-import { visuallyHidden } from "@mui/utils";
-import {
-  ChecklistLayout,
-  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, { useEffect } from "react";
-import FullWidthWrapper from "ui/public/FullWidthWrapper";
-import ErrorWrapper from "ui/shared/ErrorWrapper";
-import { object } from "yup";
+import React from "react";
 
-import { Option } from "../../shared";
-import { Props } from "../types";
-import { ChecklistItems } from "./components/ChecklistItems";
-import { ExclusiveChecklistItem } from "./components/ExclusiveChecklistItem";
-import { GroupedChecklistOptions } from "./components/GroupedChecklistOptions";
-import { toggleNonExclusiveCheckbox } from "./helpers";
-import { useExclusiveOption } from "./hooks/useExclusiveOption";
-import { useSortedOptions } from "./hooks/useSortedOptions";
+import { PublicChecklistProps } from "../types";
+import { Checklist } from "./components/Checklist";
+import { GroupedChecklist } from "./components/GroupedChecklist";
 
-const ChecklistComponent: React.FC<Props> = (props) => {
-  const {
-    description = "",
-    groupedOptions,
-    handleSubmit,
-    howMeasured,
-    info,
-    options,
-    policyRef,
-    text,
-    img,
-    previouslySubmittedData,
-    id,
-    autoAnswers,
-  } = 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);
-  };
-
-  // Auto-answered Checklists still set a breadcrumb even though they render null
-  useEffect(() => {
-    if (autoAnswers) {
-      handleSubmit?.({
-        answers: autoAnswers,
-        auto: true,
-      });
-    }
-  }, [autoAnswers]);
-
-  // Auto-answered Checklists are not publicly visible
-  if (autoAnswers) {
-    return null;
-  }
+const ChecklistComponent: React.FC<PublicChecklistProps> = (props) => {
+  const { groupedOptions, options } = props;
 
   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>
+    <>
+      {groupedOptions && <GroupedChecklist {...props} />}
+      {options && <Checklist {...props} />}
+    </>
   );
 };
 
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/Checklist.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/Checklist.tsx
new file mode 100644
index 0000000000..954d74c658
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/Checklist.tsx
@@ -0,0 +1,132 @@
+import Grid from "@mui/material/Grid";
+import { visuallyHidden } from "@mui/utils";
+import {
+  ChecklistLayout,
+  checklistValidationSchema,
+} from "@planx/components/Checklist/model";
+import { Option } from "@planx/components/shared";
+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, { useEffect } from "react";
+import FullWidthWrapper from "ui/public/FullWidthWrapper";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
+import { object } from "yup";
+
+import { PublicChecklistProps } from "../../types";
+import { changeCheckbox } from "../helpers";
+import { useExclusiveOption } from "../hooks/useExclusiveOption";
+import { useSortedOptions } from "../hooks/useSortedOptions";
+import { ChecklistItems } from "./ChecklistItems";
+import { ExclusiveChecklistItem } from "./ExclusiveChecklistItem";
+
+export const Checklist: React.FC<PublicChecklistProps> = (props) => {
+  const {
+    description = "",
+    groupedOptions,
+    handleSubmit,
+    howMeasured,
+    info,
+    options,
+    policyRef,
+    text,
+    img,
+    previouslySubmittedData,
+    id,
+    autoAnswers,
+  } = 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 toggleCheckbox = (id: string) =>
+    changeCheckbox({
+      id,
+      setCheckedFieldValue,
+      currentCheckedIds: formik.values.checked,
+      exclusiveOrOption,
+      toggleExclusiveCheckbox,
+    });
+
+  // Auto-answered Checklists still set a breadcrumb even though they render null
+  useEffect(() => {
+    if (autoAnswers) {
+      handleSubmit?.({
+        answers: autoAnswers,
+        auto: true,
+      });
+    }
+  }, [autoAnswers, handleSubmit]);
+
+  // Auto-answered Checklists are not publicly visible
+  if (autoAnswers) {
+    return null;
+  }
+
+  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={toggleCheckbox}
+              formik={formik}
+              exclusiveOptionIsChecked={exclusiveOptionIsChecked}
+            />
+            {exclusiveOrOption && (
+              <ExclusiveChecklistItem
+                exclusiveOrOption={exclusiveOrOption}
+                changeCheckbox={toggleCheckbox}
+                formik={formik}
+              />
+            )}
+          </Grid>
+        </ErrorWrapper>
+      </FullWidthWrapper>
+    </Card>
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklist.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklist.tsx
new file mode 100644
index 0000000000..1e8da1a7c3
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/components/GroupedChecklist.tsx
@@ -0,0 +1,129 @@
+import Box from "@mui/material/Box";
+import Grid from "@mui/material/Grid";
+import { visuallyHidden } from "@mui/utils";
+import {
+  ChecklistLayout,
+  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 React, { useEffect } from "react";
+import FullWidthWrapper from "ui/public/FullWidthWrapper";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
+import { object } from "yup";
+
+import { PublicChecklistProps } from "../../types";
+import { changeCheckbox, partitionGroupedOptions } from "../helpers";
+import { useExclusiveOptionInGroupedChecklist } from "../hooks/useExclusiveOption";
+import { useSortedOptions } from "../hooks/useSortedOptions";
+import { ExclusiveChecklistItem } from "./ExclusiveChecklistItem";
+import { GroupedChecklistOptions } from "./GroupedChecklistOptions";
+
+export const GroupedChecklist: React.FC<PublicChecklistProps> = (props) => {
+  const {
+    description = "",
+    groupedOptions,
+    handleSubmit,
+    howMeasured,
+    info,
+    options,
+    policyRef,
+    text,
+    img,
+    previouslySubmittedData,
+    id,
+    autoAnswers,
+  } = 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 [exclusiveOptionGroups, nonExclusiveOptionGroups] =
+    partitionGroupedOptions(groupedOptions!);
+
+  const { exclusiveOrOptionGroup, toggleExclusiveCheckbox } =
+    useExclusiveOptionInGroupedChecklist(exclusiveOptionGroups, formik);
+
+  const toggleCheckbox = (id: string) =>
+    changeCheckbox({
+      id,
+      setCheckedFieldValue,
+      currentCheckedIds: formik.values.checked,
+      exclusiveOrOption: exclusiveOrOptionGroup?.children[0],
+      toggleExclusiveCheckbox,
+    });
+
+  // Auto-answered Checklists still set a breadcrumb even though they render null
+  useEffect(() => {
+    if (autoAnswers) {
+      handleSubmit?.({
+        answers: autoAnswers,
+        auto: true,
+      });
+    }
+  }, [autoAnswers, handleSubmit]);
+
+  // Auto-answered Checklists are not publicly visible
+  if (autoAnswers) {
+    return null;
+  }
+
+  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>
+            {nonExclusiveOptionGroups && (
+              <GroupedChecklistOptions
+                groupedOptions={nonExclusiveOptionGroups}
+                previouslySubmittedData={previouslySubmittedData}
+                changeCheckbox={toggleCheckbox}
+                formik={formik}
+              />
+            )}
+            <Box pt={1}>
+              {exclusiveOrOptionGroup && (
+                <ExclusiveChecklistItem
+                  exclusiveOrOption={exclusiveOrOptionGroup?.children[0]}
+                  changeCheckbox={toggleCheckbox}
+                  formik={formik}
+                />
+              )}
+            </Box>
+          </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 986465fa46..6c7e4afe44 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/helpers.ts
@@ -1,4 +1,5 @@
 import { type Group } from "@planx/components/Checklist/model";
+import { partition } from "lodash";
 import { Store } from "pages/FlowEditor/lib/store";
 
 import { Option } from "../../shared";
@@ -11,30 +12,30 @@ 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[]
+  currentlyCheckedOptionIds: string[],
 ) => {
   const toggleOff = currentlyCheckedOptionIds.filter(
-    (id) => id !== thisCheckboxId
+    (id) => id !== thisCheckboxId,
   );
 
   const toggleOn = [...currentlyCheckedOptionIds, thisCheckboxId];
@@ -47,16 +48,59 @@ export const toggleCheckbox = (
 export const toggleNonExclusiveCheckbox = (
   thisCheckboxId: string,
   currentlyCheckedOptionIds: string[],
-  exclusiveOrOption: Option
+  exclusiveOrOption: Option,
 ) => {
   const newCheckedOptionIds = toggleCheckbox(
     thisCheckboxId,
-    currentlyCheckedOptionIds
+    currentlyCheckedOptionIds,
   );
   if (exclusiveOrOption) {
     return newCheckedOptionIds.filter(
-      (id: string) => exclusiveOrOption && id !== exclusiveOrOption.id
+      (id: string) => exclusiveOrOption && id !== exclusiveOrOption.id,
     );
   }
   return newCheckedOptionIds;
 };
+
+export const partitionGroupedOptions = (
+  groupedOptions: Group<Option>[],
+): Group<Option>[][] => {
+  const [exclusiveOptionGroup, nonExclusiveOptionGroups] = partition(
+    groupedOptions,
+    (group: Group<Option>) =>
+      group.exclusive ||
+      group.children.some((child) => child.data.exclusive === true),
+  );
+  return [exclusiveOptionGroup, nonExclusiveOptionGroups];
+};
+
+export const changeCheckbox =
+  ({
+    id,
+    setCheckedFieldValue,
+    currentCheckedIds,
+    exclusiveOrOption,
+    toggleExclusiveCheckbox,
+  }: {
+    id: string;
+    setCheckedFieldValue: (optionIds: string[]) => void;
+    currentCheckedIds: string[];
+    exclusiveOrOption: Option;
+    toggleExclusiveCheckbox: (checkboxId: string) => string[];
+  }) =>
+  () => {
+    const currentCheckboxIsExclusiveOption =
+      exclusiveOrOption && id === exclusiveOrOption.id;
+
+    if (currentCheckboxIsExclusiveOption) {
+      const newCheckedIds = toggleExclusiveCheckbox(id);
+      setCheckedFieldValue(newCheckedIds);
+      return;
+    }
+    const newCheckedIds = toggleNonExclusiveCheckbox(
+      id,
+      currentCheckedIds,
+      exclusiveOrOption,
+    );
+    setCheckedFieldValue(newCheckedIds);
+  };
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
index 85dd1d0a4f..48d19a535a 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExclusiveOption.tsx
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useExclusiveOption.tsx
@@ -1,10 +1,11 @@
 import { FormikProps } from "formik";
 
 import { Option } from "../../../shared";
+import { Group } from "../../model";
 
 export const useExclusiveOption = (
   exclusiveOptions: Option[],
-  formik: FormikProps<{ checked: Array<string> }>
+  formik: FormikProps<{ checked: Array<string> }>,
 ) => {
   const [exclusiveOrOption] = exclusiveOptions;
 
@@ -21,3 +22,24 @@ export const useExclusiveOption = (
     toggleExclusiveCheckbox,
   };
 };
+
+export const useExclusiveOptionInGroupedChecklist = (
+  exclusiveOptions: Group<Option>[],
+  formik: FormikProps<{ checked: Array<string> }>,
+) => {
+  const [exclusiveOrOptionGroup] = exclusiveOptions;
+
+  const exclusiveOptionIsChecked =
+    exclusiveOrOptionGroup &&
+    formik.values.checked.includes(exclusiveOrOptionGroup.children[0].id);
+
+  const toggleExclusiveCheckbox = (checkboxId: string) => {
+    return exclusiveOptionIsChecked ? [] : [checkboxId];
+  };
+
+  return {
+    exclusiveOrOptionGroup,
+    exclusiveOptionIsChecked,
+    toggleExclusiveCheckbox,
+  };
+};
diff --git a/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useInitialOptions.tsx b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useInitialOptions.tsx
new file mode 100644
index 0000000000..0c0ba08e03
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Checklist/Public/hooks/useInitialOptions.tsx
@@ -0,0 +1,19 @@
+import { Group } from "@planx/components/Checklist/model";
+import { useStore } from "pages/FlowEditor/lib/store";
+import { FormikHookReturn } from "types";
+
+import { Option } from "../../../shared";
+
+export const useInitialOptions = (formik: FormikHookReturn) => {
+  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);
+
+  return { initialOptions, schema, initialOptionVals };
+};
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 cc4a72156b..6f1fa6b856 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
@@ -6,7 +6,11 @@ import { axe } from "vitest-axe";
 
 import { ChecklistLayout } from "../../model";
 import Checklist from "../Public";
-import { groupedOptions, options } from "./mockOptions";
+import {
+  groupedOptions,
+  groupedOptionsWithExclusiveOption,
+  options,
+} from "./mockOptions";
 import { pressContinue, pressOption } from "./testUtils";
 
 describe("Checklist Component - Grouped Layout", () => {
@@ -58,6 +62,50 @@ describe("Checklist Component - Grouped Layout", () => {
     });
   });
 
+  it("handles exclusive Or options correctly", async () => {
+    const handleSubmit = vi.fn();
+
+    const { user } = setup(
+      <Checklist
+        allRequired={false}
+        description=""
+        text="home type?"
+        handleSubmit={handleSubmit}
+        groupedOptions={groupedOptionsWithExclusiveOption}
+      />,
+    );
+
+    // user presses an option in section 1
+    await user.click(screen.getByText("Section 1"));
+
+    const nonExclusiveOption = screen.getByLabelText("S1 Option1");
+    await user.click(nonExclusiveOption);
+    expect(nonExclusiveOption).toHaveAttribute("checked");
+
+    const exclusiveOption = screen.getByLabelText("Exclusive");
+    await user.click(exclusiveOption);
+
+    expect(nonExclusiveOption).not.toHaveAttribute("checked");
+    expect(exclusiveOption).toHaveAttribute("checked");
+
+    await user.click(screen.getByText("Section 2"));
+    const exclusiveOptionInSection2 = screen.getByLabelText("S2 Option1");
+    await user.click(exclusiveOptionInSection2);
+
+    expect(exclusiveOptionInSection2).toHaveAttribute("checked");
+    expect(exclusiveOption).not.toHaveAttribute("checked");
+
+    // user presses two more non-exclusive options
+    await user.click(screen.getByText("S1 Option1"));
+    await user.click(screen.getByText("S2 Option2"));
+
+    await user.click(screen.getByTestId("continue-button"));
+
+    expect(handleSubmit).toHaveBeenCalledWith({
+      answers: ["S1_Option1", "S2_Option1", "S2_Option2"],
+    });
+  });
+
   it("should not have any accessibility violations", async () => {
     const { container } = setup(
       <Checklist
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 e655712b6b..73dbf2bd9f 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
@@ -121,3 +121,47 @@ export const groupedOptions: Array<Group<Option>> = [
     ],
   },
 ];
+
+export const groupedOptionsWithExclusiveOption: Array<Group<Option>> = [
+  {
+    title: "Section 1",
+    children: [
+      {
+        id: "S1_Option1",
+        data: {
+          text: "S1 Option1",
+        },
+      },
+    ],
+  },
+  {
+    title: "Section 2",
+    children: [
+      {
+        id: "S2_Option1",
+        data: {
+          text: "S2 Option1",
+        },
+      },
+      {
+        id: "S2_Option2",
+        data: {
+          text: "S2 Option2",
+        },
+      },
+    ],
+  },
+  {
+    title: "Exclusive 'Or' Option",
+    exclusive: true,
+    children: [
+      {
+        id: "exclusive_option",
+        data: {
+          text: "Exclusive",
+          exclusive: true,
+        },
+      },
+    ],
+  },
+];
diff --git a/editor.planx.uk/src/@planx/components/Checklist/model.ts b/editor.planx.uk/src/@planx/components/Checklist/model.ts
index 0ac307c34c..e65e02c789 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/model.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/model.ts
@@ -1,3 +1,4 @@
+import { partition } from "lodash";
 import { array } from "yup";
 
 import { BaseNodeData, Option } from "../shared";
@@ -10,6 +11,7 @@ export enum ChecklistLayout {
 
 export interface Group<T> {
   title: string;
+  exclusive?: true;
   children: Array<T>;
 }
 
@@ -36,34 +38,51 @@ interface ChecklistExpandableProps {
   groupedOptions?: Array<Group<Option>>;
 }
 
-export const toggleExpandableChecklist = (
-  checklist: ChecklistExpandableProps,
-): ChecklistExpandableProps => {
-  if (checklist.options !== undefined && checklist.options.length > 0) {
+export const toggleExpandableChecklist = ({
+  options,
+  groupedOptions,
+}: ChecklistExpandableProps) => {
+  const checklist = [options, groupedOptions];
+
+  // toggle from unexpanded to expanded
+  if (options !== undefined && options.length > 0) {
+    const [exclusiveOptions, nonExclusiveOptions]: Option[][] = partition(
+      options,
+      (option) => option.data.exclusive,
+    );
+
+    const newGroupedOptions = [
+      {
+        title: "Section 1",
+        children: nonExclusiveOptions,
+      },
+    ];
+
+    if (exclusiveOptions.length > 0) {
+      newGroupedOptions.push({
+        title: "Or",
+        children: exclusiveOptions,
+      });
+    }
+
     return {
       ...checklist,
-      groupedOptions: [
-        {
-          title: "Section 1",
-          children: checklist.options,
-        },
-      ],
+      groupedOptions: newGroupedOptions,
       options: undefined,
     };
-  } else if (
-    checklist.groupedOptions !== undefined &&
-    checklist.groupedOptions.length > 0
-  ) {
+
+    // toggle from expanded to unexpanded
+  } else if (groupedOptions !== undefined && groupedOptions.length > 0) {
     return {
       ...checklist,
-      options: checklist.groupedOptions.flatMap((opt) => opt.children),
+      options: groupedOptions.flatMap((opt) => opt.children),
       groupedOptions: undefined,
     };
   } else {
     return {
       ...checklist,
-      options: checklist.options || [],
-      groupedOptions: checklist.groupedOptions || [
+      options: options || [],
+      groupedOptions: groupedOptions || [
         {
           title: "Section 1",
           children: [],
diff --git a/editor.planx.uk/src/@planx/components/Checklist/types.ts b/editor.planx.uk/src/@planx/components/Checklist/types.ts
index c06172c321..6dca381d67 100644
--- a/editor.planx.uk/src/@planx/components/Checklist/types.ts
+++ b/editor.planx.uk/src/@planx/components/Checklist/types.ts
@@ -18,4 +18,4 @@ export interface ChecklistProps extends Checklist {
   };
 }
 
-export type Props = PublicProps<Checklist>;
+export type PublicChecklistProps = PublicProps<Checklist>;
diff --git a/editor.planx.uk/src/@planx/components/Pay/Editor/GovPayMetadataSection.tsx b/editor.planx.uk/src/@planx/components/Pay/Editor/GovPayMetadataSection.tsx
index 2cb9a6f9f5..2369a0ed64 100644
--- a/editor.planx.uk/src/@planx/components/Pay/Editor/GovPayMetadataSection.tsx
+++ b/editor.planx.uk/src/@planx/components/Pay/Editor/GovPayMetadataSection.tsx
@@ -2,13 +2,8 @@ import DataObjectIcon from "@mui/icons-material/DataObject";
 import Box from "@mui/material/Box";
 import Link from "@mui/material/Link";
 import Typography from "@mui/material/Typography";
-import {
-  GovPayMetadata,
-} from "@opensystemslab/planx-core/types";
-import {
-  Pay,
-  REQUIRED_GOVPAY_METADATA,
-} from "@planx/components/Pay/model";
+import { GovPayMetadata } from "@opensystemslab/planx-core/types";
+import { Pay } from "@planx/components/Pay/model";
 import { useFormikContext } from "formik";
 import React from "react";
 import ListManager, {
@@ -20,65 +15,16 @@ import ErrorWrapper from "ui/shared/ErrorWrapper";
 import Input from "ui/shared/Input/Input";
 import InputRow from "ui/shared/InputRow";
 
+import { isFieldDisabled, parseError, parseTouched } from "./helpers";
+
 const GOVPAY_DOCS_URL =
   "https://docs.payments.service.gov.uk/reporting/#add-more-information-to-a-payment-39-custom-metadata-39-or-39-reporting-columns-39";
 
-type FormikGovPayMetadata =
+export type FormikGovPayMetadata =
   | Record<keyof GovPayMetadata, string>[]
   | string
   | undefined;
 
-/**
- * Helper method to handle Formik errors in arrays
- * Required as errors can be at array-level or field-level and the useFormikContext hook cannot correctly type infer this from the validation schema
- * Docs: https://formik.org/docs/api/fieldarray#fieldarray-validation-gotchas
- */
-const parseError = (
-  errors: FormikGovPayMetadata,
-  index: number,
-): string | undefined => {
-  // No errors
-  if (!errors) return;
-
-  // Array-level error - handled at a higher level
-  if (typeof errors === "string") return;
-
-  // No error for this field
-  if (!errors[index]) return;
-
-  // Specific field-level error
-  return errors[index].key || errors[index].value;
-};
-
-/**
- * Helper method to handle Formik "touched" in arrays
- * Please see parseError() for additional context
- */
-const parseTouched = (
-  touched: string | undefined | FormikGovPayMetadata,
-  index: number,
-): string | undefined => {
-  // No errors
-  if (!touched) return;
-
-  // Array-level error - handled at a higher level
-  if (typeof touched === "string") return;
-
-  // No error for this field
-  if (!touched[index]) return;
-
-  // Specific field-level error
-  return touched[index].key && touched[index].value;
-};
-
-/**
- * Disable required fields so they cannot be edited
- * Only disable first instance, otherwise any field beginning with a required field will be disabled, and user will not be able to fix their mistake as the delete icon is also disabled
- */
-const isFieldDisabled = (key: string, index: number) =>
-  REQUIRED_GOVPAY_METADATA.includes(key) &&
-  index === REQUIRED_GOVPAY_METADATA.indexOf(key);
-
 function GovPayMetadataEditor(props: ListManagerEditorProps<GovPayMetadata>) {
   const { key: currKey, value: currVal } = props.value;
   const isDisabled = isFieldDisabled(currKey, props.index);
@@ -122,17 +68,15 @@ function GovPayMetadataEditor(props: ListManagerEditorProps<GovPayMetadata>) {
 }
 
 export const GovPayMetadataSection: React.FC = () => {
-  const { errors, setFieldValue, setTouched, touched, values } = useFormikContext<Pay>();
+  const { errors, setFieldValue, setTouched, touched, values } =
+    useFormikContext<Pay>();
 
   return (
     <ModalSection>
-      <ModalSectionContent
-        title="GOV.UK Pay Metadata"
-        Icon={DataObjectIcon}
-      >
+      <ModalSectionContent title="GOV.UK Pay Metadata" Icon={DataObjectIcon}>
         <Typography variant="subtitle2" sx={{ mb: 2 }}>
-          Include metadata alongside payments, such as VAT codes, cost
-          centers, or ledger codes. See{" "}
+          Include metadata alongside payments, such as VAT codes, cost centers,
+          or ledger codes. See{" "}
           <Link
             href={GOVPAY_DOCS_URL}
             target="_blank"
@@ -143,13 +87,12 @@ export const GovPayMetadataSection: React.FC = () => {
           for more details.
         </Typography>
         <Typography variant="subtitle2" sx={{ mb: 2 }}>
-          Any values beginning with @ will be dynamically read from data
-          values set throughout the flow.
+          Any values beginning with @ will be dynamically read from data values
+          set throughout the flow.
         </Typography>
         <ErrorWrapper
           error={
-            typeof errors.govPayMetadata === "string" &&
-              touched.govPayMetadata
+            typeof errors.govPayMetadata === "string" && touched.govPayMetadata
               ? errors.govPayMetadata
               : undefined
           }
@@ -181,7 +124,7 @@ export const GovPayMetadataSection: React.FC = () => {
               </Typography>
             </Box>
             <ListManager
-              maxItems={10}
+              maxItems={15}
               disableDragAndDrop
               values={values.govPayMetadata || []}
               onChange={(metadata) => {
@@ -192,13 +135,11 @@ export const GovPayMetadataSection: React.FC = () => {
                 setTouched({});
                 return { key: "", value: "" };
               }}
-              isFieldDisabled={({ key }, index) =>
-                isFieldDisabled(key, index)
-              }
+              isFieldDisabled={({ key }, index) => isFieldDisabled(key, index)}
             />
           </>
         </ErrorWrapper>
       </ModalSectionContent>
     </ModalSection>
-  )
-}
\ No newline at end of file
+  );
+};
diff --git a/editor.planx.uk/src/@planx/components/Pay/Editor/helpers.ts b/editor.planx.uk/src/@planx/components/Pay/Editor/helpers.ts
new file mode 100644
index 0000000000..47e8273a8b
--- /dev/null
+++ b/editor.planx.uk/src/@planx/components/Pay/Editor/helpers.ts
@@ -0,0 +1,51 @@
+import { REQUIRED_GOVPAY_METADATA } from "../model";
+import { FormikGovPayMetadata } from "./GovPayMetadataSection";
+
+/**
+ * Helper method to handle Formik errors in arrays
+ * Required as errors can be at array-level or field-level and the useFormikContext hook cannot correctly type infer this from the validation schema
+ * Docs: https://formik.org/docs/api/fieldarray#fieldarray-validation-gotchas
+ */
+export const parseError = (
+  errors: FormikGovPayMetadata,
+  index: number,
+): string | undefined => {
+  // No errors
+  if (!errors) return;
+
+  // Array-level error - handled at a higher level
+  if (typeof errors === "string") return;
+
+  // No error for this field
+  if (!errors[index]) return;
+
+  // Specific field-level error
+  return errors[index].key || errors[index].value;
+};
+/**
+ * Helper method to handle Formik "touched" in arrays
+ * Please see parseError() for additional context
+ */
+export const parseTouched = (
+  touched: string | undefined | FormikGovPayMetadata,
+  index: number,
+): string | undefined => {
+  // No errors
+  if (!touched) return;
+
+  // Array-level error - handled at a higher level
+  if (typeof touched === "string") return;
+
+  // No error for this field
+  if (!touched[index]) return;
+
+  // Specific field-level error
+  return touched[index].key && touched[index].value;
+};
+/**
+ * Disable required fields so they cannot be edited
+ * Only disable first instance, otherwise any field beginning with a required field will be disabled, and user will not be able to fix their mistake as the delete icon is also disabled
+ */
+export const isFieldDisabled = (key: string, index: number) =>
+  REQUIRED_GOVPAY_METADATA.includes(key) &&
+  index === REQUIRED_GOVPAY_METADATA.indexOf(key);
diff --git a/editor.planx.uk/src/@planx/components/Pay/model.test.ts b/editor.planx.uk/src/@planx/components/Pay/model.test.ts
index 533b76b5cd..2ae8268865 100644
--- a/editor.planx.uk/src/@planx/components/Pay/model.test.ts
+++ b/editor.planx.uk/src/@planx/components/Pay/model.test.ts
@@ -97,7 +97,7 @@ describe("GovPayMetadata Schema", () => {
     expect(errors[0]).toMatch(/Keys must be unique/);
   });
 
-  test("max 10 entries can be added", async () => {
+  test("max 15 entries can be added", async () => {
     const input = [
       ...defaults,
       { key: "four", value: "someValue" },
@@ -107,6 +107,11 @@ describe("GovPayMetadata Schema", () => {
       { key: "eight", value: "someValue" },
       { key: "nine", value: "someValue" },
       { key: "ten", value: "someValue" },
+      { key: "eleven", value: "someValue" },
+      { key: "twelve", value: "someValue" },
+      { key: "thirteen", value: "someValue" },
+      { key: "fourteen", value: "someValue" },
+      { key: "fifteen", value: "someValue" },
     ];
 
     const result = await validate(input);
@@ -114,12 +119,13 @@ describe("GovPayMetadata Schema", () => {
     // No errors, input returned from validation
     expect(result).toEqual(input);
 
-    // Try 11 total values
+    // Try 16 total values - i.e. one more than permitted
     const errors = await validate([
       ...input,
-      { key: "eleven", value: "someValue" },
+      { key: "sixteen", value: "someValue" },
     ]);
+
     expect(errors).toHaveLength(1);
-    expect(errors[0]).toMatch(/A maximum of 10 fields can be set as metadata/);
+    expect(errors[0]).toMatch(/A maximum of 15 fields can be set as metadata/);
   });
 });
diff --git a/editor.planx.uk/src/@planx/components/Pay/model.ts b/editor.planx.uk/src/@planx/components/Pay/model.ts
index 9cef8596a6..44bbbce704 100644
--- a/editor.planx.uk/src/@planx/components/Pay/model.ts
+++ b/editor.planx.uk/src/@planx/components/Pay/model.ts
@@ -104,7 +104,7 @@ export const govPayMetadataSchema = array(
       }),
   }),
 )
-  .max(10, "A maximum of 10 fields can be set as metadata")
+  .max(15, "A maximum of 15 fields can be set as metadata")
   .test({
     name: "unique-keys",
     message: "Keys must be unique",
diff --git a/editor.planx.uk/src/@planx/components/shared/BaseOptionsEditor.tsx b/editor.planx.uk/src/@planx/components/shared/BaseOptionsEditor.tsx
index 29c3540fad..8722a26913 100644
--- a/editor.planx.uk/src/@planx/components/shared/BaseOptionsEditor.tsx
+++ b/editor.planx.uk/src/@planx/components/shared/BaseOptionsEditor.tsx
@@ -5,12 +5,13 @@ import InputRow from "ui/shared/InputRow";
 import InputRowItem from "ui/shared/InputRowItem";
 
 import { Option } from ".";
-import { FlagsSelect } from "./FlagsSelect";
 import { DataFieldAutocomplete } from "./DataFieldAutocomplete";
+import { FlagsSelect } from "./FlagsSelect";
 
 export interface BaseOptionsEditorProps {
   value: Option;
   schema?: string[];
+  optionPlaceholder?: string;
   showValueField?: boolean;
   showDescriptionField?: boolean;
   onChange: (newVal: Option) => void;
@@ -38,7 +39,7 @@ export const BaseOptionsEditor: React.FC<BaseOptionsEditorProps> = (props) => (
               },
             });
           }}
-          placeholder="Option"
+          placeholder={props.optionPlaceholder || "Option"}
         />
       </InputRowItem>
       <ImgInput
diff --git a/editor.planx.uk/src/@planx/graph/__tests__/remove.test.ts b/editor.planx.uk/src/@planx/graph/__tests__/remove.test.ts
index b64410543a..63ae1dca07 100644
--- a/editor.planx.uk/src/@planx/graph/__tests__/remove.test.ts
+++ b/editor.planx.uk/src/@planx/graph/__tests__/remove.test.ts
@@ -26,7 +26,7 @@ test("with clones", () => {
   ]);
 });
 
-test("with id", () => {
+test("final node with id", () => {
   const [graph, ops] = remove(
     "a",
     "_root",
@@ -43,9 +43,10 @@ test("with id", () => {
     },
     d: {},
   });
-  expect(graph).toEqual({});
+  // The `_root` node is never fully deleted, rather just "emptied out"
+  expect(graph).toEqual({ "_root": { edges: [] } });
   expect(ops).toEqual([
-    { od: { edges: ["a"] }, p: ["_root"] },
+    { ld: "a", p: ["_root", "edges", 0] },
     { od: {}, p: ["b"] },
     { od: { edges: ["b", "c"] }, p: ["a"] },
     { od: { edges: ["d"] }, p: ["c"] },
diff --git a/editor.planx.uk/src/@planx/graph/index.ts b/editor.planx.uk/src/@planx/graph/index.ts
index cfdda42da7..db7ead23b1 100644
--- a/editor.planx.uk/src/@planx/graph/index.ts
+++ b/editor.planx.uk/src/@planx/graph/index.ts
@@ -307,13 +307,13 @@ const _remove = (draft: Graph, id: string, parent: string) => {
 
   const idx = parentNode.edges.indexOf(id);
   if (idx >= 0) {
-    if (parentNode.edges.length === 1) delete parentNode.edges;
+    if (parent !== ROOT_NODE_KEY && parentNode.edges.length === 1) delete parentNode.edges;
     else parentNode.edges.splice(idx, 1);
   } else {
     throw new Error("not found in parent");
   }
 
-  if (Object.keys(draft[parent]).length === 0) delete draft[parent];
+  if (parent !== ROOT_NODE_KEY && Object.keys(draft[parent]).length === 0) delete draft[parent];
 
   if (numberOfEdgesTo(id, draft) === 0) {
     const { edges } = draft[id];
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/store/editor.ts b/editor.planx.uk/src/pages/FlowEditor/lib/store/editor.ts
index c55a0eae06..b8ca8d6beb 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/store/editor.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/store/editor.ts
@@ -2,10 +2,10 @@ import { gql } from "@apollo/client";
 import { getPathForNode, sortFlow } from "@opensystemslab/planx-core";
 import {
   ComponentType as TYPES,
+  flatFlags,
   FlowGraph,
   NodeId,
   OrderedFlow,
-  flatFlags,
 } from "@opensystemslab/planx-core/types";
 import {
   add,
@@ -189,7 +189,7 @@ export interface EditorStore extends Store.Store {
     href: string;
   }) => void;
   getURLForNode: (nodeId: string) => string;
-  getFlowSchema: () => { nodes?: string[], options?: string[] } | undefined;
+  getFlowSchema: () => { nodes?: string[]; options?: string[] } | undefined;
 }
 
 export const editorStore: StateCreator<
@@ -620,8 +620,8 @@ export const editorStore: StateCreator<
       if (node.data?.val) {
         // Exclude Filter Option flag values as not exposed to editors
         const flagVals = flatFlags.map((flag) => flag.value);
-        if (!flagVals.includes(node.data.val)) options.add(node.data.val)
-      };
+        if (!flagVals.includes(node.data.val)) options.add(node.data.val);
+      }
     });
 
     return {
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
index 3781ba2348..6c7c682d97 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
@@ -942,7 +942,7 @@ const collectedFlagValuesByCategory = (
     if (breadcrumb.answers) {
       breadcrumb.answers.forEach((answerId) => {
         const node = flow[answerId];
-        if (node.data?.flags) {
+        if (node?.data?.flags) {
           node.data.flags.forEach((flag: Flag["value"]) => {
             if (possibleFlagValues.includes(flag)) collectedFlags.push(flag);
           });
diff --git a/editor.planx.uk/src/ui/shared/ErrorWrapper.tsx b/editor.planx.uk/src/ui/shared/ErrorWrapper.tsx
index 6e4e7cb1c7..10d730f962 100644
--- a/editor.planx.uk/src/ui/shared/ErrorWrapper.tsx
+++ b/editor.planx.uk/src/ui/shared/ErrorWrapper.tsx
@@ -54,7 +54,7 @@ export default function ErrorWrapper({
   return (
     <Root error={error} role={role} data-testid="error-wrapper">
       <ErrorText id={inputId} data-testid={inputId} variant="body1">
-        {error && error}
+        {error}
       </ErrorText>
       {children || null}
     </Root>