diff --git a/meta_configurator/src/components/panels/schema-diagram/SchemaObjectAttribute.vue b/meta_configurator/src/components/panels/schema-diagram/SchemaObjectAttribute.vue
index cafb568b5..68f5c0274 100644
--- a/meta_configurator/src/components/panels/schema-diagram/SchemaObjectAttribute.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/SchemaObjectAttribute.vue
@@ -15,6 +15,7 @@ import {
 import Button from 'primevue/button';
 import {FontAwesomeIcon} from '@fortawesome/vue-fontawesome';
 import {useSettings} from '@/settings/useSettings';
+import {doesSchemaAllowNull} from '@/schema/schemaReadingUtils';
 
 const settings = useSettings();
 
@@ -42,6 +43,11 @@ const emit = defineEmits<{
     attributeData: SchemaObjectAttributeData,
     required: boolean
   ): void;
+  (
+    e: 'update_attribute_nullable',
+    attributeData: SchemaObjectAttributeData,
+    nullable: boolean
+  ): void;
   (e: 'delete_element', objectData: SchemaElementData): void;
 }>();
 
@@ -49,6 +55,10 @@ function updateRequired() {
   emit('update_attribute_required', props.data, props.data.required);
 }
 
+function updateNullable(event: Event) {
+  emit('update_attribute_nullable', props.data, (event.target as HTMLInputElement).checked);
+}
+
 const attrName = ref(props.data.name);
 const selectedType: Ref<AttributeTypeChoice | undefined> = ref(
   determineTypeChoiceBySchema(props.typeChoices, props.data.schema)
@@ -83,6 +93,10 @@ function isHighlighted() {
   return props.selectedData && props.selectedData == props.data;
 }
 
+function isNullable() {
+  return doesSchemaAllowNull(props.data.schema);
+}
+
 function getHandleId() {
   return `source-${props.data.name}`;
 }
@@ -122,9 +136,11 @@ function getHandleTop() {
       <div class="vue-flow-attribute-inline">
         <input
           type="checkbox"
-          class="vue-flow-required-checkbox"
+          class="vue-flow-attribute-checkbox"
           v-model="props.data.required"
           @change="updateRequired"
+          aria-label="Required property"
+          title="Required: controls whether this property must be present."
           @mousedown.stop
           @click.stop
           @dblclick.stop
@@ -141,6 +157,19 @@ function getHandleTop() {
           @dblclick.stop
           placeholder="Select Type" />
 
+        <input
+          v-if="settings.schemaDiagram.showNullableCheckbox"
+          type="checkbox"
+          class="vue-flow-attribute-checkbox"
+          :checked="isNullable()"
+          @change="updateNullable"
+          aria-label="Nullable property"
+          title="Nullable: allows this property to be null in addition to its current type."
+          @mousedown.stop
+          @click.stop
+          @dblclick.stop
+          @keydown.stop />
+
         <Button
           class="vue-flow-attribute-button vue-flow-attribute-input-dimensions"
           size="small"
@@ -164,7 +193,7 @@ function getHandleTop() {
 </template>
 
 <style>
-.vue-flow-required-checkbox {
+.vue-flow-attribute-checkbox {
   margin: 0 4px;
   transform: scale(0.8);
 }
diff --git a/meta_configurator/src/components/panels/schema-diagram/SchemaObjectNode.vue b/meta_configurator/src/components/panels/schema-diagram/SchemaObjectNode.vue
index 2f8fd3fd4..89d918cfb 100644
--- a/meta_configurator/src/components/panels/schema-diagram/SchemaObjectNode.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/SchemaObjectNode.vue
@@ -52,6 +52,11 @@ const emit = defineEmits<{
     attributeData: SchemaObjectAttributeData,
     required: boolean
   ): void;
+  (
+    e: 'update_attribute_nullable',
+    attributeData: SchemaObjectAttributeData,
+    nullable: boolean
+  ): void;
 }>();
 
 const objectName = ref(props.data.name || '');
@@ -62,6 +67,10 @@ function updateAttributeRequired(attributeData: SchemaObjectAttributeData, requi
   emit('update_attribute_required', attributeData, required);
 }
 
+function updateAttributeNullable(attributeData: SchemaObjectAttributeData, nullable: boolean) {
+  emit('update_attribute_nullable', attributeData, nullable);
+}
+
 function isObjectEditable() {
   return (isHighlighted() || isAttributeHighlighted()) && settings.value.schemaDiagram.editMode;
 }
@@ -222,6 +231,7 @@ function isAttributeHighlighted() {
       @update_attribute_name="updateAttributeName"
       @update_attribute_type="updateAttributeType"
       @update_attribute_required="updateAttributeRequired"
+      @update_attribute_nullable="updateAttributeNullable"
       @delete_element="deleteElement" />
 
     <div v-if="isObjectEditable()">
diff --git a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
index 1c3b44d5d..4d5bc2218 100644
--- a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
@@ -53,6 +53,7 @@ import {
   copySelectedSchemaToClipboard,
   pasteSchemaFromClipboard,
 } from '@/components/panels/schema-diagram/schemaClipboardUtils';
+import {doesSchemaAllowNull, setSchemaNullable} from '@/schema/schemaReadingUtils';
 
 const emit = defineEmits<{
   (e: 'update_current_path', path: Path): void;
@@ -374,9 +375,18 @@ function updateAttributeType(
   attributeData: SchemaObjectAttributeData,
   newType: AttributeTypeChoice
 ) {
-  //attributeData.typeDescription = newType.label;
   const attributeSchema = structuredClone(schemaData.dataAt(attributeData.absolutePath));
+  const shouldRemainNullable = doesSchemaAllowNull(attributeSchema, schemaData.data.value);
   applyNewType(attributeSchema, newType.schema);
+  if (shouldRemainNullable) {
+    setSchemaNullable(attributeSchema, true, schemaData.data.value);
+  }
+  schemaData.setDataAt(attributeData.absolutePath, attributeSchema);
+}
+
+function updateAttributeNullable(attributeData: SchemaObjectAttributeData, nullable: boolean) {
+  const attributeSchema = structuredClone(schemaData.dataAt(attributeData.absolutePath));
+  setSchemaNullable(attributeSchema, nullable, schemaData.data.value);
   schemaData.setDataAt(attributeData.absolutePath, attributeSchema);
 }
 
@@ -486,6 +496,7 @@ function updateExternalReferenceValue(
           @update_attribute_name="updateAttributeName"
           @update_attribute_type="updateAttributeType"
           @update_attribute_required="updateAttributeRequired"
+          @update_attribute_nullable="updateAttributeNullable"
           @delete_element="deleteElement"
           @add_attribute="addAttribute"
           @extract_inlined_element="extractInlinedElement"
diff --git a/meta_configurator/src/components/panels/schema-diagram/__tests__/schemaObjectAttribute.test.ts b/meta_configurator/src/components/panels/schema-diagram/__tests__/schemaObjectAttribute.test.ts
new file mode 100644
index 000000000..e8ffc3c9c
--- /dev/null
+++ b/meta_configurator/src/components/panels/schema-diagram/__tests__/schemaObjectAttribute.test.ts
@@ -0,0 +1,74 @@
+import {shallowMount} from '@vue/test-utils';
+import {describe, expect, it, vi} from 'vitest';
+import {ref} from 'vue';
+import SchemaObjectAttribute from '../SchemaObjectAttribute.vue';
+import {SchemaObjectAttributeData} from '@/schema/graph-representation/schemaGraphTypes';
+
+vi.mock('@/settings/useSettings', () => ({
+  useSettings() {
+    return ref({
+      schemaDiagram: {
+        editMode: true,
+        showNullableCheckbox: true,
+      },
+    });
+  },
+}));
+
+describe('SchemaObjectAttribute', () => {
+  function createAttributeData() {
+    return new SchemaObjectAttributeData(
+      'nickname',
+      'string',
+      'properties',
+      ['properties', 'nickname'],
+      false,
+      true,
+      0,
+      {
+        type: 'string',
+      }
+    );
+  }
+
+  it('shows the nullable checkbox only for the highlighted attribute when enabled in settings', () => {
+    const data = createAttributeData();
+    const wrapper = shallowMount(SchemaObjectAttribute, {
+      props: {
+        data,
+        selectedData: data,
+        typeChoices: [{label: 'string', schema: {type: 'string'}}],
+      },
+      global: {
+        directives: {
+          tooltip: vi.fn(),
+        },
+      },
+    });
+
+    const checkboxes = wrapper.findAll('input[type="checkbox"]');
+    expect(checkboxes).toHaveLength(2);
+    expect(checkboxes[1]!.attributes('aria-label')).toBe('Nullable property');
+  });
+
+  it('emits nullable updates when the nullable checkbox changes', async () => {
+    const data = createAttributeData();
+    const wrapper = shallowMount(SchemaObjectAttribute, {
+      props: {
+        data,
+        selectedData: data,
+        typeChoices: [{label: 'string', schema: {type: 'string'}}],
+      },
+      global: {
+        directives: {
+          tooltip: vi.fn(),
+        },
+      },
+    });
+
+    const nullableCheckbox = wrapper.findAll('input[type="checkbox"]')[1]!;
+    await nullableCheckbox.setValue(true);
+
+    expect(wrapper.emitted('update_attribute_nullable')).toEqual([[data, true]]);
+  });
+});
diff --git a/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts b/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts
new file mode 100644
index 000000000..f1010107e
--- /dev/null
+++ b/meta_configurator/src/schema/__tests__/metaSchemaBuilder.test.ts
@@ -0,0 +1,185 @@
+import {describe, expect, it} from 'vitest';
+import {buildMetaSchema} from '@/schema/metaSchemaBuilder';
+import {ValidationService} from '@/schema/validationService';
+import {SETTINGS_DATA_DEFAULT} from '@/settings/defaultSettingsData';
+import type {SettingsInterfaceMetaSchema} from '@/settings/settingsTypes';
+import type {TopLevelSchema} from '@/schema/jsonSchemaType';
+
+function buildSettings(overrides: Partial<SettingsInterfaceMetaSchema> = {}) {
+  return {
+    ...structuredClone(SETTINGS_DATA_DEFAULT.metaSchema),
+    ...overrides,
+  };
+}
+
+function validateSchemaCandidate(
+  settings: Partial<SettingsInterfaceMetaSchema>,
+  schemaCandidate: TopLevelSchema
+) {
+  const metaSchema = buildMetaSchema(buildSettings(settings));
+  const validationService = new ValidationService(metaSchema);
+  return validationService.validate(schemaCandidate);
+}
+
+describe('metaSchemaBuilder', () => {
+  describe('type validation with allowMultipleTypes disabled', () => {
+    it('accepts all individual simple types', () => {
+      const simpleTypes = ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'];
+
+      for (const type of simpleTypes) {
+        const result = validateSchemaCandidate(
+          {allowMultipleTypes: false},
+          type === 'array'
+            ? {type, items: {type: 'string'}}
+            : type === 'object'
+            ? {type, properties: {}}
+            : {type}
+        );
+
+        expect(result.errors, `type ${type} should be valid`).toEqual([]);
+      }
+    });
+
+    it('accepts nullable unions with exactly one non-null type', () => {
+      const nullableTypes = ['array', 'boolean', 'integer', 'number', 'object', 'string'];
+
+      for (const type of nullableTypes) {
+        const schemaCandidate =
+          type === 'array'
+            ? {type: ['array', 'null'], items: {type: 'string'}}
+            : type === 'object'
+            ? {type: ['object', 'null'], properties: {}}
+            : {type: [type, 'null']};
+
+        const result = validateSchemaCandidate({allowMultipleTypes: false}, schemaCandidate);
+        expect(result.errors, `nullable type ${type} should be valid`).toEqual([]);
+      }
+    });
+
+    it('accepts nullable unions regardless of order', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: false},
+        {type: ['null', 'string']}
+      );
+
+      expect(result.errors).toEqual([]);
+    });
+
+    it('rejects non-null multi-type unions', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: false},
+        {type: ['string', 'number']}
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('rejects unions with null and more than one non-null type', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: false},
+        {type: ['string', 'number', 'null']}
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('rejects duplicate nullable unions', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: false},
+        {type: ['string', 'null', 'null']}
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('still rejects empty type arrays', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: false},
+        {type: [] as unknown as TopLevelSchema['type']}
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('type validation with allowMultipleTypes enabled', () => {
+    it('accepts unrestricted multi-type unions', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: true},
+        {type: ['string', 'number']}
+      );
+
+      expect(result.errors).toEqual([]);
+    });
+
+    it('still accepts nullable unions', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: true},
+        {type: ['string', 'null']}
+      );
+
+      expect(result.errors).toEqual([]);
+    });
+
+    it('still rejects duplicate type arrays', () => {
+      const result = validateSchemaCandidate(
+        {allowMultipleTypes: true},
+        {type: ['string', 'string']}
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('boolean schema validation', () => {
+    it('rejects nested boolean schemas when allowBooleanSchema is disabled', () => {
+      const result = validateSchemaCandidate(
+        {allowBooleanSchema: false},
+        {
+          type: 'object',
+          properties: {
+            maybeAnything: true,
+          },
+        }
+      );
+
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('accepts nested boolean schemas when allowBooleanSchema is enabled', () => {
+      const result = validateSchemaCandidate(
+        {allowBooleanSchema: true},
+        {
+          type: 'object',
+          properties: {
+            maybeAnything: true,
+          },
+        }
+      );
+
+      expect(result.errors).toEqual([]);
+    });
+  });
+
+  describe('ordinary object schema validation', () => {
+    it('accepts ordinary object schemas in simplified mode', () => {
+      const result = validateSchemaCandidate(
+        {
+          allowBooleanSchema: false,
+          allowMultipleTypes: false,
+        },
+        {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+            },
+          },
+          required: ['name'],
+        }
+      );
+
+      expect(result.errors).toEqual([]);
+    });
+  });
+});
diff --git a/meta_configurator/src/schema/__tests__/schemaManipulationUtils.test.ts b/meta_configurator/src/schema/__tests__/schemaManipulationUtils.test.ts
new file mode 100644
index 000000000..6f2e8f0d4
--- /dev/null
+++ b/meta_configurator/src/schema/__tests__/schemaManipulationUtils.test.ts
@@ -0,0 +1,161 @@
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+import {shallowRef} from 'vue';
+import {ManagedData} from '@/data/managedData';
+import {SessionMode} from '@/store/sessionMode';
+import {extractInlinedSchemaElement} from '@/schema/schemaManipulationUtils';
+
+vi.mock('@/dataformats/formatRegistry', () => ({
+  useDataConverter: () => ({
+    stringify: (data: any) => JSON.stringify(data),
+    parse: (data: string) => JSON.parse(data),
+  }),
+}));
+
+describe('schemaManipulationUtils', () => {
+  let schemaData: ManagedData;
+
+  beforeEach(() => {
+    schemaData = new ManagedData(
+      shallowRef({
+        type: 'object',
+        properties: {
+          a: {
+            type: 'object',
+            properties: {
+              a1: {
+                type: 'object',
+              },
+              a2: {
+                type: 'object',
+                properties: {
+                  a2a: {
+                    type: 'string',
+                  },
+                },
+              },
+              a3: {
+                type: 'object',
+                $ref: '#/properties/a/properties/a2',
+              },
+            },
+          },
+          b: {
+            type: 'object',
+            $ref: '#/properties/a',
+          },
+          c: {
+            type: 'string',
+            $ref: '#/properties/a/properties/a1',
+          },
+        },
+      }),
+      SessionMode.SchemaEditor
+    );
+  });
+
+  it('extracts an inlined schema into $defs and rewrites references to the extracted path', () => {
+    const extractedPath = extractInlinedSchemaElement(
+      ['properties', 'a', 'properties', 'a2'],
+      schemaData,
+      'a2'
+    );
+
+    expect(extractedPath).toEqual(['$defs', 'a2']);
+    expect(schemaData.data.value).toEqual({
+      type: 'object',
+      properties: {
+        a: {
+          type: 'object',
+          properties: {
+            a1: {
+              type: 'object',
+            },
+            a2: {
+              $ref: '#/$defs/a2',
+            },
+            a3: {
+              type: 'object',
+              $ref: '#/$defs/a2',
+            },
+          },
+        },
+        b: {
+          type: 'object',
+          $ref: '#/properties/a',
+        },
+        c: {
+          type: 'string',
+          $ref: '#/properties/a/properties/a1',
+        },
+      },
+      $defs: {
+        a2: {
+          type: 'object',
+          properties: {
+            a2a: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    });
+  });
+
+  it('reuses an existing matching definition when duplicate reuse is enabled', () => {
+    schemaData.setDataAt(['$defs', 'sharedObject'], {
+      type: 'object',
+      properties: {
+        a2a: {
+          type: 'string',
+        },
+      },
+    });
+
+    const extractedPath = extractInlinedSchemaElement(
+      ['properties', 'a', 'properties', 'a2'],
+      schemaData,
+      'sharedObject',
+      true
+    );
+
+    expect(extractedPath).toEqual(['$defs', 'sharedObject']);
+    expect(schemaData.data.value).toEqual({
+      type: 'object',
+      properties: {
+        a: {
+          type: 'object',
+          properties: {
+            a1: {
+              type: 'object',
+            },
+            a2: {
+              $ref: '#/$defs/sharedObject',
+            },
+            a3: {
+              type: 'object',
+              $ref: '#/$defs/sharedObject',
+            },
+          },
+        },
+        b: {
+          type: 'object',
+          $ref: '#/properties/a',
+        },
+        c: {
+          type: 'string',
+          $ref: '#/properties/a/properties/a1',
+        },
+      },
+      $defs: {
+        sharedObject: {
+          type: 'object',
+          properties: {
+            a2a: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    });
+  });
+});
diff --git a/meta_configurator/src/schema/graph-representation/__tests__/typeUtils.test.ts b/meta_configurator/src/schema/graph-representation/__tests__/typeUtils.test.ts
new file mode 100644
index 000000000..796567971
--- /dev/null
+++ b/meta_configurator/src/schema/graph-representation/__tests__/typeUtils.test.ts
@@ -0,0 +1,102 @@
+import {describe, expect, it} from 'vitest';
+import {reactive} from 'vue';
+import {collectTypeChoices, determineTypeChoiceBySchema} from '../typeUtils';
+import {SchemaObjectNodeData} from '../schemaGraphTypes';
+import type {JsonSchemaObjectType, TopLevelSchema} from '@/schema/jsonSchemaType';
+import {getAllowedTypesOfSchema, setSchemaNullable} from '@/schema/schemaReadingUtils';
+
+describe('type utils nullable support', () => {
+  it('infers allowed types from an internal reference without an explicit type', () => {
+    const rootSchema: TopLevelSchema = {
+      $defs: {
+        person: {
+          properties: {
+            name: {
+              type: 'string',
+            },
+          },
+        },
+      },
+      properties: {
+        assignee: {
+          $ref: '#/$defs/person',
+        },
+      },
+    };
+
+    expect(getAllowedTypesOfSchema(rootSchema.properties!.assignee as any, rootSchema)).toEqual([
+      'object',
+    ]);
+  });
+
+  it('adds and removes null on a direct type', () => {
+    const schema: JsonSchemaObjectType = {
+      type: 'string',
+    };
+
+    setSchemaNullable(schema, true);
+    expect(schema.type).toEqual(['string', 'null']);
+
+    setSchemaNullable(schema, false);
+    expect(schema.type).toBe('string');
+  });
+
+  it('adds null to a referenced schema while keeping the reference', () => {
+    const rootSchema: TopLevelSchema = {
+      $defs: {
+        person: {
+          properties: {
+            name: {
+              type: 'string',
+            },
+          },
+        },
+      },
+      properties: {
+        assignee: {
+          $ref: '#/$defs/person',
+        },
+      },
+    };
+
+    const attributeSchema = structuredClone(rootSchema.properties!.assignee as any);
+    setSchemaNullable(attributeSchema, true, rootSchema);
+
+    expect(attributeSchema).toEqual({
+      $ref: '#/$defs/person',
+      type: ['object', 'null'],
+    });
+  });
+
+  it('matches a nullable scalar schema to its non-null type choice', () => {
+    const choices = collectTypeChoices([]);
+
+    expect(determineTypeChoiceBySchema(choices, {type: ['string', 'null']})).toEqual(
+      choices.find(choice => choice.label === 'string')
+    );
+  });
+
+  it('matches a nullable reactive schema without cloning errors', () => {
+    const choices = collectTypeChoices([]);
+    const schema = reactive<JsonSchemaObjectType>({
+      type: ['string', 'null'],
+    });
+
+    expect(determineTypeChoiceBySchema(choices, schema)).toEqual(
+      choices.find(choice => choice.label === 'string')
+    );
+  });
+
+  it('matches a nullable referenced schema to the referenced type choice', () => {
+    const choices = collectTypeChoices([
+      new SchemaObjectNodeData('person', undefined, 'person', true, ['$defs', 'person'], {}, []),
+    ]);
+
+    expect(
+      determineTypeChoiceBySchema(choices, {
+        $ref: '#/$defs/person',
+        type: ['object', 'null'],
+      })
+    ).toEqual(choices.find(choice => choice.label === 'person'));
+  });
+});
diff --git a/meta_configurator/src/schema/graph-representation/schemaGraphConstructor.ts b/meta_configurator/src/schema/graph-representation/schemaGraphConstructor.ts
index 40c19431f..8d07258a5 100644
--- a/meta_configurator/src/schema/graph-representation/schemaGraphConstructor.ts
+++ b/meta_configurator/src/schema/graph-representation/schemaGraphConstructor.ts
@@ -5,7 +5,7 @@ import {
   getTypeDescription,
   isSubSchemaDefinedInDefinitions,
 } from '@/schema/schemaReadingUtils';
-import {jsonPointerToPath, pathToString} from '@/utility/pathUtils';
+import {pathToString} from '@/utility/pathUtils';
 import {useSettings} from '@/settings/useSettings';
 import {mergeAllOfs} from '@/schema/mergeAllOfs';
 import {dataAt} from '@/utility/resolveDataAtPath';
@@ -23,6 +23,7 @@ import {
 import {useErrorService} from '@/utility/errorServiceInstance';
 import {isExternalRef} from '@/schema/externalReferences.ts';
 import {JsonSchemaVisitor, type VisitorContext} from '@/schema/jsonSchemaVisitor.ts';
+import {resolveInternalReferencePath} from '@/schema/schemaReferenceUtils';
 
 const settings = useSettings();
 
@@ -396,6 +397,10 @@ export function generateAttributeTypeDescription(
     }
   }
 
+  if (doesSchemaHaveType(schema, 'null', true) && !typeDescription.includes('null')) {
+    typeDescription += ', null';
+  }
+
   return typeDescription;
 }
 
@@ -555,10 +560,12 @@ function resolveReferenceNode(
         return undefined;
       }
     }
-    const refPath = jsonPointerToPath(schema.$ref.replace('#', ''));
-    const refPathString = pathToString(refPath);
-    if (objectDefs.has(refPathString)) {
-      return objectDefs.get(refPathString);
+    const refPath = resolveInternalReferencePath(schema.$ref);
+    if (refPath) {
+      const refPathString = pathToString(refPath);
+      if (objectDefs.has(refPathString)) {
+        return objectDefs.get(refPathString);
+      }
     }
   }
   return undefined;
diff --git a/meta_configurator/src/schema/graph-representation/typeUtils.ts b/meta_configurator/src/schema/graph-representation/typeUtils.ts
index 70a7e55b6..fc9ebed41 100644
--- a/meta_configurator/src/schema/graph-representation/typeUtils.ts
+++ b/meta_configurator/src/schema/graph-representation/typeUtils.ts
@@ -1,8 +1,13 @@
-import type {JsonSchemaObjectType, SchemaPropertyTypes} from '@/schema/jsonSchemaType';
+import type {
+  JsonSchemaObjectType,
+  SchemaPropertyType,
+  SchemaPropertyTypes,
+} from '@/schema/jsonSchemaType';
 import {pathToJsonPointer} from '@/utility/pathUtils';
 import {SchemaNodeData} from '@/schema/graph-representation/schemaGraphTypes';
 import type {Path} from '@/utility/path';
 import {cleanupSchemaByType} from '../cleanupSchemaByType';
+import {doesSchemaAllowNull} from '@/schema/schemaReadingUtils';
 
 export type AttributeTypeChoice = {label: string; schema: JsonSchemaObjectType};
 
@@ -88,18 +93,23 @@ function isSchemaMatchingTypeChoice(
   if (schema === undefined || typeChoiceSchema === undefined) {
     return false;
   }
-  if (schema.type !== typeChoiceSchema.type) {
+  if (typeChoiceSchema.$ref !== undefined) {
+    return schema.$ref === typeChoiceSchema.$ref && !isSchemaOnlyNull(schema);
+  }
+
+  const comparableSchema = getNonNullableSchemaVariant(schema);
+  if (comparableSchema.type !== typeChoiceSchema.type) {
     return false;
   }
 
-  if (schema.type === 'array') {
+  if (comparableSchema.type === 'array') {
     return isSchemaMatchingTypeChoice(
-      schema.items as JsonSchemaObjectType,
+      comparableSchema.items as JsonSchemaObjectType,
       typeChoiceSchema.items as JsonSchemaObjectType
     );
   }
 
-  if (schema.$ref != typeChoiceSchema.$ref) {
+  if (comparableSchema.$ref != typeChoiceSchema.$ref) {
     return false;
   }
 
@@ -152,3 +162,31 @@ export function isSimpleType(typeDescription: string): boolean {
     'null[]',
   ].includes(typeDescription);
 }
+
+function getNonNullableSchemaVariant(schema: JsonSchemaObjectType): JsonSchemaObjectType {
+  const directTypes = normalizeTypes(schema.type);
+  const nonNullableTypes = directTypes.filter(type => type !== 'null');
+  if (nonNullableTypes.length === directTypes.length) {
+    return schema;
+  }
+
+  const comparableSchema: JsonSchemaObjectType = {...schema};
+  if (nonNullableTypes.length === 0) {
+    delete comparableSchema.type;
+  } else {
+    comparableSchema.type = nonNullableTypes.length === 1 ? nonNullableTypes[0] : nonNullableTypes;
+  }
+  return comparableSchema;
+}
+
+function normalizeTypes(types: SchemaPropertyTypes | undefined): SchemaPropertyType[] {
+  if (types === undefined) {
+    return [];
+  }
+  return Array.isArray(types) ? [...types] : [types];
+}
+
+function isSchemaOnlyNull(schema: JsonSchemaObjectType) {
+  const directTypes = normalizeTypes(schema.type);
+  return directTypes.length === 1 && directTypes[0] === 'null';
+}
diff --git a/meta_configurator/src/schema/metaSchemaBuilder.ts b/meta_configurator/src/schema/metaSchemaBuilder.ts
index e72b1be0a..af89dc05d 100644
--- a/meta_configurator/src/schema/metaSchemaBuilder.ts
+++ b/meta_configurator/src/schema/metaSchemaBuilder.ts
@@ -16,7 +16,7 @@ export function buildMetaSchema(metaSchemaSettings: SettingsInterfaceMetaSchema)
     metaSchema.$defs!.jsonSchema = DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA;
   }
   if (!metaSchemaSettings.allowMultipleTypes) {
-    metaSchema.$defs!.typeDefinition = DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES;
+    metaSchema.$defs!.typeDefinition = DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE;
   }
   if (!metaSchemaSettings.showAdditionalPropertiesButton) {
     metaSchema.$defs!.objectSubSchema!.metaConfigurator = {
@@ -104,10 +104,33 @@ const DEF_JSON_SCHEMA_WITHOUT_BOOLEAN_SCHEMA = {
     'This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.',
 };
 
-const DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES = {
+const DEF_TYPE_DEFINITION_WITHOUT_MULTIPLE_TYPES_EXCEPT_NULLABLE = {
   properties: {
     type: {
-      $ref: '#/$defs/simpleTypes',
+      oneOf: [
+        {
+          $ref: '#/$defs/simpleTypes',
+        },
+        {
+          title: 'Nullable type union',
+          type: 'array',
+          minItems: 2,
+          maxItems: 2,
+          uniqueItems: true,
+          allOf: [
+            {
+              contains: {
+                const: 'null',
+              },
+            },
+            {
+              contains: {
+                enum: ['array', 'boolean', 'integer', 'number', 'object', 'string'],
+              },
+            },
+          ],
+        },
+      ],
     },
   },
 };
diff --git a/meta_configurator/src/schema/resolveReferencesForDocumentation.ts b/meta_configurator/src/schema/resolveReferencesForDocumentation.ts
index 1b7cb6702..bb0e22d61 100644
--- a/meta_configurator/src/schema/resolveReferencesForDocumentation.ts
+++ b/meta_configurator/src/schema/resolveReferencesForDocumentation.ts
@@ -1,11 +1,14 @@
 import type {JsonSchemaObjectType, TopLevelSchema} from '@/schema/jsonSchemaType';
-import {dataAt} from '@/utility/resolveDataAtPath';
-import {jsonPointerToPathTyped} from '@/utility/pathUtils';
 import {cloneDeep} from 'lodash';
 import {mergeAllOfs} from '@/schema/mergeAllOfs';
 import type {Path} from '@/utility/path';
 import {doesSchemaHaveType} from '@/schema/schemaReadingUtils';
 import {useErrorService} from '@/utility/errorServiceInstance';
+import {
+  resolveInternalReferencePath,
+  resolveInternalReferenceSchema,
+} from '@/schema/schemaReferenceUtils';
+import {dataAt} from '@/utility/resolveDataAtPath';
 
 // this code is not recursive and also mainly developed for the documentation view, not sure how generally applicable it is
 export function resolveReferencesForDocumentation(subSchema: any, rootSchema: TopLevelSchema): any {
@@ -14,8 +17,7 @@ export function resolveReferencesForDocumentation(subSchema: any, rootSchema: To
   }
   if (subSchema.$ref) {
     const refJsonPointer = subSchema.$ref;
-    const refPath = jsonPointerToPathTyped(refJsonPointer);
-    const schemaAtRef = dataAt(refPath, rootSchema);
+    const schemaAtRef = resolveInternalReferenceSchema(refJsonPointer, rootSchema);
     // copy subSchema
     const subSchemaWithoutRef = cloneDeep(subSchema);
     delete subSchemaWithoutRef.$ref;
@@ -40,8 +42,7 @@ export function collectReferences(subSchema: any, rootSchema: TopLevelSchema): S
   }
   if (subSchema.$ref) {
     const refJsonPointer = subSchema.$ref;
-    const refPath = jsonPointerToPathTyped(refJsonPointer);
-    const schemaAtRef = dataAt(refPath, rootSchema);
+    const schemaAtRef = resolveInternalReferenceSchema(refJsonPointer, rootSchema);
     const result = collectReferences(schemaAtRef, rootSchema);
     result.add(refJsonPointer);
     return result;
@@ -57,8 +58,10 @@ export function findTargetPath(
 ): Path {
   const schemaAtPath: JsonSchemaObjectType = dataAt(path, rootSchema);
   if (schemaAtPath && schemaAtPath.$ref) {
-    const newPath = jsonPointerToPathTyped(schemaAtPath.$ref);
-    return findTargetPath(newPath, rootSchema, goThroughArray);
+    const newPath = resolveInternalReferencePath(schemaAtPath.$ref);
+    if (newPath) {
+      return findTargetPath(newPath, rootSchema, goThroughArray);
+    }
   }
 
   if (goThroughArray && doesSchemaHaveType(schemaAtPath, 'array', true)) {
diff --git a/meta_configurator/src/schema/schemaReadingUtils.ts b/meta_configurator/src/schema/schemaReadingUtils.ts
index bc32bf4c4..b2146927e 100644
--- a/meta_configurator/src/schema/schemaReadingUtils.ts
+++ b/meta_configurator/src/schema/schemaReadingUtils.ts
@@ -2,11 +2,13 @@ import type {
   JsonSchemaObjectType,
   JsonSchemaType,
   SchemaPropertyType,
+  SchemaPropertyTypes,
 } from '@/schema/jsonSchemaType';
-import {NUMBER_OF_PROPERTY_TYPES} from '@/schema/jsonSchemaType';
+import {NUMBER_OF_PROPERTY_TYPES, SCHEMA_PROPERTY_TYPES} from '@/schema/jsonSchemaType';
 import type {Path} from '@/utility/path';
 import type {ManagedData} from '@/data/managedData';
 import type {TopLevelJsonSchemaWrapper} from '@/schema/topLevelJsonSchemaWrapper';
+import {resolveInternalReferenceSchema} from '@/schema/schemaReferenceUtils';
 
 /**
  * Returns a string representation of the type of the property.
@@ -102,6 +104,130 @@ export function doesSchemaHaveType(
   return false;
 }
 
+export function doesSchemaAllowNull(
+  schema: JsonSchemaObjectType,
+  rootSchema?: JsonSchemaType
+): boolean {
+  return getAllowedTypesOfSchema(schema, rootSchema).includes('null');
+}
+
+export function getAllowedTypesOfSchema(
+  schema: JsonSchemaObjectType,
+  rootSchema?: JsonSchemaType
+): SchemaPropertyType[] {
+  const directTypes = normalizeTypes(schema.type);
+  if (directTypes.length > 0) {
+    return directTypes;
+  }
+
+  if (schema.$ref && rootSchema) {
+    const referencedSchema = resolveInternalReferenceSchema(schema.$ref, rootSchema);
+    if (referencedSchema) {
+      return inferTypesFromSchema(referencedSchema, rootSchema);
+    }
+  }
+
+  return [];
+}
+
+export function setSchemaNullable(
+  schema: JsonSchemaObjectType,
+  nullable: boolean,
+  rootSchema?: JsonSchemaType
+) {
+  if (nullable) {
+    const nonNullableTypes = getAllowedTypesOfSchema(schema, rootSchema).filter(
+      type => type !== 'null'
+    );
+    const nextTypes = [...new Set([...nonNullableTypes, 'null'])];
+    schema.type = nextTypes.length === 1 ? nextTypes[0] : nextTypes;
+    return;
+  }
+
+  const nextTypes = normalizeTypes(schema.type).filter(type => type !== 'null');
+  if (nextTypes.length === 0) {
+    delete schema.type;
+  } else {
+    schema.type = nextTypes.length === 1 ? nextTypes[0] : nextTypes;
+  }
+}
+
+function normalizeTypes(types: SchemaPropertyTypes | undefined): SchemaPropertyType[] {
+  if (types === undefined) {
+    return [];
+  }
+  return Array.isArray(types) ? [...types] : [types];
+}
+
+function inferTypesFromSchema(
+  schema: JsonSchemaObjectType,
+  rootSchema?: JsonSchemaType
+): SchemaPropertyType[] {
+  const directTypes = normalizeTypes(schema.type);
+  if (directTypes.length > 0) {
+    return directTypes;
+  }
+
+  if (schema.$ref && rootSchema) {
+    const referencedSchema = resolveInternalReferenceSchema(schema.$ref, rootSchema);
+    if (referencedSchema) {
+      return inferTypesFromSchema(referencedSchema, rootSchema);
+    }
+  }
+
+  if (
+    schema.properties !== undefined ||
+    schema.patternProperties !== undefined ||
+    schema.required !== undefined ||
+    schema.dependentRequired !== undefined ||
+    schema.additionalProperties !== undefined
+  ) {
+    return ['object'];
+  }
+
+  if (
+    schema.items !== undefined ||
+    schema.prefixItems !== undefined ||
+    schema.contains !== undefined ||
+    schema.minItems !== undefined ||
+    schema.maxItems !== undefined ||
+    schema.uniqueItems !== undefined
+  ) {
+    return ['array'];
+  }
+
+  if (schema.const !== undefined) {
+    return inferTypesFromValue(schema.const);
+  }
+
+  if (schema.enum !== undefined && schema.enum.length > 0) {
+    return [...new Set(schema.enum.flatMap(value => inferTypesFromValue(value)))];
+  }
+
+  return [];
+}
+
+function inferTypesFromValue(value: unknown): SchemaPropertyType[] {
+  if (value === null) {
+    return ['null'];
+  }
+  if (Array.isArray(value)) {
+    return ['array'];
+  }
+  switch (typeof value) {
+    case 'string':
+      return ['string'];
+    case 'boolean':
+      return ['boolean'];
+    case 'number':
+      return [Number.isInteger(value) ? 'integer' : 'number'];
+    case 'object':
+      return ['object'];
+    default:
+      return [...SCHEMA_PROPERTY_TYPES];
+  }
+}
+
 export function getSchemaTitle(schema: TopLevelJsonSchemaWrapper) {
   return schema.title || 'Untitled schema';
 }
diff --git a/meta_configurator/src/schema/schemaReferenceUtils.ts b/meta_configurator/src/schema/schemaReferenceUtils.ts
new file mode 100644
index 000000000..eb7b9aca1
--- /dev/null
+++ b/meta_configurator/src/schema/schemaReferenceUtils.ts
@@ -0,0 +1,32 @@
+import type {JsonSchemaObjectType, JsonSchemaType} from '@/schema/jsonSchemaType';
+import type {Path} from '@/utility/path';
+import {jsonPointerToPathTyped} from '@/utility/pathUtils';
+import {dataAt} from '@/utility/resolveDataAtPath';
+
+export function resolveInternalReferencePath(reference: string): Path | undefined {
+  if (!reference.startsWith('#')) {
+    return undefined;
+  }
+  return jsonPointerToPathTyped(reference);
+}
+
+export function resolveInternalReferenceSchema(
+  reference: string,
+  rootSchema: JsonSchemaType
+): JsonSchemaObjectType | undefined {
+  const referencePath = resolveInternalReferencePath(reference);
+  if (!referencePath) {
+    return undefined;
+  }
+
+  const referencedSchema = dataAt(referencePath, rootSchema);
+  if (
+    referencedSchema === undefined ||
+    typeof referencedSchema !== 'object' ||
+    referencedSchema === null
+  ) {
+    return undefined;
+  }
+
+  return referencedSchema as JsonSchemaObjectType;
+}
diff --git a/meta_configurator/src/settings/__tests__/settingsUpdater.test.ts b/meta_configurator/src/settings/__tests__/settingsUpdater.test.ts
index a6d6e4d5e..73acb755e 100644
--- a/meta_configurator/src/settings/__tests__/settingsUpdater.test.ts
+++ b/meta_configurator/src/settings/__tests__/settingsUpdater.test.ts
@@ -40,6 +40,7 @@ describe('test settings updater', () => {
         c: 5,
       },
     },
+    schemaDiagram: {},
     panels: {
       dataEditor: [
         {
@@ -76,6 +77,9 @@ describe('test settings updater', () => {
         g: 4,
       },
     },
+    schemaDiagram: {
+      showNullableCheckbox: true,
+    },
     panels: {
       dataEditor: [
         {
@@ -128,6 +132,9 @@ describe('test settings updater', () => {
           g: 4,
         },
       },
+      schemaDiagram: {
+        showNullableCheckbox: true,
+      },
       panels: {
         dataEditor: [
           {
@@ -167,6 +174,7 @@ describe('test settings updater', () => {
           c: 5,
         },
       },
+      schemaDiagram: {},
       panels: {
         dataEditor: [
           {
diff --git a/meta_configurator/src/settings/defaultSettingsData.ts b/meta_configurator/src/settings/defaultSettingsData.ts
index 4d8b257db..58c8fcac0 100644
--- a/meta_configurator/src/settings/defaultSettingsData.ts
+++ b/meta_configurator/src/settings/defaultSettingsData.ts
@@ -37,6 +37,7 @@ export const SETTINGS_DATA_DEFAULT = {
     vertical: true,
     showAttributes: true,
     showEnumValues: true,
+    showNullableCheckbox: true,
     maxAttributesToShow: 30,
     maxEnumValuesToShow: 10,
     moveViewToSelectedElement: false,
diff --git a/meta_configurator/src/settings/settingsSchema.ts b/meta_configurator/src/settings/settingsSchema.ts
index 34b2d5de8..38f4c109d 100644
--- a/meta_configurator/src/settings/settingsSchema.ts
+++ b/meta_configurator/src/settings/settingsSchema.ts
@@ -217,6 +217,7 @@ export const SETTINGS_SCHEMA: TopLevelSchema = {
         'vertical',
         'showAttributes',
         'showEnumValues',
+        'showNullableCheckbox',
         'maxAttributesToShow',
         'maxEnumValuesToShow',
         'moveViewToSelectedElement',
@@ -250,6 +251,12 @@ export const SETTINGS_SCHEMA: TopLevelSchema = {
             'If set to true, the enum values of the schema will be displayed in the schema diagram.',
           default: true,
         },
+        showNullableCheckbox: {
+          type: 'boolean',
+          description:
+            'If set to true, highlighted attributes in schema diagram edit mode will show a checkbox for toggling nullable types.',
+          default: true,
+        },
         maxAttributesToShow: {
           type: 'integer',
           description:
diff --git a/meta_configurator/src/settings/settingsTypes.ts b/meta_configurator/src/settings/settingsTypes.ts
index c0ea36117..269ec6255 100644
--- a/meta_configurator/src/settings/settingsTypes.ts
+++ b/meta_configurator/src/settings/settingsTypes.ts
@@ -54,6 +54,7 @@ export interface SettingsInterfaceSchemaDiagram {
   vertical: boolean;
   showAttributes: boolean;
   showEnumValues: boolean;
+  showNullableCheckbox: boolean;
   maxAttributesToShow: number;
   maxEnumValuesToShow: number;
   moveViewToSelectedElement: boolean;