diff --git a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-editor.tsx b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-editor.tsx
index 377bc9c51..da67487ff 100644
--- a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-editor.tsx
+++ b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-editor.tsx
@@ -29,6 +29,7 @@ import {
   Radio,
   Collapse,
   Typography,
+  App,
 } from 'antd';
 
 import useMobileModeler from '@/lib/useMobileModeler';
@@ -49,28 +50,42 @@ import AddButton from './add-button';
 import ConfigModal from '@/components/config-modal';
 import {
   addMachineConfig,
+  addParentConfigVersion,
   addTargetConfig,
   removeTargetConfig,
+  setParentConfigVersionAsLatest,
   updateMachineConfig,
   updateParentConfig,
   updateTargetConfig,
 } from '@/lib/data/legacy/machine-config';
 import ActionButtons from './action-buttons';
+import ConfirmationButton from '@/components/confirmation-button';
+import { v4 } from 'uuid';
+import { wrapServerCall } from '@/lib/wrap-server-call';
 type MachineDataViewProps = {
   selectedConfig: AbstractConfig;
   parentConfig: ParentConfig;
   editable: boolean;
+  editingAllowed: boolean;
   onChangeEditable: (isEditable: boolean) => void;
 };
 
-const LATEST_VERSION = { version: -1, name: 'Latest Version', description: '' };
+const LATEST_VERSION = {
+  id: '-1',
+  name: 'Latest Version',
+  description: '',
+  versionBasedOn: '',
+  createdOn: new Date(),
+};
 
 const ConfigEditor: React.FC<MachineDataViewProps> = ({
   selectedConfig,
   parentConfig,
   editable,
+  editingAllowed,
   onChangeEditable,
 }) => {
+  const app = App.useApp();
   const router = useRouter();
   const environment = useEnvironment();
   const query = useSearchParams();
@@ -105,25 +120,66 @@ const ConfigEditor: React.FC<MachineDataViewProps> = ({
   } = theme.useToken();
 
   const selectedVersion =
-    selectedConfig.versions.find(
-      (version: any) => version.version === parseInt(selectedVersionId ?? '-1'),
-    ) ?? LATEST_VERSION;
+    parentConfig.versions.find((version: any) => version.id === (selectedVersionId ?? '')) ??
+    LATEST_VERSION;
+
+  // TODO use FuzzySearch
+  // currently only ignores capitalization
   const filterOption: SelectProps['filterOption'] = (input, option) =>
     ((option?.label as string) ?? '').toLowerCase().includes(input.toLowerCase());
 
-  // const createConfigVersion = async (values: {
-  //   versionName: string;
-  //   versionDescription: string;
-  // }) => {
-  //   selectedConfig.versions.push({
-  //     version: selectedConfig.versions.length + 1,
-  //     name: values.versionName,
-  //     description: values.versionDescription,
-  //     versionBasedOn: selectedConfig.versions.length,
-  //   });
-  //   await saveParentConfig(configId, parentConfig);
-  //   router.refresh();
-  // };
+  const createConfigVersion = async (values: {
+    versionName: string;
+    versionDescription: string;
+  }) => {
+    const versionId = v4();
+    wrapServerCall({
+      fn: () =>
+        addParentConfigVersion(
+          parentConfig,
+          environment.spaceId,
+          versionId,
+          values.versionName,
+          values.versionDescription,
+        ),
+      onSuccess: () => {
+        router.refresh();
+        app.message.success({
+          content: (
+            <span>
+              Version <em>{values.versionName}</em> successfully created
+            </span>
+          ),
+        });
+      },
+      onError: () => {
+        app.message.success(`Creation of version failed`);
+      },
+    });
+  };
+
+  const makeConfigVersionLatest = async () => {
+    wrapServerCall({
+      fn: () => setParentConfigVersionAsLatest(parentConfig),
+      onSuccess: () => {
+        const searchParams = new URLSearchParams(query);
+        searchParams.delete('version');
+        router.push(
+          spaceURL(
+            environment,
+            `/machine-config/${parentConfig.id as string}${
+              searchParams.size ? '?' + searchParams.toString() : ''
+            }`,
+          ),
+        );
+        router.refresh();
+        app.message.success(`Version successfully set as latest`);
+      },
+      onError: () => {
+        app.message.success(`There was an error setting this version as latest`);
+      },
+    });
+  };
 
   const showMobileView = useMobileModeler();
 
@@ -321,34 +377,35 @@ const ConfigEditor: React.FC<MachineDataViewProps> = ({
                   {selectedConfig.name}
                 </Title>
               </div>
-              {/* <Space.Compact style={{ margin: '0 0 0 10px' }}>
+
+              <Space.Compact style={{ margin: '0 0 0 10px' }}>
                 <Select
                   popupMatchSelectWidth={false}
                   placeholder="Select Version"
                   showSearch
                   filterOption={filterOption}
                   value={{
-                    value: selectedVersion.version,
+                    value: selectedVersion.id,
                     label: selectedVersion.name,
                   }}
                   onSelect={(_, option) => {
                     // change the version info in the query but keep other info
                     const searchParams = new URLSearchParams(query);
-                    if (!option.value || option.value === -1) searchParams.delete('version');
+                    if (!option.value || option.value === '-1') searchParams.delete('version');
                     else searchParams.set(`version`, `${option.value}`);
                     router.push(
                       spaceURL(
                         environment,
-                        `/machine-config/${configId as string}${
+                        `/machine-config/${parentConfig.id as string}${
                           searchParams.size ? '?' + searchParams.toString() : ''
                         }`,
                       ),
                     );
                   }}
-                  options={[LATEST_VERSION]
-                    .concat(selectedConfig.versions ?? [])
-                    .map(({ version, name }) => ({
-                      value: version,
+                  options={[LATEST_VERSION, ...parentConfig.versions]
+                    // .concat(parentConfig.versions ?? [])
+                    .map(({ id, name }) => ({
+                      value: id,
                       label: name,
                     }))}
                 />
@@ -362,7 +419,7 @@ const ConfigEditor: React.FC<MachineDataViewProps> = ({
                     </Tooltip>
                   </>
                 )}
-              </Space.Compact> */}
+              </Space.Compact>
             </Space>
 
             <Space>
@@ -376,28 +433,49 @@ const ConfigEditor: React.FC<MachineDataViewProps> = ({
             </Space>
 
             <Space>
-              <Radio.Group
-                value={editable ? 'edit' : 'view'}
-                onChange={(e) => onChangeEditable(e.target.value === 'edit')}
-              >
-                <Radio.Button value="view">
-                  View
-                  <EyeOutlined
-                    style={{
-                      margin: '0 0 0 8px',
-                    }}
-                  />
-                </Radio.Button>
-
-                <Radio.Button value="edit">
-                  Edit
-                  <EditOutlined
-                    style={{
-                      margin: '0 0 0 8px',
-                    }}
-                  />
-                </Radio.Button>
-              </Radio.Group>
+              {!editingAllowed && (
+                <ConfirmationButton
+                  title="Are you sure you want to continue editing with this Version?"
+                  description="Any changes that are not stored in another version are irrecoverably lost!"
+                  tooltip="Set as latest Version and enable editing"
+                  onConfirm={makeConfigVersionLatest}
+                  modalProps={{
+                    okText: 'Set as latest Version',
+                    okButtonProps: {
+                      danger: true,
+                    },
+                  }}
+                  buttonProps={{
+                    icon: <EditOutlined />,
+                  }}
+                >
+                  Set as Latest
+                </ConfirmationButton>
+              )}
+              {editingAllowed && (
+                <Radio.Group
+                  value={editable ? 'edit' : 'view'}
+                  onChange={(e) => onChangeEditable(e.target.value === 'edit')}
+                >
+                  <Radio.Button value="view">
+                    View
+                    <EyeOutlined
+                      style={{
+                        margin: '0 0 0 8px',
+                      }}
+                    />
+                  </Radio.Button>
+
+                  <Radio.Button value="edit">
+                    Edit
+                    <EditOutlined
+                      style={{
+                        margin: '0 0 0 8px',
+                      }}
+                    />
+                  </Radio.Button>
+                </Radio.Group>
+              )}
 
               <Button onClick={exportCurrentConfig}>
                 Export
diff --git a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-page-content.tsx b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-page-content.tsx
index a60b75a0e..6fa9bd88c 100644
--- a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-page-content.tsx
+++ b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/config-page-content.tsx
@@ -27,6 +27,7 @@ const collapsedWidth = 70;
 
 type VariablesEditorProps = {
   parentConfig: ParentConfig;
+  editingAllowed: boolean;
 };
 
 const ParameterTreeNode: React.FC<{
@@ -73,7 +74,7 @@ const ConfigTreeNode: React.FC<{ config: AbstractConfig }> = ({ config }) => {
   );
 };
 
-const ConfigContent: React.FC<VariablesEditorProps> = ({ parentConfig }) => {
+const ConfigContent: React.FC<VariablesEditorProps> = ({ parentConfig, editingAllowed }) => {
   const [selectionId, setSelectionId] = useState('');
   const [selectionType, setSelectionType] = useState<AbstractConfig['type'] | 'parameter'>(
     'config',
@@ -240,7 +241,7 @@ const ConfigContent: React.FC<VariablesEditorProps> = ({ parentConfig }) => {
           <div className={styles.CustomBoxContentWrapper}>
             <ConfigurationTreeView
               parentConfig={parentConfig}
-              editable={editable}
+              editable={editable && editingAllowed}
               treeData={treeData}
               expandedKeys={expandedKeys}
               onExpandedChange={(newExpanded) => {
@@ -271,13 +272,14 @@ const ConfigContent: React.FC<VariablesEditorProps> = ({ parentConfig }) => {
                   key={key}
                   keyId={key}
                   parameter={val}
-                  editable={editable}
+                  editable={editable && editingAllowed}
                 />
               ))}
             </>
           ) : (
             <ConfigEditor
-              editable={editable}
+              editable={editable && editingAllowed}
+              editingAllowed={editingAllowed}
               onChangeEditable={setEditable}
               parentConfig={parentConfig}
               selectedConfig={selectedNode as AbstractConfig}
diff --git a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/page.tsx b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/page.tsx
index 06b8eaa80..374a5f0bd 100644
--- a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/page.tsx
+++ b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/page.tsx
@@ -8,13 +8,17 @@ type MachineConfigProps = {
   searchParams: { version?: string };
 };
 
-const MachineConfigView: React.FC<MachineConfigProps> = async ({ params: { configId } }) => {
-  let machineConfig = await getDeepParentConfigurationById(configId);
+const MachineConfigView: React.FC<MachineConfigProps> = async ({
+  params: { configId },
+  searchParams,
+}) => {
+  const selectedVersionId = searchParams.version ? searchParams.version : undefined;
+  let machineConfig = await getDeepParentConfigurationById(configId, selectedVersionId);
 
   //replace ConfigContent <-> MachineConfigEditor as needed
   return (
     <Content title={`Tech Data Set: ${machineConfig.name}`}>
-      <ConfigPage parentConfig={machineConfig} />
+      <ConfigPage parentConfig={machineConfig} editingAllowed={!selectedVersionId} />
     </Content>
   );
 };
diff --git a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/parent-config-list.tsx b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/parent-config-list.tsx
index 3b56f063a..592d2c13a 100644
--- a/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/parent-config-list.tsx
+++ b/src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/parent-config-list.tsx
@@ -248,7 +248,7 @@ const ParentConfigList: React.FC<ConfigListProps> = ({ data }) => {
       const importedData: ParentConfig[] = JSON.parse(text);
 
       await asyncForEach(importedData, async (item) => {
-        const add_return = await addParentConfig(item, space.spaceId, item);
+        const add_return = await addParentConfig(item, space.spaceId);
         if ('error' in add_return) {
           throw add_return.error.message;
         }
diff --git a/src/management-system-v2/lib/data/legacy/machine-config.ts b/src/management-system-v2/lib/data/legacy/machine-config.ts
index 3c59a4462..9ebb7fa19 100644
--- a/src/management-system-v2/lib/data/legacy/machine-config.ts
+++ b/src/management-system-v2/lib/data/legacy/machine-config.ts
@@ -23,6 +23,7 @@ import { v4 } from 'uuid';
 import eventHandler from './eventHandler.js';
 import { toCaslResource } from '@/lib/ability/caslAbility';
 import { asyncForEach, asyncMap } from '@/lib/helpers/javascriptHelpers';
+import { defaultConfiguration } from '@/app/(dashboard)/[environmentId]/machine-config/configuration-helper';
 
 // @ts-ignore
 let firstInit = !global.machineConfigMetaObjects;
@@ -33,6 +34,8 @@ type StoredConfigsAndParameters = {
   machineConfigs: Record<string, StoredMachineConfig>;
   targetConfigs: Record<string, StoredTargetConfig>;
   parameters: Record<string, StoredParameter>;
+  // versionedParentConfigs: Record<string, StoredParentConfig>;
+  versionedParentConfigs: Record<string, Record<string, StoredParentConfig>>;
 };
 
 let storedData: StoredConfigsAndParameters =
@@ -44,6 +47,7 @@ let storedData: StoredConfigsAndParameters =
     machineConfigs: {},
     targetConfigs: {},
     parameters: {},
+    versionedParentConfigs: {},
   } as StoredConfigsAndParameters);
 
 /**
@@ -99,7 +103,7 @@ function targetConfigToStorage(
         targetConfig.parameters,
         newId,
       ),
-    };
+    } as StoredTargetConfig;
 
     return targetConfig.id;
   }
@@ -134,7 +138,7 @@ function machineConfigsToStorage(
         machineConfig.parameters,
         newId,
       ),
-    };
+    } as StoredMachineConfig;
   });
 
   return machineConfigs.map(({ id }) => id);
@@ -144,18 +148,40 @@ function machineConfigsToStorage(
  * Stores a given ParentConfig into the new storage referencing other elements by id instead of having them nested.
  * @param parentConfig ParentConfig that is to be stored, able to contain TargetConfigs, MachineConfigs and ParameterConfigs
  * @param newId Boolean determining if new IDs are to be generated.
+ * @param version Version-ID of the config if a versioned config is to be stored.
  */
-function parentConfigToStorage(parentConfig: ParentConfig, newId: boolean = false) {
+function parentConfigToStorage(
+  parentConfig: ParentConfig,
+  newId: boolean = false,
+  version: string = '',
+) {
   const { targetConfig, metadata, machineConfigs } = parentConfig;
 
-  parentConfig.id = newId ? v4() : parentConfig.id;
+  parentConfig.id = newId && !version ? v4() : parentConfig.id;
 
-  storedData.parentConfigs[parentConfig.id] = {
+  if (!storedData.versionedParentConfigs[parentConfig.id])
+    storedData.versionedParentConfigs[parentConfig.id] = {};
+
+  let toStore = {
     ...parentConfig,
     targetConfig: targetConfigToStorage(parentConfig.id, targetConfig, newId),
     machineConfigs: machineConfigsToStorage(parentConfig.id, machineConfigs, newId),
     metadata: parametersToStorage(parentConfig.id, 'parent-config', metadata, newId),
   };
+
+  if (version) storedData.versionedParentConfigs[parentConfig.id][version] = toStore;
+  else storedData.parentConfigs[parentConfig.id] = toStore;
+}
+
+function versionToParentConfigStorage(parentConfig: ParentConfig) {
+  const { targetConfig, metadata, machineConfigs } = parentConfig;
+
+  storedData.parentConfigs[parentConfig.id] = {
+    ...parentConfig,
+    targetConfig: targetConfigToStorage(parentConfig.id, targetConfig, true),
+    machineConfigs: machineConfigsToStorage(parentConfig.id, machineConfigs, true),
+    metadata: parametersToStorage(parentConfig.id, 'parent-config', metadata, true),
+  };
 }
 
 /**
@@ -264,9 +290,12 @@ function nestedMachineConfigsFromStorage(machineConfigIds: string[]): MachineCon
  */
 export async function getDeepParentConfigurationById(
   parentConfigId: string,
+  version: string = '',
   ability?: Ability,
 ): Promise<ParentConfig> {
-  const storedParentConfig = storedData.parentConfigs[parentConfigId];
+  const storedParentConfig = version
+    ? storedData.versionedParentConfigs[parentConfigId][version]
+    : storedData.parentConfigs[parentConfigId];
 
   // TODO: check if the user can access the config
 
@@ -277,6 +306,7 @@ export async function getDeepParentConfigurationById(
     metadata: nestedParametersFromStorage(storedParentConfig.metadata),
     targetConfig: nestedConfigFromStorage('target-config', storedParentConfig.targetConfig),
     machineConfigs: nestedMachineConfigsFromStorage(storedParentConfig.machineConfigs),
+    versions: storedData.parentConfigs[parentConfigId].versions,
   };
 
   if (
@@ -288,7 +318,7 @@ export async function getDeepParentConfigurationById(
   return parentConfig;
 }
 
-/** Returns all shallow machineConfigs in form of an array */
+/** Returns all shallow Configs in form of an array */
 export async function getParentConfigurations(
   environmentId: string,
   ability?: Ability,
@@ -506,13 +536,11 @@ export async function copyParentConfig(
 
 /*************************** Element Addition *****************************/
 
-export async function addParentConfig(
-  machineConfigInput: ParentConfig,
-  environmentId: string,
-  base?: ParentConfig,
-) {
+export async function addParentConfig(machineConfigInput: ParentConfig, environmentId: string) {
   try {
+    // TODO this doesn't do anything since every property is optional
     const parentConfigData = AbstractConfigInputSchema.parse(machineConfigInput);
+    // TODO to be replaced by defaultConfiguration
     const date = new Date();
     const metadata: ParentConfig = {
       ...({
@@ -536,8 +564,7 @@ export async function addParentConfig(
         machineConfigs: [],
         environmentId: environmentId,
       } as ParentConfig),
-      ...parentConfigData,
-      ...(base ? base : {}),
+      ...machineConfigInput,
     };
 
     metadata.folderId = (await getRootFolder(environmentId)).id;
@@ -558,8 +585,6 @@ export async function addParentConfig(
     store.set('techData', 'targetConfigs', storedData.targetConfigs);
     store.set('techData', 'parameters', storedData.parameters);
 
-    eventHandler.dispatch('machineConfigAdded', { machineConfig: metadata });
-
     return metadata;
   } catch (e: unknown) {
     const error = e as Error;
@@ -567,6 +592,86 @@ export async function addParentConfig(
   }
 }
 
+/**
+ * This adds a new version for a parent configuration to the storage.
+ * @param machineConfigInput Config for which a version is created.
+ * @param environmentId Environment ID for the current space.
+ * @param versionId ID for the version that is to be created.
+ * @param versionName Name for the version that is to be created.
+ * @param versionDescription Description for the version that is to be created.
+ * @returns returns the newly created config version in the case of no errors. Otherwise returns UserError.
+ */
+export async function addParentConfigVersion(
+  machineConfigInput: ParentConfig,
+  environmentId: string,
+  versionId: string,
+  versionName: string,
+  versionDescription: string,
+) {
+  let versions = Array.from(machineConfigInput.versions);
+  versions.push({
+    id: versionId,
+    name: versionName,
+    description: versionDescription,
+    versionBasedOn: machineConfigInput.version,
+    createdOn: new Date(),
+  });
+
+  updateParentConfig(machineConfigInput.id, { versions });
+
+  const newVersion: ParentConfig = JSON.parse(JSON.stringify(machineConfigInput));
+  newVersion.id = newVersion.id;
+
+  try {
+    const newConfig: ParentConfig = {
+      ...(defaultConfiguration(environmentId) as ParentConfig),
+      ...newVersion,
+      version: versionId,
+    };
+
+    newConfig.folderId = (await getRootFolder(environmentId)).id;
+    newConfig.environmentId = environmentId;
+
+    const folderData = foldersMetaObject.folders[newConfig.folderId];
+    if (!folderData) throw new Error('Folder not found');
+
+    // true to generate new IDs for data and create a version of a parentConfig instead of a regular one
+    parentConfigToStorage(newConfig, true, versionId);
+    store.set('techData', 'parentConfigs', storedData.parentConfigs);
+    store.set('techData', 'versionedParentConfigs', storedData.versionedParentConfigs);
+    store.set('techData', 'machineConfigs', storedData.machineConfigs);
+    store.set('techData', 'targetConfigs', storedData.targetConfigs);
+    store.set('techData', 'parameters', storedData.parameters);
+
+    return newConfig;
+  } catch (e: unknown) {
+    const error = e as Error;
+    // console.log(error.message);
+    return userError(error.message ?? "Couldn't create Machine Config");
+  }
+}
+
+/**
+ * Copies the data of a specific config-version into the editable "main-config" displayed as latest version.
+ * @param machineConfigInput The config-version that is to be set as latest version.
+ * @returns Returns the config if no errors occur. Otherwise a UserError is returned.
+ */
+export async function setParentConfigVersionAsLatest(machineConfigInput: ParentConfig) {
+  try {
+    versionToParentConfigStorage(machineConfigInput);
+    store.set('techData', 'parentConfigs', storedData.parentConfigs);
+    store.set('techData', 'machineConfigs', storedData.machineConfigs);
+    store.set('techData', 'targetConfigs', storedData.targetConfigs);
+    store.set('techData', 'parameters', storedData.parameters);
+
+    return machineConfigInput;
+  } catch (e: unknown) {
+    const error = e as Error;
+    // console.log(error.message);
+    return userError(error.message ?? "Couldn't create Machine Config");
+  }
+}
+
 export async function addTargetConfig(parentConfigId: string, targetConfig: TargetConfig) {
   const parentConfig = storedData.parentConfigs[parentConfigId];
   if (!parentConfig)
@@ -768,15 +873,20 @@ export async function removeMachineConfig(machineConfigId: string) {
  */
 export async function removeParentConfiguration(parentConfigId: string) {
   const parentConfig = storedData.parentConfigs[parentConfigId];
+  const parentConfigVersions = storedData.versionedParentConfigs[parentConfigId];
 
   if (!parentConfig) return;
+  if (!parentConfigVersions) return;
 
   delete storedData.parentConfigs[parentConfigId];
+  delete storedData.versionedParentConfigs[parentConfigId];
 
   if (parentConfig.targetConfig) await removeTargetConfig(parentConfig.targetConfig);
   await asyncForEach(parentConfig.machineConfigs, (id) => removeMachineConfig(id));
   await asyncForEach(parentConfig.metadata, (id) => removeParameter(id));
 
+  // TODO for each version removeTargetConfig(), removeMachineConfig(), removeParameter() like above
+
   // remove parentConfig from folder
   foldersMetaObject.folders[parentConfig.folderId]!.children = foldersMetaObject.folders[
     parentConfig.folderId
@@ -784,6 +894,7 @@ export async function removeParentConfiguration(parentConfigId: string) {
 
   // remove from store
   store.set('techData', 'parentConfigs', storedData.parentConfigs);
+  store.set('techData', 'versionedParentConfigs', storedData.versionedParentConfigs);
 }
 
 export const deleteParentConfigurations = async (definitionIds: string[], spaceId: string) => {
diff --git a/src/management-system-v2/lib/data/legacy/store.js b/src/management-system-v2/lib/data/legacy/store.js
index 3171a6b1c..ada3cba77 100644
--- a/src/management-system-v2/lib/data/legacy/store.js
+++ b/src/management-system-v2/lib/data/legacy/store.js
@@ -59,6 +59,7 @@ if (!global.stores) {
       machineConfigs: {},
       targetConfigs: {},
       parameters: {},
+      versionedParentConfigs: {},
     }),
   };
   stores.systemAdmins = { store: getStore('systemAdmins') };
diff --git a/src/management-system-v2/lib/data/machine-config-schema.ts b/src/management-system-v2/lib/data/machine-config-schema.ts
index b0ba7262b..93f6d0182 100644
--- a/src/management-system-v2/lib/data/machine-config-schema.ts
+++ b/src/management-system-v2/lib/data/machine-config-schema.ts
@@ -25,6 +25,7 @@ export const AbstractConfigInputSchema = z.object({
   name: z.string().optional(),
   metadata: z.record(z.string(), ParameterZod),
   folderId: z.string().optional(),
+  version: z.string().optional(),
 });
 
 type Metadata = {