diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.scss b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.scss
new file mode 100644
index 00000000000..f213e451b4e
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.scss
@@ -0,0 +1,21 @@
+.kubevirt-create-vm-modal__container {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.kubevirt-create-vm-modal__wizard-content {
+  flex-flow: wrap
+}
+
+.pf-c-wizard__outer-wrap {
+  min-height: inherit;
+}
+
+.pf-c-wizard__nav {
+  z-index: calc(var(--pf-global--ZIndex--xs) + 1);
+}
+
+.pf-c-wizard__toggle {
+  z-index: calc(var(--pf-global--ZIndex--xs) + 2);
+}
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.tsx
new file mode 100644
index 00000000000..4af2ea47dd0
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.tsx
@@ -0,0 +1,330 @@
+import * as React from 'react';
+import * as _ from 'lodash';
+import { connect } from 'react-redux';
+import { createVm, createVmTemplate } from 'kubevirt-web-ui-components';
+import { Wizard } from '@patternfly/react-core';
+import {
+  PersistentVolumeClaimModel,
+  StorageClassModel,
+  TemplateModel,
+} from '@console/internal/models';
+import {
+  Firehose,
+  history,
+  makeQuery,
+  makeReduxID,
+  units,
+} from '@console/internal/components/utils';
+import { withReduxID } from '../../utils/redux/common';
+import {
+  DataVolumeModel,
+  NetworkAttachmentDefinitionModel,
+  VirtualMachineModel,
+} from '../../models';
+import { TEMPLATE_TYPE_BASE, TEMPLATE_TYPE_LABEL, TEMPLATE_TYPE_VM } from '../../constants/vm';
+import { getResource } from '../../utils';
+import { EnhancedK8sMethods } from '../../k8s/enhancedK8sMethods/enhancedK8sMethods';
+import {
+  cleanupAndGetResults,
+  errorsFirstSort,
+  getResults,
+} from '../../k8s/enhancedK8sMethods/k8sMethodsUtils';
+import {
+  concatImmutableLists,
+  iGetIn,
+  iGetLoadedData,
+  immutableListToShallowJS,
+} from '../../utils/immutable';
+import { getTemplateOperatingSystems } from '../../selectors/vm-template/advanced';
+import {
+  ChangedCommonData,
+  CommonData,
+  CreateVMWizardComponentProps,
+  DetectCommonDataChanges,
+  VMSettingsField,
+  VMWizardProps,
+  VMWizardTab,
+} from './types';
+import {
+  CREATE_VM,
+  CREATE_VM_TEMPLATE,
+  REVIEW_AND_CREATE,
+  TabTitleResolver,
+} from './strings/strings';
+import { vmWizardActions } from './redux/actions';
+import { ActionType } from './redux/types';
+import { iGetCommonData, iGetCreateVMWizardTabs } from './selectors/immutable/selectors';
+import { isStepLocked, isStepValid } from './selectors/immutable/wizard-selectors';
+import { VMSettingsTab } from './tabs/vm-settings-tab/vm-settings-tab';
+import { ResourceLoadErrors } from './resource-load-errors';
+
+import './create-vm-wizard.scss';
+
+export class CreateVMWizardComponent extends React.Component<CreateVMWizardComponentProps> {
+  private isClosed = false;
+
+  constructor(props) {
+    super(props);
+    props.onInitialize();
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.isClosed) {
+      return;
+    }
+    const changedProps = [...DetectCommonDataChanges].reduce((changedPropsAcc, propName) => {
+      if (prevProps[propName] !== this.props[propName]) {
+        changedPropsAcc.add(propName);
+      }
+      return changedPropsAcc;
+    }, new Set()) as ChangedCommonData;
+
+    if (changedProps.size > 0) {
+      this.props.onCommonDataChanged(
+        { dataIDReferences: this.props.dataIDReferences },
+        changedProps,
+      );
+    }
+  }
+
+  onClose = () => {
+    this.isClosed = true;
+    this.props.onClose();
+  };
+
+  finish() {
+    const create = this.props.isCreateTemplate ? createVmTemplate : createVm;
+
+    const enhancedK8sMethods = new EnhancedK8sMethods();
+    const vmSettings = iGetIn(this.props.stepData, [VMWizardTab.VM_SETTINGS, 'value']).toJS();
+    const templates = immutableListToShallowJS(
+      concatImmutableLists(
+        iGetLoadedData(this.props[VMWizardProps.commonTemplates]),
+        iGetLoadedData(this.props[VMWizardProps.userTemplates]),
+      ),
+    );
+
+    // TODO remove after moving create functions from kubevirt-web-ui-components
+    /** *
+     * BEGIN kubevirt-web-ui-components InterOP
+     */
+    vmSettings.namespace = { value: this.props.activeNamespace };
+    const operatingSystems = getTemplateOperatingSystems(templates);
+    const osField = vmSettings[VMSettingsField.OPERATING_SYSTEM];
+    const osID = osField.value;
+    osField.value = operatingSystems.find(({ id }) => id === osID);
+    /**
+     * END kubevirt-web-ui-components InterOP
+     */
+
+    create(
+      enhancedK8sMethods,
+      templates,
+      vmSettings,
+      iGetIn(this.props.stepData, [VMWizardTab.NETWORKS, 'value']).toJS(),
+      iGetIn(this.props.stepData, [VMWizardTab.STORAGE, 'value']).toJS(),
+      immutableListToShallowJS(iGetLoadedData(this.props[VMWizardProps.persistentVolumeClaims])),
+      units,
+    )
+      .then(() => getResults(enhancedK8sMethods))
+      .catch((error) => cleanupAndGetResults(enhancedK8sMethods, error))
+      .then(({ results, valid }) => this.props.onResultsChanged(errorsFirstSort(results), valid)) // TODO should distinguish between errors and objects in redux
+      .catch((e) => console.error(e)); // eslint-disable-line no-console
+  }
+
+  render() {
+    const { isCreateTemplate, stepData } = this.props;
+    const createVmText = isCreateTemplate ? CREATE_VM_TEMPLATE : CREATE_VM;
+
+    if (this.isClosed) {
+      return null;
+    }
+
+    const steps = [
+      {
+        id: VMWizardTab.VM_SETTINGS,
+        component: (
+          <>
+            <ResourceLoadErrors wizardReduxID={this.props.reduxID} />
+            <VMSettingsTab wizardReduxID={this.props.reduxID} />
+          </>
+        ),
+        nextButtonText: REVIEW_AND_CREATE,
+      },
+      // {
+      //   id: VMWizardTab.NETWORKS,
+      // },
+      // {
+      //   id: VMWizardTab.STORAGE,
+      // },
+      {
+        id: VMWizardTab.REVIEW,
+        nextButtonText: createVmText,
+        component: <>VM review</>,
+      },
+      {
+        id: VMWizardTab.RESULT,
+        component: (
+          <>
+            {isStepValid(stepData, VMWizardTab.RESULT) ? 'Created Successfully' : 'Creation Failed'}
+          </>
+        ),
+        isFinishedStep: isStepValid(stepData, VMWizardTab.RESULT),
+      },
+    ];
+
+    const isLocked = _.some(steps, ({ id }) => isStepLocked(stepData, id));
+
+    return (
+      <div className="kubevirt-create-vm-modal__container">
+        {!isStepValid(stepData, VMWizardTab.RESULT) && (
+          <div className="yaml-editor__header">
+            <h1 className="yaml-editor__header-text">{createVmText}</h1>
+          </div>
+        )}
+        <Wizard
+          isInPage
+          className="kubevirt-create-vm-modal__wizard-content"
+          title={createVmText}
+          onClose={this.onClose}
+          onNext={({ id }) => {
+            if (id === VMWizardTab.RESULT) {
+              this.finish();
+            }
+          }}
+          steps={steps.map((step, idx) => {
+            const valid = isStepValid(stepData, step.id);
+            const prevStepValid = idx === 0 ? true : isStepValid(stepData, steps[idx - 1].id);
+            return {
+              ...step,
+              name: TabTitleResolver[step.id],
+              enableNext: !isLocked && valid,
+              canJumpTo: !isLocked && prevStepValid && step.id !== VMWizardTab.RESULT,
+              hideBackButton: isLocked,
+              component: step.component,
+            };
+          })}
+        />
+      </div>
+    );
+  }
+}
+
+const wizardStateToProps = (state, { reduxID }) => ({
+  stepData: iGetCreateVMWizardTabs(state, reduxID),
+  // fetch data from store to detect and fire changes
+  ...[...DetectCommonDataChanges].reduce((acc, propName) => {
+    acc[propName] = iGetCommonData(state, reduxID, propName);
+    return acc;
+  }, {}),
+});
+
+const wizardDispatchToProps = (dispatch, props) => ({
+  onInitialize: () => {
+    dispatch(
+      vmWizardActions[ActionType.Create](props.reduxID, {
+        data: {
+          isCreateTemplate: props.isCreateTemplate,
+        },
+        dataIDReferences: props.dataIDReferences,
+      }),
+    );
+  },
+  onCommonDataChanged: (commonData: CommonData, changedCommonData: ChangedCommonData) => {
+    dispatch(
+      vmWizardActions[ActionType.UpdateCommonData](props.reduxID, commonData, changedCommonData),
+    );
+  },
+  onResultsChanged: (results, isValid) => {
+    dispatch(vmWizardActions[ActionType.SetResults](props.reduxID, results, isValid));
+  },
+  onClose: () => {
+    if (props.onClose) {
+      props.onClose();
+    }
+    dispatch(vmWizardActions[ActionType.Dispose](props.reduxID, props));
+  },
+});
+
+export const CreateVMWizard = connect(
+  wizardStateToProps,
+  wizardDispatchToProps,
+)(CreateVMWizardComponent);
+
+export const CreateVMWizardPageComponent: React.FC<CreateVMWizardPageComponentProps> = (props) => {
+  const {
+    reduxID,
+    match: {
+      params: { ns: activeNamespace },
+    },
+  } = props;
+  const resources = [
+    getResource(VirtualMachineModel, {
+      namespace: activeNamespace,
+      prop: VMWizardProps.virtualMachines,
+    }),
+    getResource(TemplateModel, {
+      namespace: activeNamespace,
+      prop: VMWizardProps.userTemplates,
+      matchLabels: { [TEMPLATE_TYPE_LABEL]: TEMPLATE_TYPE_VM },
+    }),
+    getResource(TemplateModel, {
+      namespace: 'openshift',
+      prop: VMWizardProps.commonTemplates,
+      matchLabels: { [TEMPLATE_TYPE_LABEL]: TEMPLATE_TYPE_BASE },
+    }),
+    getResource(NetworkAttachmentDefinitionModel, {
+      namespace: activeNamespace,
+      prop: VMWizardProps.networkConfigs,
+    }),
+    getResource(StorageClassModel, { prop: VMWizardProps.storageClasses }),
+    getResource(PersistentVolumeClaimModel, {
+      namespace: activeNamespace,
+      prop: VMWizardProps.persistentVolumeClaims,
+    }),
+    getResource(DataVolumeModel, {
+      namespace: activeNamespace,
+      prop: VMWizardProps.dataVolumes,
+    }),
+  ];
+
+  const dataIDReferences = resources.reduce((acc, resource) => {
+    const query = makeQuery(
+      resource.namespace,
+      resource.selector,
+      resource.fieldSelector,
+      resource.name,
+    );
+    acc[resource.prop] = ['k8s', makeReduxID(resource.model, query)];
+
+    return acc;
+  }, {});
+
+  dataIDReferences[VMWizardProps.activeNamespace] = ['UI', 'activeNamespace'];
+
+  return (
+    <Firehose resources={resources}>
+      <CreateVMWizard
+        isCreateTemplate={!props.match.path.includes('/virtualmachines/')}
+        dataIDReferences={dataIDReferences}
+        activeNamespace={activeNamespace}
+        reduxID={reduxID}
+        onClose={() => history.goBack()}
+      />
+    </Firehose>
+  );
+};
+
+type CreateVMWizardPageComponentProps = {
+  match: {
+    params: {
+      ns: string;
+    };
+    path: string;
+    isExact: boolean;
+    url: string;
+  };
+  reduxID: string;
+};
+
+export const CreateVMWizardPage = withReduxID(CreateVMWizardPageComponent);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-context.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-context.tsx
new file mode 100644
index 00000000000..270011164ef
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-context.tsx
@@ -0,0 +1,7 @@
+import * as React from 'react';
+
+export const FormFieldContext = React.createContext({
+  field: null,
+  fieldType: null,
+  isLoading: false,
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-row.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-row.tsx
new file mode 100644
index 00000000000..a1c5bfc2cb1
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field-row.tsx
@@ -0,0 +1,58 @@
+import * as React from 'react';
+import * as _ from 'lodash';
+import { getFieldHelp, getFieldId, getFieldTitle } from '../utils/vm-settings-tab-utils';
+import { isFieldHidden, isFieldRequired } from '../selectors/immutable/vm-settings';
+import { iGet, iGetIn, iGetIsLoaded } from '../../../utils/immutable';
+import { FormRow } from '../../form/form-row';
+import { FormFieldContext } from './form-field-context';
+import { FormFieldType } from './form-field';
+
+const isLoading = (loadingResources?: { [k: string]: any }) =>
+  loadingResources &&
+  _.some(Object.keys(loadingResources), (key) => !iGetIsLoaded(loadingResources[key]));
+
+export const FormFieldRow: React.FC<FieldFormRowProps> = ({
+  field,
+  fieldType,
+  children,
+  loadingResources,
+}) => {
+  const fieldKey = iGet(field, 'key');
+
+  if (!field || !fieldKey || isFieldHidden(field)) {
+    return null;
+  }
+
+  const loading = isLoading(loadingResources);
+
+  return (
+    <FormRow
+      fieldId={getFieldId(fieldKey)}
+      title={fieldType === FormFieldType.INLINE_CHECKBOX ? undefined : getFieldTitle(fieldKey)}
+      help={getFieldHelp(fieldKey, iGet(field, 'value'))}
+      isRequired={isFieldRequired(field)}
+      validationMessage={iGetIn(field, ['validation', 'message'])}
+      validationType={iGetIn(field, ['validation', 'type'])}
+      isLoading={loading}
+    >
+      <FormFieldContext.Provider value={{ field, fieldType, isLoading: loading }}>
+        {children}
+      </FormFieldContext.Provider>
+    </FormRow>
+  );
+};
+
+type FieldFormRowProps = {
+  field: any;
+  fieldType: FormFieldType;
+  children?: React.ReactNode;
+  loadingResources?: { [k: string]: any };
+};
+
+export const FormFieldMemoRow = React.memo(
+  FormFieldRow,
+  (prevProps, nextProps) =>
+    prevProps.field === nextProps.field &&
+    prevProps.fieldType === nextProps.fieldType &&
+    isLoading(prevProps.loadingResources) === isLoading(nextProps.loadingResources),
+);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field.tsx
new file mode 100644
index 00000000000..6247bdfee50
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/form/form-field.tsx
@@ -0,0 +1,80 @@
+import * as React from 'react';
+import * as _ from 'lodash';
+import { inject } from '@console/internal/components/utils';
+import { getPlaceholder, getFieldId, getFieldTitle } from '../utils/vm-settings-tab-utils';
+import { iGetIn } from '../../../utils/immutable';
+import {
+  iGetFieldKey,
+  iGetFieldValue,
+  isFieldDisabled,
+  isFieldRequired,
+} from '../selectors/immutable/vm-settings';
+import { ValidationErrorType } from '../../../utils/validations/types';
+import { FormFieldContext } from './form-field-context';
+
+export enum FormFieldType {
+  TEXT = 'TEXT',
+  TEXT_AREA = 'TEXT_AREA',
+  SELECT = 'SELECT',
+  CHECKBOX = 'CHECKBOX',
+  INLINE_CHECKBOX = 'INLINE_CHECKBOX',
+}
+
+const hasValue = new Set([FormFieldType.TEXT, FormFieldType.TEXT_AREA, FormFieldType.SELECT]);
+const hasIsDisabled = new Set([
+  FormFieldType.TEXT,
+  FormFieldType.SELECT,
+  FormFieldType.CHECKBOX,
+  FormFieldType.INLINE_CHECKBOX,
+]);
+const hasDisabled = new Set([FormFieldType.TEXT_AREA]);
+const hasIsChecked = new Set([FormFieldType.CHECKBOX, FormFieldType.INLINE_CHECKBOX]);
+const hasIsRequired = new Set([FormFieldType.TEXT, FormFieldType.TEXT_AREA]);
+const hasLabel = new Set([FormFieldType.INLINE_CHECKBOX]);
+
+const setSupported = (fieldType: FormFieldType, supportedTypes: Set<FormFieldType>, value) =>
+  supportedTypes.has(fieldType) ? value : undefined;
+
+// renders only when props change (shallow compare)
+export const FormField: React.FC<FormFieldProps> = ({ children, isDisabled }) => {
+  return (
+    <FormFieldContext.Consumer>
+      {({
+        field,
+        fieldType,
+        isLoading,
+      }: {
+        field: any;
+        fieldType: FormFieldType;
+        isLoading: boolean;
+      }) => {
+        const set = setSupported.bind(undefined, fieldType);
+        const value = iGetFieldValue(field);
+        const key = iGetFieldKey(field);
+        const disabled = isDisabled || isFieldDisabled(field) || isLoading;
+
+        return inject(
+          children,
+          _.omitBy(
+            {
+              value: hasValue.has(fieldType) ? value || getPlaceholder(key) || '' : undefined,
+              isChecked: set(hasIsChecked, value),
+              isDisabled: set(hasIsDisabled, disabled),
+              disabled: set(hasDisabled, disabled),
+              isRequired: set(hasIsRequired, isFieldRequired(field)),
+              isValid: iGetIn(field, ['validation', 'type']) !== ValidationErrorType.Error,
+              id: getFieldId(key),
+              label: set(hasLabel, getFieldTitle(key)),
+            },
+            _.isUndefined,
+          ),
+        );
+      }}
+    </FormFieldContext.Consumer>
+  );
+};
+
+type FormFieldProps = {
+  children: React.ReactNode;
+  isDisabled?: boolean;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/index.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/index.ts
new file mode 100644
index 00000000000..f48b4027611
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/index.ts
@@ -0,0 +1 @@
+export { CreateVMWizardPage } from './create-vm-wizard';
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/actions.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/actions.ts
new file mode 100644
index 00000000000..fa43557c765
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/actions.ts
@@ -0,0 +1,85 @@
+import {
+  ALL_VM_WIZARD_TABS,
+  ChangedCommonDataProp,
+  ChangedCommonData,
+  CommonData,
+  DetectCommonDataChanges,
+  VMSettingsField,
+} from '../types';
+import { cleanup, updateAndValidateState } from './utils';
+import { getTabInitialState } from './initial-state';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { ActionType, InternalActionType, WizardActionDispatcher } from './types';
+import { vmWizardInternalActions } from './internal-actions';
+
+type VMWizardActions = { [key in ActionType]: WizardActionDispatcher };
+
+export const vmWizardActions: VMWizardActions = {
+  [ActionType.Create]: (id, commonData: CommonData) => (dispatch, getState) => {
+    const prevState = getState(); // must be called before dispatch
+
+    dispatch(
+      vmWizardInternalActions[InternalActionType.Create](id, {
+        tabs: ALL_VM_WIZARD_TABS.reduce((initial, tabKey) => {
+          initial[tabKey] = getTabInitialState(tabKey, commonData);
+          return initial;
+        }, {}),
+        commonData,
+      }),
+    );
+
+    updateAndValidateState({
+      id,
+      changedCommonData: new Set<ChangedCommonDataProp>(DetectCommonDataChanges),
+      dispatch,
+      getState,
+      prevState,
+    });
+  },
+  [ActionType.Dispose]: (id) => (dispatch, getState) => {
+    const prevState = getState(); // must be called before dispatch
+    cleanup({
+      id,
+      changedCommonData: new Set<ChangedCommonDataProp>(),
+      dispatch,
+      prevState,
+      getState,
+    });
+
+    dispatch(vmWizardInternalActions[InternalActionType.Dispose](id));
+  },
+  [ActionType.SetVmSettingsFieldValue]: (id, key: VMSettingsField, value: string) => (
+    dispatch,
+    getState,
+  ) => {
+    const prevState = getState(); // must be called before dispatch
+    dispatch(vmWizardInternalActions[InternalActionType.SetVmSettingsFieldValue](id, key, value));
+
+    updateAndValidateState({
+      id,
+      dispatch,
+      changedCommonData: new Set<ChangedCommonDataProp>(),
+      getState,
+      prevState,
+    });
+  },
+  [ActionType.UpdateCommonData]: (id, commonData: CommonData, changedProps: ChangedCommonData) => (
+    dispatch,
+    getState,
+  ) => {
+    const prevState = getState(); // must be called before dispatch
+
+    dispatch(vmWizardInternalActions[InternalActionType.UpdateCommonData](id, commonData));
+
+    updateAndValidateState({ id, dispatch, changedCommonData: changedProps, getState, prevState });
+  },
+  [ActionType.SetNetworks]: (id, value: any, valid: boolean, locked: boolean) => (dispatch) => {
+    dispatch(vmWizardInternalActions[InternalActionType.SetNetworks](id, value, valid, locked));
+  },
+  [ActionType.SetStorages]: (id, value: any, valid: boolean, locked: boolean) => (dispatch) => {
+    dispatch(vmWizardInternalActions[InternalActionType.SetStorages](id, value, valid, locked));
+  },
+  [ActionType.SetResults]: (id, value: any, valid: boolean) => (dispatch) => {
+    dispatch(vmWizardInternalActions[InternalActionType.SetResults](id, value, valid));
+  },
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/index.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/index.ts
new file mode 100644
index 00000000000..7960ee6ec64
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/index.ts
@@ -0,0 +1 @@
+export * from './initial-state';
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/initial-state.ts
new file mode 100644
index 00000000000..47b13a8a2f6
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/initial-state.ts
@@ -0,0 +1,25 @@
+import { CommonData, VMWizardTab } from '../../types';
+import { getVmSettingsInitialState } from './vm-settings-tab-initial-state';
+import { getNetworksInitialState } from './networks-tab-initial-state';
+import { getStorageInitialState } from './storage-tab-initial-state';
+import { getResultInitialState } from './result-tab-initial-state';
+import { getReviewInitialState } from './review-tab-initial-state';
+
+const initialStateGetterResolver = {
+  [VMWizardTab.VM_SETTINGS]: getVmSettingsInitialState,
+  [VMWizardTab.NETWORKS]: getNetworksInitialState,
+  [VMWizardTab.STORAGE]: getStorageInitialState,
+  [VMWizardTab.REVIEW]: getReviewInitialState,
+  [VMWizardTab.RESULT]: getResultInitialState,
+};
+
+export const getTabInitialState = (tabKey: VMWizardTab, props: CommonData) => {
+  const getter = initialStateGetterResolver[tabKey];
+
+  let result;
+  if (getter) {
+    result = getter(props);
+  }
+
+  return result || { value: {}, valid: false };
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/networks-tab-initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/networks-tab-initial-state.ts
new file mode 100644
index 00000000000..20d079972d5
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/networks-tab-initial-state.ts
@@ -0,0 +1,18 @@
+import { NetworkBinding, NetworkType, POD_NETWORK } from '../../../../constants/vm';
+
+export const podNetwork = {
+  rootNetwork: {},
+  id: 0,
+  name: 'nic0',
+  mac: '',
+  network: POD_NETWORK,
+  editable: true,
+  edit: false,
+  networkType: NetworkType.POD,
+  binding: NetworkBinding.MASQUERADE,
+};
+
+export const getNetworksInitialState = () => ({
+  value: [podNetwork],
+  valid: true,
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/result-tab-initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/result-tab-initial-state.ts
new file mode 100644
index 00000000000..4f1a0b687fc
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/result-tab-initial-state.ts
@@ -0,0 +1,4 @@
+export const getResultInitialState = () => ({
+  value: {},
+  valid: null, // result of the request
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/review-tab-initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/review-tab-initial-state.ts
new file mode 100644
index 00000000000..a016e2bb030
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/review-tab-initial-state.ts
@@ -0,0 +1,4 @@
+export const getReviewInitialState = () => ({
+  value: {},
+  valid: true,
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/storage-tab-initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/storage-tab-initial-state.ts
new file mode 100644
index 00000000000..de13ac8a42f
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/storage-tab-initial-state.ts
@@ -0,0 +1,33 @@
+// left intentionally empty
+import { ProvisionSource } from '../../../../types/vm';
+import { StorageType } from '../../../../constants/vm/storage';
+
+const rootDisk = {
+  rootStorage: {},
+  name: 'rootdisk',
+  isBootable: true,
+};
+export const rootContainerDisk = {
+  ...rootDisk,
+  storageType: StorageType.CONTAINER,
+};
+export const rootDataVolumeDisk = {
+  ...rootDisk,
+  storageType: StorageType.DATAVOLUME,
+  size: 10,
+};
+export const getInitialDisk = (provisionSource: ProvisionSource) => {
+  switch (provisionSource) {
+    case ProvisionSource.URL:
+      return rootDataVolumeDisk;
+    case ProvisionSource.CONTAINER:
+      return rootContainerDisk;
+    default:
+      return null;
+  }
+};
+
+export const getStorageInitialState = () => ({
+  value: [],
+  valid: true, // empty Storages are valid
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/vm-settings-tab-initial-state.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/vm-settings-tab-initial-state.ts
new file mode 100644
index 00000000000..33ec043464f
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/initial-state/vm-settings-tab-initial-state.ts
@@ -0,0 +1,63 @@
+import { OrderedSet } from 'immutable';
+import { CommonData, VMSettingsField, VMWizardProps } from '../../types';
+import { asHidden, asRequired } from '../../utils/utils';
+import { ProvisionSource } from '../../../../types/vm';
+
+export const getInitialVmSettings = (common: CommonData) => {
+  const {
+    data: { isCreateTemplate },
+  } = common;
+
+  const provisionSources = [
+    // ProvisionSource.PXE, // TODO: uncomment when storage tab is implemented
+    ProvisionSource.URL,
+    ProvisionSource.CONTAINER,
+    // ProvisionSource.CLONED_DISK, // TODO: uncomment when storage tab is implemented
+  ];
+
+  const fields = {
+    [VMSettingsField.NAME]: {
+      isRequired: asRequired(true),
+    },
+    [VMSettingsField.DESCRIPTION]: {},
+    [VMSettingsField.USER_TEMPLATE]: {
+      isHidden: asHidden(isCreateTemplate, VMWizardProps.isCreateTemplate),
+      initialized: false,
+    },
+    [VMSettingsField.PROVISION_SOURCE_TYPE]: {
+      isRequired: asRequired(true),
+      sources: OrderedSet(provisionSources),
+    },
+    [VMSettingsField.CONTAINER_IMAGE]: {},
+    [VMSettingsField.IMAGE_URL]: {},
+    [VMSettingsField.OPERATING_SYSTEM]: {
+      isRequired: asRequired(true),
+    },
+    [VMSettingsField.FLAVOR]: {
+      isRequired: asRequired(true),
+    },
+    [VMSettingsField.MEMORY]: {},
+    [VMSettingsField.CPU]: {},
+    [VMSettingsField.WORKLOAD_PROFILE]: {
+      isRequired: asRequired(true),
+    },
+    [VMSettingsField.START_VM]: {
+      isHidden: asHidden(isCreateTemplate, VMWizardProps.isCreateTemplate),
+    },
+    [VMSettingsField.USE_CLOUD_INIT]: {},
+    [VMSettingsField.USE_CLOUD_INIT_CUSTOM_SCRIPT]: {},
+    [VMSettingsField.HOST_NAME]: {},
+    [VMSettingsField.AUTHKEYS]: {},
+    [VMSettingsField.CLOUD_INIT_CUSTOM_SCRIPT]: {},
+  };
+
+  Object.keys(fields).forEach((k) => {
+    fields[k].key = k;
+  });
+  return fields;
+};
+
+export const getVmSettingsInitialState = (props) => ({
+  value: getInitialVmSettings(props),
+  valid: false,
+});
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/internal-actions.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/internal-actions.ts
new file mode 100644
index 00000000000..9b14cfdf007
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/internal-actions.ts
@@ -0,0 +1,108 @@
+import { VMSettingsField, VMWizardTab } from '../types';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { ActionBatch, InternalActionType, WizardInternalActionDispatcher } from './types';
+
+type VMWizardInternalActions = { [key in InternalActionType]: WizardInternalActionDispatcher };
+
+export const vmWizardInternalActions: VMWizardInternalActions = {
+  [InternalActionType.Create]: (id, value: any) => ({
+    payload: {
+      id,
+      value,
+    },
+    type: InternalActionType.Create,
+  }),
+
+  [InternalActionType.Dispose]: (id) => ({
+    payload: {
+      id,
+    },
+    type: InternalActionType.Dispose,
+  }),
+  [InternalActionType.Update]: (id, value) => ({
+    payload: {
+      id,
+      value,
+    },
+    type: InternalActionType.Update,
+  }),
+  [InternalActionType.UpdateCommonData]: (id, value) => ({
+    payload: {
+      id,
+      value,
+    },
+    type: InternalActionType.UpdateCommonData,
+  }),
+  [InternalActionType.SetTabValidity]: (id, tab: VMWizardTab, valid: boolean) => ({
+    payload: {
+      id,
+      tab,
+      valid,
+    },
+    type: InternalActionType.SetTabValidity,
+  }),
+  [InternalActionType.SetVmSettingsFieldValue]: (id, key: VMSettingsField, value: string) => ({
+    payload: {
+      id,
+      key,
+      value,
+    },
+    type: InternalActionType.SetVmSettingsFieldValue,
+  }),
+  [InternalActionType.UpdateVmSettingsField]: (id, key: VMSettingsField, value) => ({
+    payload: {
+      id,
+      key,
+      value,
+    },
+    type: InternalActionType.UpdateVmSettingsField,
+  }),
+  [InternalActionType.SetInVmSettings]: (id, path: string[], value) => ({
+    payload: {
+      id,
+      path,
+      value,
+    },
+    type: InternalActionType.SetInVmSettings,
+  }),
+  [InternalActionType.SetInVmSettingsBatch]: (id, batch: ActionBatch) => ({
+    payload: {
+      id,
+      batch,
+    },
+    type: InternalActionType.SetInVmSettingsBatch,
+  }),
+  [InternalActionType.UpdateVmSettings]: (id, value) => ({
+    payload: {
+      id,
+      value,
+    },
+    type: InternalActionType.UpdateVmSettings,
+  }),
+  [InternalActionType.SetNetworks]: (id, value, valid: boolean, locked: boolean) => ({
+    payload: {
+      id,
+      value,
+      valid,
+      locked,
+    },
+    type: InternalActionType.SetNetworks,
+  }),
+  [InternalActionType.SetStorages]: (id, value, valid: boolean, locked: boolean) => ({
+    payload: {
+      id,
+      value,
+      valid,
+      locked,
+    },
+    type: InternalActionType.SetStorages,
+  }),
+  [InternalActionType.SetResults]: (id, value, valid: boolean) => ({
+    payload: {
+      id,
+      value,
+      valid,
+    },
+    type: InternalActionType.SetResults,
+  }),
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/reducers.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/reducers.ts
new file mode 100644
index 00000000000..9ca73dbde74
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/reducers.ts
@@ -0,0 +1,100 @@
+import { Map as ImmutableMap, fromJS } from 'immutable';
+import { VMWizardTab } from '../types';
+import { InternalActionType, WizardInternalAction } from './types';
+
+// Merge deep in without updating the keys with undefined values
+const mergeDeepInSpecial = (state, path: string[], value) =>
+  state.updateIn(path, (oldValue) => {
+    if (oldValue) {
+      return oldValue.mergeDeepWith(
+        (oldSubValue, newSubValue) =>
+          typeof newSubValue === 'undefined' ? oldSubValue : newSubValue,
+        value,
+      );
+    }
+    return value;
+  });
+
+const TAB_UPDATE_KEYS = ['value', 'valid', 'locked'];
+
+const setTabKeys = (state, tab: VMWizardTab, action: WizardInternalAction) =>
+  TAB_UPDATE_KEYS.reduce((nextState, key) => {
+    if (typeof action.payload[key] === 'undefined') {
+      return nextState;
+    }
+    return nextState.setIn([action.payload.id, 'tabs', tab, key], fromJS(action.payload[key]));
+  }, state);
+
+const setObjectValues = (state, path, obj) => {
+  return obj
+    ? Object.keys(obj).reduce(
+        (nextState, key) => nextState.setIn([...path, key], fromJS(obj[key])),
+        state,
+      )
+    : state;
+};
+
+export default (state, action: WizardInternalAction) => {
+  if (!state) {
+    return ImmutableMap();
+  }
+  const { payload } = action;
+  const dialogId = payload && payload.id;
+
+  switch (action.type) {
+    case InternalActionType.Create:
+      return state.set(dialogId, fromJS(payload.value));
+    case InternalActionType.Dispose:
+      return state.delete(dialogId);
+    case InternalActionType.SetNetworks:
+      return setTabKeys(state, VMWizardTab.NETWORKS, action);
+    case InternalActionType.SetStorages:
+      return setTabKeys(state, VMWizardTab.STORAGE, action);
+    case InternalActionType.SetResults:
+      return setTabKeys(state, VMWizardTab.RESULT, action);
+    case InternalActionType.Update:
+      return mergeDeepInSpecial(state, [dialogId], fromJS(payload.value));
+    case InternalActionType.UpdateCommonData:
+      return setObjectValues(
+        setObjectValues(state, [dialogId, 'commonData', 'data'], payload.value.data),
+        [dialogId, 'commonData', 'dataIDReferences'],
+        payload.value.dataIDReferences,
+      );
+    case InternalActionType.SetTabValidity:
+      return state.setIn([dialogId, 'tabs', payload.tab, 'valid'], payload.valid);
+    case InternalActionType.SetVmSettingsFieldValue:
+      return state.setIn(
+        [dialogId, 'tabs', VMWizardTab.VM_SETTINGS, 'value', payload.key, 'value'],
+        fromJS(payload.value),
+      );
+    case InternalActionType.SetInVmSettings:
+      return state.setIn(
+        [dialogId, 'tabs', VMWizardTab.VM_SETTINGS, 'value', ...payload.path],
+        fromJS(payload.value),
+      );
+    case InternalActionType.SetInVmSettingsBatch:
+      return payload.batch.reduce(
+        (nextState, { path, value }) =>
+          nextState.setIn(
+            [dialogId, 'tabs', VMWizardTab.VM_SETTINGS, 'value', ...path],
+            fromJS(value),
+          ),
+        state,
+      );
+    case InternalActionType.UpdateVmSettingsField:
+      return mergeDeepInSpecial(
+        state,
+        [dialogId, 'tabs', VMWizardTab.VM_SETTINGS, 'value', payload.key],
+        fromJS(payload.value),
+      );
+    case InternalActionType.UpdateVmSettings:
+      return mergeDeepInSpecial(
+        state,
+        [dialogId, 'tabs', VMWizardTab.VM_SETTINGS, 'value'],
+        fromJS(payload.value),
+      );
+    default:
+      break;
+  }
+  return state;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/prefill-vm-template-state-update.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/prefill-vm-template-state-update.ts
new file mode 100644
index 00000000000..929b2ad3ef4
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/prefill-vm-template-state-update.ts
@@ -0,0 +1,158 @@
+import * as _ from 'lodash';
+import { InternalActionType, UpdateOptions } from '../../types';
+import { iGetVmSettingValue } from '../../../selectors/immutable/vm-settings';
+import { VMSettingsField, VMWizardProps } from '../../../types';
+import { iGetLoadedCommonData, iGetName } from '../../../selectors/immutable/selectors';
+import { concatImmutableLists, immutableListToShallowJS } from '../../../../../utils/immutable';
+import { iGetNetworks as getDialogNetworks } from '../../../selectors/immutable/networks';
+import { iGetStorages } from '../../../selectors/immutable/storage';
+import { podNetwork } from '../../initial-state/networks-tab-initial-state';
+import { vmWizardInternalActions } from '../../internal-actions';
+import { CUSTOM_FLAVOR } from '../../../../../constants/vm';
+import {
+  DEFAULT_CPU,
+  getCloudInitUserData,
+  getCPU,
+  getInterfaces,
+  getMemory,
+  getNetworks,
+  hasAutoAttachPodInterface,
+  parseCPU,
+} from '../../../../../selectors/vm';
+import { selectVM } from '../../../../../selectors/vm-template/selectors';
+import {
+  getTemplateFlavors,
+  getTemplateOperatingSystems,
+  getTemplateWorkloadProfiles,
+} from '../../../../../selectors/vm-template/advanced';
+import { ProvisionSource } from '../../../../../types/vm';
+import {
+  getTemplateProvisionSource,
+  getTemplateStorages,
+} from '../../../../../selectors/vm-template/combined';
+import { getFlavors } from '../../../../../selectors/vm-template/combined-dependent';
+
+// used by user template; currently we do not support PROVISION_SOURCE_IMPORT
+const provisionSourceDataFieldResolver = {
+  [ProvisionSource.CONTAINER]: VMSettingsField.CONTAINER_IMAGE,
+  [ProvisionSource.URL]: VMSettingsField.IMAGE_URL,
+};
+
+export const prefillVmTemplateUpdater = ({ id, dispatch, getState }: UpdateOptions) => {
+  const state = getState();
+
+  const userTemplateName = iGetVmSettingValue(state, id, VMSettingsField.USER_TEMPLATE);
+
+  const iUserTemplates = iGetLoadedCommonData(state, id, VMWizardProps.userTemplates);
+
+  const iUserTemplate =
+    userTemplateName && iUserTemplates
+      ? iUserTemplates.find((template) => iGetName(template) === userTemplateName)
+      : null;
+
+  const vmSettingsUpdate = {};
+
+  // filter out oldTemplates
+  const networkRowsUpdate = immutableListToShallowJS(getDialogNetworks(state, id)).filter(
+    (network) => !network.templateNetwork,
+  );
+  const storageRowsUpdate = immutableListToShallowJS(iGetStorages(state, id)).filter(
+    (storage) => !(storage.templateStorage || storage.rootStorage),
+  );
+
+  if (!networkRowsUpdate.find((row) => row.rootNetwork)) {
+    networkRowsUpdate.push(podNetwork);
+  }
+
+  if (iUserTemplate) {
+    const dataVolumes = immutableListToShallowJS(
+      iGetLoadedCommonData(state, id, VMWizardProps.userTemplates),
+    );
+    const userTemplate = iUserTemplate.toJS();
+
+    const vm = selectVM(userTemplate);
+
+    // update flavor
+    const [flavor] = getTemplateFlavors([userTemplate]);
+    vmSettingsUpdate[VMSettingsField.FLAVOR] = { value: flavor };
+    if (flavor === CUSTOM_FLAVOR) {
+      vmSettingsUpdate[VMSettingsField.CPU] = { value: parseCPU(getCPU(vm), DEFAULT_CPU).cores }; // TODO also add sockets + threads
+      const memory = getMemory(vm);
+      vmSettingsUpdate[VMSettingsField.MEMORY] = { value: memory ? parseInt(memory, 10) : null };
+    }
+
+    // update os
+    const [os] = getTemplateOperatingSystems([userTemplate]);
+    vmSettingsUpdate[VMSettingsField.OPERATING_SYSTEM] = { value: os && os.id };
+
+    // update workload profile
+    const [workload] = getTemplateWorkloadProfiles([userTemplate]);
+    vmSettingsUpdate[VMSettingsField.WORKLOAD_PROFILE] = { value: workload };
+
+    // update cloud-init
+    const cloudInitUserData = getCloudInitUserData(vm);
+    if (cloudInitUserData) {
+      vmSettingsUpdate[VMSettingsField.USE_CLOUD_INIT] = { value: true };
+      vmSettingsUpdate[VMSettingsField.USE_CLOUD_INIT_CUSTOM_SCRIPT] = { value: true };
+      vmSettingsUpdate[VMSettingsField.CLOUD_INIT_CUSTOM_SCRIPT] = {
+        value: cloudInitUserData || '',
+      };
+    }
+
+    // update provision source
+    const provisionSource = getTemplateProvisionSource(userTemplate, dataVolumes);
+    if (provisionSource.type === ProvisionSource.UNKNOWN) {
+      vmSettingsUpdate[VMSettingsField.PROVISION_SOURCE_TYPE] = { value: null };
+    } else {
+      vmSettingsUpdate[VMSettingsField.PROVISION_SOURCE_TYPE] = { value: provisionSource.type };
+      const dataFieldName = provisionSourceDataFieldResolver[provisionSource.type];
+      if (dataFieldName) {
+        vmSettingsUpdate[dataFieldName] = { value: provisionSource.source };
+      }
+    }
+
+    // prefill networks
+    const templateNetworks = getInterfaces(vm).map((i) => ({
+      templateNetwork: {
+        network: getNetworks(vm).find((n) => n.name === i.name),
+        interface: i,
+      },
+    }));
+
+    // do not add root interface if there already is one or autoAttachPodInterface is set to false
+    if (
+      templateNetworks.some((network) => network.templateNetwork.network.pod) ||
+      !hasAutoAttachPodInterface(vm, true)
+    ) {
+      const index = _.findIndex(networkRowsUpdate, (network: any) => network.rootNetwork);
+      networkRowsUpdate.splice(index, 1);
+    }
+
+    networkRowsUpdate.push(...templateNetworks);
+
+    // prefill storage
+    const templateStorages = getTemplateStorages(userTemplate, dataVolumes).map((storage) => ({
+      templateStorage: storage,
+      rootStorage: storage.disk.bootOrder === 1 ? {} : undefined,
+    }));
+    storageRowsUpdate.push(...templateStorages);
+  } else {
+    const iCommonTemplates = iGetLoadedCommonData(state, id, VMWizardProps.commonTemplates);
+
+    const flavors = getFlavors(
+      immutableListToShallowJS(concatImmutableLists(iCommonTemplates, iUserTemplates)),
+      {
+        workload: iGetVmSettingValue(state, id, VMSettingsField.WORKLOAD_PROFILE),
+        os: iGetVmSettingValue(state, id, VMSettingsField.OPERATING_SYSTEM),
+        userTemplate: null,
+      },
+    );
+    if (flavors.length === 1) {
+      vmSettingsUpdate[VMSettingsField.FLAVOR] = { value: flavors[0] };
+    }
+  }
+
+  dispatch(vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, vmSettingsUpdate));
+  dispatch(vmWizardInternalActions[InternalActionType.SetNetworks](id, networkRowsUpdate));
+  dispatch(vmWizardInternalActions[InternalActionType.SetStorages](id, storageRowsUpdate));
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/vm-settings-tab-state-update.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/vm-settings-tab-state-update.ts
new file mode 100644
index 00000000000..36677a0320a
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/vm-settings-tab-state-update.ts
@@ -0,0 +1,207 @@
+import {
+  hasVmSettingsChanged,
+  iGetVmSettingAttribute,
+  iGetVmSettingValue,
+} from '../../../selectors/immutable/vm-settings';
+import { VMSettingsField, VMWizardProps } from '../../../types';
+import { InternalActionType, UpdateOptions } from '../../types';
+import { asDisabled, asHidden, asRequired } from '../../../utils/utils';
+import { vmWizardInternalActions } from '../../internal-actions';
+import {
+  iGetCommonData,
+  iGetLoadedCommonData,
+  iGetName,
+} from '../../../selectors/immutable/selectors';
+import {
+  iGetIsLoaded,
+  iGetLoadedData,
+  immutableListToShallowJS,
+} from '../../../../../utils/immutable';
+import { ProvisionSource } from '../../../../../types/vm';
+import { ignoreCaseSort } from '../../../../../utils/sort';
+import { CUSTOM_FLAVOR } from '../../../../../constants/vm';
+import { iGetStorages } from '../../../selectors/immutable/storage';
+import { getInitialDisk } from '../../initial-state/storage-tab-initial-state';
+import { prefillVmTemplateUpdater } from './prefill-vm-template-state-update';
+
+export const selectUserTemplateOnLoadedUpdater = ({
+  id,
+  dispatch,
+  getState,
+  changedCommonData,
+}: UpdateOptions) => {
+  const state = getState();
+  if (
+    iGetCommonData(state, id, VMWizardProps.isCreateTemplate) ||
+    iGetVmSettingAttribute(state, id, VMSettingsField.USER_TEMPLATE, 'initialized') ||
+    !(
+      changedCommonData.has(VMWizardProps.userTemplates) ||
+      changedCommonData.has(VMWizardProps.commonTemplates) ||
+      changedCommonData.has(VMWizardProps.dataVolumes)
+    )
+  ) {
+    return;
+  }
+
+  const iUserTemplatesWrapper = iGetCommonData(state, id, VMWizardProps.userTemplates);
+  const iCommonTemplatesWrapper = iGetCommonData(state, id, VMWizardProps.commonTemplates); // flavor prefill
+  const iDataVolumeWrapper = iGetCommonData(state, id, VMWizardProps.dataVolumes); // template prefill
+
+  if (
+    !iGetIsLoaded(iUserTemplatesWrapper) ||
+    !iGetIsLoaded(iCommonTemplatesWrapper) ||
+    !iGetIsLoaded(iDataVolumeWrapper)
+  ) {
+    return;
+  }
+
+  const iUserTemplates = iGetLoadedData(iUserTemplatesWrapper);
+
+  const firstUserTemplateName = ignoreCaseSort(
+    iUserTemplates
+      .toIndexedSeq()
+      .toArray()
+      .map(iGetName),
+  )[0];
+
+  dispatch(
+    vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, {
+      [VMSettingsField.USER_TEMPLATE]: {
+        initialized: true,
+        value: firstUserTemplateName,
+      },
+    }),
+  );
+};
+
+export const selectedUserTemplateUpdater = (options: UpdateOptions) => {
+  const { id, prevState, dispatch, getState } = options;
+  const state = getState();
+  if (!hasVmSettingsChanged(prevState, state, id, VMSettingsField.USER_TEMPLATE)) {
+    return;
+  }
+
+  const userTemplates = iGetLoadedCommonData(state, id, VMWizardProps.userTemplates);
+
+  const userTemplateName = iGetVmSettingValue(state, id, VMSettingsField.USER_TEMPLATE);
+
+  const iUserTemplate =
+    userTemplateName && userTemplates
+      ? userTemplates.find((template) => iGetName(template) === userTemplateName)
+      : null;
+
+  const isDisabled = asDisabled(iUserTemplate != null, VMSettingsField.USER_TEMPLATE);
+
+  dispatch(
+    vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, {
+      [VMSettingsField.PROVISION_SOURCE_TYPE]: { isDisabled },
+      [VMSettingsField.CONTAINER_IMAGE]: { isDisabled },
+      [VMSettingsField.IMAGE_URL]: { isDisabled },
+      [VMSettingsField.OPERATING_SYSTEM]: { isDisabled },
+      [VMSettingsField.WORKLOAD_PROFILE]: { isDisabled },
+    }),
+  );
+
+  if (iGetVmSettingAttribute(state, id, VMSettingsField.USER_TEMPLATE, 'initialized')) {
+    prefillVmTemplateUpdater(options);
+  }
+};
+
+export const provisioningSourceUpdater = ({ id, prevState, dispatch, getState }: UpdateOptions) => {
+  const state = getState();
+  if (
+    !hasVmSettingsChanged(
+      prevState,
+      state,
+      id,
+      VMSettingsField.PROVISION_SOURCE_TYPE,
+      VMSettingsField.USER_TEMPLATE,
+    )
+  ) {
+    return;
+  }
+  const source = iGetVmSettingValue(state, id, VMSettingsField.PROVISION_SOURCE_TYPE);
+  const isContainer = source === ProvisionSource.CONTAINER;
+  const isUrl = source === ProvisionSource.URL;
+
+  dispatch(
+    vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, {
+      [VMSettingsField.CONTAINER_IMAGE]: {
+        value: isContainer ? undefined : null,
+        isRequired: asRequired(isContainer, VMSettingsField.PROVISION_SOURCE_TYPE),
+        isHidden: asHidden(!isContainer, VMSettingsField.PROVISION_SOURCE_TYPE),
+      },
+      [VMSettingsField.IMAGE_URL]: {
+        value: isUrl ? undefined : null,
+        isRequired: asRequired(isUrl, VMSettingsField.PROVISION_SOURCE_TYPE),
+        isHidden: asHidden(!isUrl, VMSettingsField.PROVISION_SOURCE_TYPE),
+      },
+    }),
+  );
+};
+
+// TODO: move this logic to StorageTab?
+export const prefillInitialDiskUpdater = ({ id, prevState, dispatch, getState }: UpdateOptions) => {
+  const state = getState();
+  if (
+    !hasVmSettingsChanged(
+      prevState,
+      state,
+      id,
+      VMSettingsField.PROVISION_SOURCE_TYPE,
+      VMSettingsField.USER_TEMPLATE,
+    )
+  ) {
+    return;
+  }
+
+  const storageRowsUpdate = immutableListToShallowJS(iGetStorages(state, id)).filter(
+    (storage) => storage.templateStorage || !storage.rootStorage,
+  );
+  // template pre-fills its own storages
+  if (!iGetVmSettingValue(state, id, VMSettingsField.USER_TEMPLATE)) {
+    const storage = getInitialDisk(
+      iGetVmSettingValue(state, id, VMSettingsField.PROVISION_SOURCE_TYPE),
+    );
+    if (storage) {
+      storageRowsUpdate.push(storage);
+    }
+  }
+
+  dispatch(vmWizardInternalActions[InternalActionType.SetStorages](id, storageRowsUpdate));
+};
+
+export const flavorUpdater = ({ id, prevState, dispatch, getState }: UpdateOptions) => {
+  const state = getState();
+  if (!hasVmSettingsChanged(prevState, state, id, VMSettingsField.FLAVOR)) {
+    return;
+  }
+  const flavor = iGetVmSettingValue(state, id, VMSettingsField.FLAVOR);
+
+  const isHidden = asHidden(flavor !== CUSTOM_FLAVOR, VMSettingsField.FLAVOR);
+  const isRequired = asRequired(flavor === CUSTOM_FLAVOR, VMSettingsField.FLAVOR);
+
+  dispatch(
+    vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, {
+      [VMSettingsField.MEMORY]: {
+        isHidden,
+        isRequired,
+      },
+      [VMSettingsField.CPU]: {
+        isHidden,
+        isRequired,
+      },
+    }),
+  );
+};
+
+export const updateVmSettingsState = (options: UpdateOptions) =>
+  [
+    selectUserTemplateOnLoadedUpdater,
+    selectedUserTemplateUpdater,
+    provisioningSourceUpdater,
+    prefillInitialDiskUpdater,
+    flavorUpdater,
+  ].forEach((updater) => {
+    updater && updater(options);
+  });
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/types.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/types.ts
new file mode 100644
index 00000000000..a6d0d21dee2
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/types.ts
@@ -0,0 +1,80 @@
+import {
+  ChangedCommonData,
+  ChangedCommonDataProp,
+  VMSettingsField,
+  VMSettingsFieldType,
+  VMWizardTab,
+} from '../types';
+import { ValidationObject } from '../../../utils/validations/types';
+
+export enum ActionType {
+  Create = 'KubevirtVMWizardCreate',
+  Dispose = 'KubevirtVMWizardDispose',
+  UpdateCommonData = 'KubevirtVMWizardUpdateCommonData',
+  SetVmSettingsFieldValue = 'KubevirtVMWizardSetVmSettingsFieldValue',
+  SetNetworks = 'KubevirtVMWizardSetNetworks',
+  SetStorages = 'KubevirtVMWizardSetStorages',
+  SetResults = 'KubevirtVMWizardSetResults',
+}
+
+// should not be called directly from outside redux code (e.g. stateUpdate)
+export enum InternalActionType {
+  Create = 'KubevirtVMWizardCreate',
+  Dispose = 'KubevirtVMWizardDispose',
+  Update = 'KubevirtVMWizardUpdateInternal',
+  UpdateCommonData = 'KubevirtVMWizardUpdateCommonData',
+  SetTabValidity = 'KubevirtVMWizardSetTabValidityInternal',
+  SetVmSettingsFieldValue = 'KubevirtVMWizardSetVmSettingsFieldValueInternal',
+  SetInVmSettings = 'KubevirtVMWizardSetInVmSettingsInternal',
+  SetInVmSettingsBatch = 'KubevirtVMWizardSetInVmSettingsBatchInternal',
+  UpdateVmSettingsField = 'KubevirtVMWizardUpdateVmSettingsFieldInternal',
+  UpdateVmSettings = 'KubevirtVMWizardUpdateVmSettingsInternal',
+  SetNetworks = 'KubevirtVMWizardSetNetworks',
+  SetStorages = 'KubevirtVMWizardSetStorages',
+  SetResults = 'KubevirtVMWizardSetResults',
+}
+
+export type WizardInternalAction = {
+  type: InternalActionType;
+  payload: {
+    id: string;
+    value?: any;
+    valid?: boolean;
+    locked?: boolean;
+    path?: string[];
+    key?: VMSettingsField;
+    tab?: VMWizardTab;
+    batch?: ActionBatch;
+  };
+};
+
+export type WizardInternalActionDispatcher = (id: string, ...any) => WizardInternalAction;
+export type WizardActionDispatcher = (
+  id: string,
+  ...any
+) => (dispatch: Function, getState: Function) => void;
+
+export type ActionBatch = { path: string[]; value: any }[];
+
+export type UpdateOptions = {
+  id: string;
+  changedCommonData: ChangedCommonData;
+  dispatch: Function;
+  getState: Function;
+  prevState: any;
+};
+
+export type VmSettingsValidator = (
+  field: VMSettingsFieldType,
+  options: UpdateOptions,
+) => ValidationObject;
+
+export type VMSettingsValidationConfig = {
+  [key: string]: {
+    detectValueChanges?: ((field, options) => VMSettingsField[]) | VMSettingsField[];
+    detectCommonDataChanges?:
+      | ((field, options) => ChangedCommonDataProp[])
+      | ChangedCommonDataProp[];
+    validator: VmSettingsValidator;
+  };
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/utils.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/utils.ts
new file mode 100644
index 00000000000..f6b08d810f1
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/utils.ts
@@ -0,0 +1,56 @@
+import { VMWizardTab } from '../types';
+import { UpdateOptions } from './types';
+import { updateVmSettingsState } from './stateUpdate/vmSettings/vm-settings-tab-state-update';
+import {
+  setVmSettingsTabValidity,
+  validateVmSettings,
+} from './validations/vm-settings-tab-validation';
+
+const UPDATE_TABS = [VMWizardTab.VM_SETTINGS];
+
+const updaterResolver = {
+  [VMWizardTab.VM_SETTINGS]: updateVmSettingsState,
+};
+
+const validateTabResolver = {
+  [VMWizardTab.VM_SETTINGS]: validateVmSettings,
+};
+
+const isTabValidResolver = {
+  [VMWizardTab.VM_SETTINGS]: setVmSettingsTabValidity,
+};
+
+export const updateAndValidateState = (options: UpdateOptions) => {
+  const { prevState, changedCommonData, getState } = options;
+
+  const propsChanged = Object.keys(changedCommonData).some((key) => changedCommonData[key]);
+  const enhancedOptions = { ...options, propsChanged };
+
+  UPDATE_TABS.forEach((tabKey) => {
+    const updater = updaterResolver[tabKey];
+    updater && updater(enhancedOptions);
+  });
+
+  if (propsChanged || prevState !== getState()) {
+    UPDATE_TABS.forEach((tabKey) => {
+      const dataValidator = validateTabResolver[tabKey];
+      const tabValidator = isTabValidResolver[tabKey];
+
+      if (dataValidator) {
+        dataValidator(options);
+      }
+
+      if (tabValidator) {
+        tabValidator(enhancedOptions);
+      }
+    });
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const cleanup = (options: UpdateOptions) => {
+  // TODO (suomiy): add providers
+  // getProviders().forEach((provider) => {
+  //   cleanupProvider(provider, options);
+  // });
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/utils.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/utils.ts
new file mode 100644
index 00000000000..59c395f6d9f
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/utils.ts
@@ -0,0 +1,42 @@
+import { Map as ImmutableMap } from 'immutable';
+import * as _ from 'lodash';
+import { UpdateOptions, VMSettingsValidationConfig } from '../types';
+import { ValidationObject } from '../../../../utils/validations/types';
+import { VMSettingsFieldType } from '../../types';
+
+export const getValidationUpdate = (
+  config: VMSettingsValidationConfig,
+  options: UpdateOptions,
+  fields: ImmutableMap<string, VMSettingsFieldType>,
+  compareField: (prevState, state, id: string, key: any) => boolean,
+) => {
+  const { id, changedCommonData, prevState, getState } = options;
+  const state = getState();
+
+  return Object.keys(config).reduce((updateAcc, validationFieldKey) => {
+    const { detectValueChanges, detectCommonDataChanges, validator } = config[validationFieldKey];
+
+    const field = fields.get(validationFieldKey);
+
+    const detectValues = _.isFunction(detectValueChanges)
+      ? detectValueChanges(field, options)
+      : detectValueChanges;
+    const detectCommonData = _.isFunction(detectCommonDataChanges)
+      ? detectCommonDataChanges(field, options)
+      : detectCommonDataChanges;
+
+    const needsValidationUpdate =
+      (detectValues &&
+        detectValues.some((fieldKey) => compareField(prevState, state, id, fieldKey))) ||
+      (detectCommonData && detectCommonData.some((fieldKey) => changedCommonData[fieldKey]));
+
+    if (needsValidationUpdate) {
+      const validation = validator(field, options);
+      // null -> value || oldValue -> null || oldValue -> value
+      if (field.get('validation') || validation) {
+        updateAcc[validationFieldKey] = { validation };
+      }
+    }
+    return updateAcc;
+  }, {}) as { [key: string]: { validation: ValidationObject } };
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/vm-settings-tab-validation.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/vm-settings-tab-validation.ts
new file mode 100644
index 00000000000..fe073bfb274
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/vm-settings-tab-validation.ts
@@ -0,0 +1,168 @@
+import { isEmpty } from 'lodash';
+import { List } from 'immutable';
+import { VMSettingsField, VMWizardProps, VMWizardTab } from '../../types';
+import {
+  iGetFieldKey,
+  iGetVmSettings,
+  hasVmSettingsChanged,
+  iGetFieldValue,
+  isFieldRequired,
+} from '../../selectors/immutable/vm-settings';
+import {
+  InternalActionType,
+  UpdateOptions,
+  VMSettingsValidationConfig,
+  VmSettingsValidator,
+} from '../types';
+import { vmWizardInternalActions } from '../internal-actions';
+import { ValidationErrorType, ValidationObject } from '../../../../utils/validations/types';
+import {
+  validateUserTemplateProvisionSource,
+  validateVmLikeEntityName,
+} from '../../../../utils/validations/vm';
+import {
+  VIRTUAL_MACHINE_EXISTS,
+  VIRTUAL_MACHINE_TEMPLATE_EXISTS,
+} from '../../../../utils/validations/strings';
+import { concatImmutableLists, immutableListToShallowJS } from '../../../../utils/immutable';
+import { getFieldTitle } from '../../utils/vm-settings-tab-utils';
+import {
+  iGetCommonData,
+  iGetLoadedCommonData,
+  iGetName,
+  immutableListToShallowMetadataJS,
+} from '../../selectors/immutable/selectors';
+import {
+  validatePositiveInteger,
+  validateTrim,
+  validateURL,
+} from '../../../../utils/validations/common';
+import { getValidationUpdate } from './utils';
+
+const validateVm: VmSettingsValidator = (field, options) => {
+  const { getState, id } = options;
+  const state = getState();
+
+  const isCreateTemplate = iGetCommonData(state, id, VMWizardProps.isCreateTemplate);
+
+  const entities = isCreateTemplate
+    ? concatImmutableLists(
+        iGetLoadedCommonData(state, id, VMWizardProps.commonTemplates),
+        iGetLoadedCommonData(state, id, VMWizardProps.userTemplates),
+      )
+    : iGetLoadedCommonData(state, id, VMWizardProps.virtualMachines);
+
+  return validateVmLikeEntityName(
+    iGetFieldValue(field),
+    iGetCommonData(state, id, VMWizardProps.activeNamespace),
+    immutableListToShallowMetadataJS(entities),
+    {
+      existsErrorMessage: isCreateTemplate
+        ? VIRTUAL_MACHINE_TEMPLATE_EXISTS
+        : VIRTUAL_MACHINE_EXISTS,
+      subject: getFieldTitle(iGetFieldKey(field)),
+    },
+  );
+};
+
+export const validateUserTemplate: VmSettingsValidator = (field, options) => {
+  const { getState, id } = options;
+  const state = getState();
+
+  const userTemplateName = iGetFieldValue(field);
+  if (!userTemplateName) {
+    return null;
+  }
+  const userTemplate = iGetLoadedCommonData(state, id, VMWizardProps.userTemplates, List()).find(
+    (template) => iGetName(template) === userTemplateName,
+  );
+
+  const dataVolumes = immutableListToShallowJS(
+    iGetLoadedCommonData(state, id, VMWizardProps.userTemplates),
+  );
+
+  return validateUserTemplateProvisionSource(userTemplate && userTemplate.toJSON(), dataVolumes);
+};
+
+const asVMSettingsFieldValidator = (
+  validator: (value: string, opts: { subject: string }) => ValidationObject,
+) => (field) =>
+  validator(iGetFieldValue(field), {
+    subject: getFieldTitle(iGetFieldKey(field)),
+  });
+
+const validationConfig: VMSettingsValidationConfig = {
+  [VMSettingsField.NAME]: {
+    detectValueChanges: [VMSettingsField.NAME],
+    detectCommonDataChanges: (field, options) => {
+      const isCreateTemplate = iGetCommonData(
+        options.getState(),
+        options.id,
+        VMWizardProps.isCreateTemplate,
+      );
+      return isCreateTemplate
+        ? [
+            VMWizardProps.activeNamespace,
+            VMWizardProps.userTemplates,
+            VMWizardProps.commonTemplates,
+          ]
+        : [VMWizardProps.activeNamespace, VMWizardProps.virtualMachines];
+    },
+    validator: validateVm,
+  },
+  [VMSettingsField.CONTAINER_IMAGE]: {
+    detectValueChanges: [VMSettingsField.CONTAINER_IMAGE],
+    validator: asVMSettingsFieldValidator(validateTrim),
+  },
+  [VMSettingsField.USER_TEMPLATE]: {
+    detectValueChanges: [VMSettingsField.USER_TEMPLATE],
+    detectCommonDataChanges: [VMWizardProps.userTemplates, VMWizardProps.dataVolumes],
+    validator: validateUserTemplate,
+  },
+  [VMSettingsField.IMAGE_URL]: {
+    detectValueChanges: [VMSettingsField.IMAGE_URL],
+    validator: asVMSettingsFieldValidator(validateURL),
+  },
+  [VMSettingsField.CPU]: {
+    detectValueChanges: [VMSettingsField.CPU],
+    validator: asVMSettingsFieldValidator(validatePositiveInteger),
+  },
+  [VMSettingsField.MEMORY]: {
+    detectValueChanges: [VMSettingsField.MEMORY],
+    validator: asVMSettingsFieldValidator(validatePositiveInteger),
+  },
+};
+
+export const validateVmSettings = (options: UpdateOptions) => {
+  const { id, dispatch, getState } = options;
+  const state = getState();
+  const vmSettings = iGetVmSettings(state, id);
+
+  const update = getValidationUpdate(validationConfig, options, vmSettings, hasVmSettingsChanged);
+
+  if (!isEmpty(update)) {
+    dispatch(vmWizardInternalActions[InternalActionType.UpdateVmSettings](id, update));
+  }
+};
+
+export const setVmSettingsTabValidity = (options: UpdateOptions) => {
+  const { id, dispatch, getState } = options;
+  const state = getState();
+  const vmSettings = iGetVmSettings(state, id);
+
+  // check if all required fields are defined
+  let valid = vmSettings
+    .filter((field) => isFieldRequired(field))
+    .every((field) => field.get('value'));
+
+  if (valid) {
+    // check if all fields are valid
+    valid = vmSettings.every(
+      (field) => field.getIn(['validation', 'type']) !== ValidationErrorType.Error,
+    );
+  }
+
+  dispatch(
+    vmWizardInternalActions[InternalActionType.SetTabValidity](id, VMWizardTab.VM_SETTINGS, valid),
+  );
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/resource-load-errors.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/resource-load-errors.tsx
new file mode 100644
index 00000000000..3c905d9ea70
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/resource-load-errors.tsx
@@ -0,0 +1,33 @@
+import { connect } from 'react-redux';
+import { AlertVariant } from '@patternfly/react-core';
+import { iGet } from '../../utils/immutable';
+import { Errors, Error } from '../errors/errors';
+import { COULD_NOT_LOAD_DATA } from '../../utils/strings';
+import { CommonDataProp, VMWizardProps } from './types';
+import { iGetCommonData } from './selectors/immutable/selectors';
+
+const asError = (state, id: string, key: CommonDataProp, variant?: AlertVariant): Error => {
+  const loadError = iGet(iGetCommonData(state, id, key), 'loadError');
+  return (
+    loadError && {
+      message: loadError.message,
+      title: COULD_NOT_LOAD_DATA,
+      key: key as string,
+      variant: variant || AlertVariant.danger,
+    }
+  );
+};
+
+const stateToProps = (state, { wizardReduxID }) => ({
+  errors: [
+    asError(state, wizardReduxID, VMWizardProps.commonTemplates),
+    asError(state, wizardReduxID, VMWizardProps.userTemplates),
+    asError(state, wizardReduxID, VMWizardProps.networkConfigs),
+    asError(state, wizardReduxID, VMWizardProps.persistentVolumeClaims),
+    asError(state, wizardReduxID, VMWizardProps.dataVolumes),
+    asError(state, wizardReduxID, VMWizardProps.storageClasses),
+    asError(state, wizardReduxID, VMWizardProps.virtualMachines, AlertVariant.warning), // for validation only
+  ],
+});
+
+export const ResourceLoadErrors = connect(stateToProps)(Errors);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/networks.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/networks.ts
new file mode 100644
index 00000000000..6997327d3ed
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/networks.ts
@@ -0,0 +1,6 @@
+import { iGetIn } from '../../../../utils/immutable';
+import { VMWizardTab } from '../../types';
+import { iGetCreateVMWizardTabs } from './selectors';
+
+export const iGetNetworks = (state, id: string) =>
+  iGetIn(iGetCreateVMWizardTabs(state, id), [VMWizardTab.NETWORKS, 'value']);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/selectors.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/selectors.ts
new file mode 100644
index 00000000000..3c687831a41
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/selectors.ts
@@ -0,0 +1,48 @@
+import { K8sResourceKind } from '@console/internal/module/k8s';
+import { iGet, iGetIn, iGetLoadedData } from '../../../../utils/immutable';
+import { getCreateVMWizards } from '../selectors';
+import { CommonDataProp } from '../../types';
+
+export const iGetCreateVMWizard = (state, reduxID: string) =>
+  iGet(getCreateVMWizards(state), reduxID);
+export const iGetCreateVMWizardTabs = (state, reduxID: string) =>
+  iGet(iGetCreateVMWizard(state, reduxID), 'tabs');
+
+export const iGetCommonData = (state, reduxID: string, key: CommonDataProp) => {
+  const wizard = iGetCreateVMWizard(state, reduxID);
+  const data = iGetIn(wizard, ['commonData', 'data', key]);
+  if (data !== undefined) {
+    return data;
+  }
+
+  const dataRefererence = iGetIn(wizard, ['commonData', 'dataIDReferences', key]);
+
+  if (dataRefererence && dataRefererence.size > 0) {
+    const firstStep = state[dataRefererence.first()];
+
+    return firstStep && firstStep.getIn(dataRefererence.skip(1));
+  }
+  return undefined;
+};
+
+export const iGetName = (o) =>
+  iGetIn(o, ['metadata', 'name']) as K8sResourceKind['metadata']['name'];
+export const iGetNamespace = (o) =>
+  iGetIn(o, ['metadata', 'namespace']) as K8sResourceKind['metadata']['namespace'];
+
+export const iGetLoadedCommonData = (
+  state,
+  reduxID: string,
+  key: CommonDataProp,
+  defaultValue = undefined,
+) => iGetLoadedData(iGetCommonData(state, reduxID, key), defaultValue);
+
+export const immutableListToShallowMetadataJS = (list, defaultValue = []) =>
+  list
+    ? list.toArray().map((p) => ({
+        metadata: {
+          name: iGetName(p),
+          namespace: iGetNamespace(p),
+        },
+      }))
+    : defaultValue;
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/storage.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/storage.ts
new file mode 100644
index 00000000000..7767d701d58
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/storage.ts
@@ -0,0 +1,6 @@
+import { iGetIn } from '../../../../utils/immutable';
+import { VMWizardTab } from '../../types';
+import { iGetCreateVMWizardTabs } from './selectors';
+
+export const iGetStorages = (state, id: string) =>
+  iGetIn(iGetCreateVMWizardTabs(state, id), [VMWizardTab.STORAGE, 'value']);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/vm-settings.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/vm-settings.ts
new file mode 100644
index 00000000000..794aab78e6f
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/vm-settings.ts
@@ -0,0 +1,37 @@
+import { hasTruthyValue, iGet, iGetIn } from '../../../../utils/immutable';
+import { VMSettingsField, VMWizardTab } from '../../types';
+import { iGetCreateVMWizardTabs } from './selectors';
+
+export const VM_SETTINGS_METADATA_ID = 'VM_SETTINGS_METADATA_ID';
+export const VMWARE_PROVIDER_METADATA_ID = 'VMWARE_PROVIDER_METADATA_ID';
+
+export const iGetFieldValue = (field, defaultValue = undefined) =>
+  iGet(field, 'value', defaultValue);
+export const iGetFieldKey = (field, defaultValue = undefined) => iGet(field, 'key', defaultValue);
+
+export const isFieldRequired = (field) => hasTruthyValue(iGet(field, 'isRequired'));
+export const isFieldHidden = (field) => hasTruthyValue(iGet(field, 'isHidden'));
+export const isFieldDisabled = (field) => hasTruthyValue(iGet(field, 'isDisabled'));
+
+export const iGetVmSettings = (state, id: string) =>
+  iGetIn(iGetCreateVMWizardTabs(state, id), [VMWizardTab.VM_SETTINGS, 'value']);
+export const iGetVmSetting = (state, id: string, path, defaultValue = undefined) =>
+  iGetIn(iGetVmSettings(state, id), path, defaultValue);
+
+export const hasVmSettingsChanged = (prevState, state, id: string, ...keys: VMSettingsField[]) =>
+  !!keys.find((key) => iGetVmSetting(prevState, id, [key]) !== iGetVmSetting(state, id, [key]));
+
+export const iGetVmSettingAttribute = (
+  state,
+  id: string,
+  key: VMSettingsField,
+  attribute = 'value',
+  defaultValue = undefined,
+) => iGetVmSetting(state, id, [key, attribute], defaultValue);
+
+export const iGetVmSettingValue = (
+  state,
+  id: string,
+  key: VMSettingsField,
+  defaultValue = undefined,
+) => iGetVmSettingAttribute(state, id, key, 'value', defaultValue);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/wizard-selectors.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/wizard-selectors.ts
new file mode 100644
index 00000000000..a4520612037
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/immutable/wizard-selectors.ts
@@ -0,0 +1,4 @@
+import { iGetIn } from '../../../../utils/immutable';
+
+export const isStepValid = (stepData, stepId: string) => !!iGetIn(stepData, [stepId, 'valid']);
+export const isStepLocked = (stepData, stepId: string) => !!iGetIn(stepData, [stepId, 'locked']);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/selectors.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/selectors.ts
new file mode 100644
index 00000000000..c962e44bcc3
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/selectors.ts
@@ -0,0 +1,5 @@
+import { get } from 'lodash';
+import { Map } from 'immutable';
+
+export const getCreateVMWizards = (state): Map<string, any> =>
+  get(state, ['kubevirt', 'createVmWizards']);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/strings.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/strings.ts
new file mode 100644
index 00000000000..c94c79ec311
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/strings.ts
@@ -0,0 +1,15 @@
+import { VMWizardTab } from '../types';
+
+export const CREATE_VM = 'Create Virtual Machine';
+export const CREATE_VM_TEMPLATE = `${CREATE_VM} Template`;
+export const REVIEW_AND_CREATE = 'Review and create';
+export const NO_TEMPLATE = 'None';
+export const NO_TEMPLATE_AVAILABLE = 'No template available';
+
+export const TabTitleResolver = {
+  [VMWizardTab.VM_SETTINGS]: 'General',
+  [VMWizardTab.NETWORKS]: 'Networking',
+  [VMWizardTab.STORAGE]: 'Storage',
+  [VMWizardTab.REVIEW]: 'Review',
+  [VMWizardTab.RESULT]: 'Result',
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/vm-settings.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/vm-settings.ts
new file mode 100644
index 00000000000..b3de2c7ee59
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/vm-settings.ts
@@ -0,0 +1,56 @@
+import { VMSettingsField, VMSettingsRenderableFieldResolver } from '../types';
+import { ProvisionSource } from '../../../types/vm';
+
+export const titleResolver: VMSettingsRenderableFieldResolver = {
+  [VMSettingsField.NAME]: 'Name',
+  [VMSettingsField.DESCRIPTION]: 'Description',
+  [VMSettingsField.USER_TEMPLATE]: 'Template',
+  [VMSettingsField.PROVISION_SOURCE_TYPE]: 'Source',
+  [VMSettingsField.PROVIDER]: 'Provider',
+  [VMSettingsField.CONTAINER_IMAGE]: 'Container Image',
+  [VMSettingsField.IMAGE_URL]: 'URL',
+  [VMSettingsField.OPERATING_SYSTEM]: 'Operating System',
+  [VMSettingsField.FLAVOR]: 'Flavor',
+  [VMSettingsField.MEMORY]: 'Memory (GB)',
+  [VMSettingsField.CPU]: 'CPUs',
+  [VMSettingsField.WORKLOAD_PROFILE]: 'Workload Profile',
+  [VMSettingsField.START_VM]: 'Start virtual machine on creation',
+  [VMSettingsField.USE_CLOUD_INIT]: 'Use cloud-init',
+  [VMSettingsField.USE_CLOUD_INIT_CUSTOM_SCRIPT]: 'Use custom script',
+  [VMSettingsField.HOST_NAME]: 'Hostname',
+  [VMSettingsField.AUTHKEYS]: 'Authenticated SSH Keys',
+  [VMSettingsField.CLOUD_INIT_CUSTOM_SCRIPT]: 'Custom Script',
+};
+
+export const placeholderResolver = {
+  [VMSettingsField.USER_TEMPLATE]: '--- Select Template ---',
+  [VMSettingsField.PROVISION_SOURCE_TYPE]: '--- Select Source ---',
+  [VMSettingsField.PROVIDER]: '--- Select Provider ---',
+  [VMSettingsField.OPERATING_SYSTEM]: '--- Select Operating System ---',
+  [VMSettingsField.FLAVOR]: '--- Select Flavor ---',
+  [VMSettingsField.WORKLOAD_PROFILE]: '--- Select Workload Profile ---',
+};
+
+const provisionSourceHelpResolver = {
+  [ProvisionSource.URL]:
+    'An external URL to the .iso, .img, .qcow2 or .raw that the virtual machine should be created from.',
+  [ProvisionSource.PXE]: 'Discover provisionable virtual machines over the network.',
+  [ProvisionSource.CONTAINER]:
+    'Ephemeral virtual machine disk image which will be pulled from container registry.',
+  [ProvisionSource.IMPORT]: 'Import a virtual machine from external service using a provider.',
+  [ProvisionSource.CLONED_DISK]: 'Select an existing PVC in Storage tab',
+};
+
+export const helpResolver = {
+  [VMSettingsField.PROVISION_SOURCE_TYPE]: (sourceType: ProvisionSource) =>
+    provisionSourceHelpResolver[sourceType],
+  [VMSettingsField.PROVIDER]: (provider) => `Not Implemented for ${provider}!!!`,
+  [VMSettingsField.FLAVOR]: () =>
+    'The combination of processing power and memory that will be provided to the virtual machine.',
+  [VMSettingsField.MEMORY]: () =>
+    'The amount of memory that will be dedicated to the virtual machine.',
+  [VMSettingsField.CPU]: () =>
+    'The number of virtual CPU cores that will be dedicated to the virtual machine.',
+  [VMSettingsField.WORKLOAD_PROFILE]: () =>
+    'The category of workload that this virtual machine will be used for.',
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/memory-cpu.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/memory-cpu.tsx
new file mode 100644
index 00000000000..666a7551834
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/memory-cpu.tsx
@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { Grid, GridItem } from '@patternfly/react-core';
+import { FormFieldMemoRow } from '../../form/form-field-row';
+import { FormField, FormFieldType } from '../../form/form-field';
+import { Integer } from '../../../form/integer/integer';
+import { VMSettingsField } from '../../types';
+import { isFieldHidden } from '../../selectors/immutable/vm-settings';
+
+import './vm-settings-tab.scss';
+
+export const MemoryCPU: React.FC<MemoryCPUProps> = React.memo(
+  ({ memoryField, cpuField, onChange }) => {
+    if (isFieldHidden(memoryField) && isFieldHidden(cpuField)) {
+      return null;
+    }
+
+    return (
+      <Grid>
+        <GridItem span={6} className="kubevirt-create-vm-modal__memory-row">
+          <FormFieldMemoRow field={memoryField} fieldType={FormFieldType.TEXT}>
+            <FormField>
+              <Integer
+                className="kubevirt-create-vm-modal__memory-input"
+                isPositive
+                onChange={(value) => onChange(VMSettingsField.MEMORY, value)}
+              />
+            </FormField>
+          </FormFieldMemoRow>
+        </GridItem>
+        <GridItem span={6}>
+          <FormFieldMemoRow field={cpuField} fieldType={FormFieldType.TEXT}>
+            <FormField>
+              <Integer
+                className="kubevirt-create-vm-modal__cpu-input"
+                isPositive
+                onChange={(value) => onChange(VMSettingsField.CPU, value)}
+              />
+            </FormField>
+          </FormFieldMemoRow>
+        </GridItem>
+      </Grid>
+    );
+  },
+);
+
+type MemoryCPUProps = {
+  memoryField: any;
+  cpuField: any;
+  onChange: (key: string, value: string) => void;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/os-flavor.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/os-flavor.tsx
new file mode 100644
index 00000000000..aed1aa69e92
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/os-flavor.tsx
@@ -0,0 +1,105 @@
+import * as React from 'react';
+import { FormSelect, FormSelectOption } from '@patternfly/react-core';
+import {
+  concatImmutableLists,
+  iGetLoadedData,
+  immutableListToShallowJS,
+} from '../../../../utils/immutable';
+import { FormFieldRow } from '../../form/form-field-row';
+import { FormField, FormFieldType } from '../../form/form-field';
+import { FormSelectPlaceholderOption } from '../../../form/form-select-placeholder-option';
+import {
+  getFlavors,
+  getOperatingSystems,
+} from '../../../../selectors/vm-template/combined-dependent';
+import { flavorSort, ignoreCaseSort } from '../../../../utils/sort';
+import { VMSettingsField } from '../../types';
+import { iGetFieldValue } from '../../selectors/immutable/vm-settings';
+import { getPlaceholder } from '../../utils/vm-settings-tab-utils';
+import { nullOnEmptyChange } from '../../utils/utils';
+
+export const OSFlavor: React.FC<OSFlavorProps> = React.memo(
+  ({
+    userTemplates,
+    commonTemplates,
+    userTemplate,
+    operatinSystemField,
+    flavorField,
+    workloadProfile,
+    onChange,
+  }) => {
+    const flavor = iGetFieldValue(flavorField);
+    const os = iGetFieldValue(operatinSystemField);
+    const params = {
+      userTemplate,
+      flavor,
+      workload: workloadProfile,
+      os,
+    };
+
+    const vanillaTemplates = immutableListToShallowJS(
+      concatImmutableLists(iGetLoadedData(commonTemplates), iGetLoadedData(userTemplates)),
+    );
+
+    const operatingSystems = ignoreCaseSort(getOperatingSystems(vanillaTemplates, params), [
+      'name',
+    ]);
+
+    const flavors = flavorSort(getFlavors(vanillaTemplates, params));
+
+    return (
+      <>
+        <FormFieldRow
+          field={operatinSystemField}
+          fieldType={FormFieldType.SELECT}
+          loadingResources={{
+            userTemplates,
+            commonTemplates,
+          }}
+        >
+          <FormField>
+            <FormSelect onChange={nullOnEmptyChange(onChange, VMSettingsField.OPERATING_SYSTEM)}>
+              <FormSelectPlaceholderOption
+                placeholder={getPlaceholder(VMSettingsField.OPERATING_SYSTEM)}
+                isDisabled={!!os}
+              />
+              {operatingSystems.map(({ id, name }) => {
+                return <FormSelectOption key={id} value={id} label={name} />;
+              })}
+            </FormSelect>
+          </FormField>
+        </FormFieldRow>
+        <FormFieldRow
+          field={flavorField}
+          fieldType={FormFieldType.SELECT}
+          loadingResources={{
+            userTemplates,
+            commonTemplates,
+          }}
+        >
+          <FormField isDisabled={flavor && flavors.length === 1}>
+            <FormSelect onChange={nullOnEmptyChange(onChange, VMSettingsField.FLAVOR)}>
+              <FormSelectPlaceholderOption
+                placeholder={getPlaceholder(VMSettingsField.FLAVOR)}
+                isDisabled={!!flavor}
+              />
+              {flavors.map((f) => {
+                return <FormSelectOption key={f} value={f} label={f} />;
+              })}
+            </FormSelect>
+          </FormField>
+        </FormFieldRow>
+      </>
+    );
+  },
+);
+
+type OSFlavorProps = {
+  userTemplates: any;
+  commonTemplates: any;
+  flavorField: any;
+  operatinSystemField: any;
+  userTemplate: string;
+  workloadProfile: string;
+  onChange: (key: string, value: string) => void;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/user-templates.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/user-templates.tsx
new file mode 100644
index 00000000000..88ad474aeeb
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/user-templates.tsx
@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { FormSelect, FormSelectOption } from '@patternfly/react-core';
+import { iGetIsLoaded, iGetLoadedData } from '../../../../utils/immutable';
+import { FormFieldRow } from '../../form/form-field-row';
+import { FormField, FormFieldType } from '../../form/form-field';
+import { FormSelectPlaceholderOption } from '../../../form/form-select-placeholder-option';
+import { ignoreCaseSort } from '../../../../utils/sort';
+import { VMSettingsField } from '../../types';
+import { NO_TEMPLATE, NO_TEMPLATE_AVAILABLE } from '../../strings/strings';
+import { nullOnEmptyChange } from '../../utils/utils';
+import { iGetName } from '../../selectors/immutable/selectors';
+
+export const UserTemplates: React.FC<UserTemplatesProps> = React.memo(
+  ({ userTemplateField, userTemplates, commonTemplates, dataVolumes, onChange }) => {
+    const data = iGetLoadedData(userTemplates);
+    const names =
+      data &&
+      data
+        .toIndexedSeq()
+        .toArray()
+        .map(iGetName);
+    const sortedNames = ignoreCaseSort(names);
+    const hasUserTemplates = sortedNames.length > 0;
+
+    return (
+      <FormFieldRow
+        field={userTemplateField}
+        fieldType={FormFieldType.SELECT}
+        loadingResources={{
+          userTemplates,
+          commonTemplates,
+          dataVolumes,
+        }}
+      >
+        <FormField isDisabled={!hasUserTemplates}>
+          <FormSelect onChange={nullOnEmptyChange(onChange, VMSettingsField.USER_TEMPLATE)}>
+            <FormSelectPlaceholderOption
+              placeholder={hasUserTemplates ? NO_TEMPLATE : NO_TEMPLATE_AVAILABLE}
+            />
+            {sortedNames.map((name) => {
+              return <FormSelectOption key={name} value={name} label={name} />;
+            })}
+          </FormSelect>
+        </FormField>
+      </FormFieldRow>
+    );
+  },
+  (prevProps, nextProps) =>
+    iGetIsLoaded(prevProps.dataVolumes) === iGetIsLoaded(nextProps.dataVolumes) && // wait for dataVolumes; required when pre-filling template
+    iGetIsLoaded(prevProps.commonTemplates) === iGetIsLoaded(nextProps.commonTemplates) && // wait -||-
+    prevProps.userTemplateField === nextProps.userTemplateField &&
+    prevProps.userTemplates === nextProps.userTemplates,
+);
+
+type UserTemplatesProps = {
+  userTemplateField: any;
+  userTemplates: any;
+  commonTemplates: any;
+  dataVolumes: any;
+  onChange: (key: string, value: string) => void;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.scss b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.scss
new file mode 100644
index 00000000000..8eca4d0bc45
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.scss
@@ -0,0 +1,20 @@
+.kubevirt-create-vm-modal__description {
+  min-height: 3em;
+  resize: vertical;
+}
+
+.kubevirt-create-vm-modal__memory-row {
+  margin-right: 0.5em;
+}
+
+.kubevirt-create-vm-modal__memory-input {
+  max-width:  100% !important;
+}
+
+.kubevirt-create-vm-modal__cpu-input {
+  max-width:  100% !important;
+}
+
+.kubevirt-create-vm-modal__start_vm_checkbox > input[type="checkbox"] {
+  margin: -0.25em 0 0 !important;
+}
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.tsx
new file mode 100644
index 00000000000..d2380ae8ec4
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/vm-settings-tab.tsx
@@ -0,0 +1,165 @@
+import * as React from 'react';
+import {
+  Form,
+  FormSelect,
+  FormSelectOption,
+  TextArea,
+  TextInput,
+  Checkbox,
+} from '@patternfly/react-core';
+import { connect } from 'react-redux';
+import { iGet, iGetIn } from '../../../../utils/immutable';
+import { FormFieldMemoRow } from '../../form/form-field-row';
+import { FormField, FormFieldType } from '../../form/form-field';
+import { FormSelectPlaceholderOption } from '../../../form/form-select-placeholder-option';
+import { vmWizardActions } from '../../redux/actions';
+import { VMSettingsField, VMSettingsRenderableField, VMWizardProps } from '../../types';
+import { iGetVmSettings } from '../../selectors/immutable/vm-settings';
+import { ActionType } from '../../redux/types';
+import { getFieldId, getPlaceholder } from '../../utils/vm-settings-tab-utils';
+import { iGetCommonData } from '../../selectors/immutable/selectors';
+import { WorkloadProfile } from './workload-profile';
+import { OSFlavor } from './os-flavor';
+import { UserTemplates } from './user-templates';
+import { MemoryCPU } from './memory-cpu';
+
+import './vm-settings-tab.scss';
+
+export class VMSettingsTabComponent extends React.Component<VMSettingsTabComponentProps> {
+  getField = (key) => iGet(this.props.vmSettings, key);
+
+  getFieldAttribute = (key, attribute) => iGetIn(this.props.vmSettings, [key, attribute]);
+
+  getFieldValue = (key) => iGetIn(this.props.vmSettings, [key, 'value']);
+
+  onChange = (key) => (value) => this.props.onFieldChange(key, value);
+
+  render() {
+    const { userTemplates, commonTemplates, dataVolumes } = this.props;
+
+    return (
+      <Form>
+        <UserTemplates
+          userTemplateField={this.getField(VMSettingsField.USER_TEMPLATE)}
+          userTemplates={userTemplates}
+          commonTemplates={commonTemplates}
+          dataVolumes={dataVolumes}
+          onChange={this.props.onFieldChange}
+        />
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.PROVISION_SOURCE_TYPE)}
+          fieldType={FormFieldType.SELECT}
+        >
+          <FormField>
+            <FormSelect onChange={this.onChange(VMSettingsField.PROVISION_SOURCE_TYPE)}>
+              <FormSelectPlaceholderOption
+                placeholder={getPlaceholder(VMSettingsField.PROVISION_SOURCE_TYPE)}
+                isDisabled={!!this.getFieldValue(VMSettingsField.PROVISION_SOURCE_TYPE)}
+              />
+              {(this.getFieldAttribute(VMSettingsField.PROVISION_SOURCE_TYPE, 'sources') || []).map(
+                (source) => {
+                  return <FormSelectOption key={source} value={source} label={source} />;
+                },
+              )}
+            </FormSelect>
+          </FormField>
+        </FormFieldMemoRow>
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.CONTAINER_IMAGE)}
+          fieldType={FormFieldType.TEXT}
+        >
+          <FormField>
+            <TextInput onChange={this.onChange(VMSettingsField.CONTAINER_IMAGE)} />
+          </FormField>
+        </FormFieldMemoRow>
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.IMAGE_URL)}
+          fieldType={FormFieldType.TEXT}
+        >
+          <FormField>
+            <TextInput onChange={this.onChange(VMSettingsField.IMAGE_URL)} />
+          </FormField>
+        </FormFieldMemoRow>
+        <OSFlavor
+          userTemplates={userTemplates}
+          commonTemplates={commonTemplates}
+          operatinSystemField={this.getField(VMSettingsField.OPERATING_SYSTEM)}
+          flavorField={this.getField(VMSettingsField.FLAVOR)}
+          userTemplate={this.getFieldValue(VMSettingsField.USER_TEMPLATE)}
+          workloadProfile={this.getFieldValue(VMSettingsField.WORKLOAD_PROFILE)}
+          onChange={this.props.onFieldChange}
+        />
+        <MemoryCPU
+          memoryField={this.getField(VMSettingsField.MEMORY)}
+          cpuField={this.getField(VMSettingsField.CPU)}
+          onChange={this.props.onFieldChange}
+        />
+        <WorkloadProfile
+          userTemplates={userTemplates}
+          commonTemplates={commonTemplates}
+          workloadProfileField={this.getField(VMSettingsField.WORKLOAD_PROFILE)}
+          userTemplate={this.getFieldValue(VMSettingsField.USER_TEMPLATE)}
+          operatingSystem={this.getFieldValue(VMSettingsField.OPERATING_SYSTEM)}
+          flavor={this.getFieldValue(VMSettingsField.FLAVOR)}
+          onChange={this.props.onFieldChange}
+        />
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.NAME)}
+          fieldType={FormFieldType.TEXT}
+        >
+          <FormField>
+            <TextInput onChange={this.onChange(VMSettingsField.NAME)} />
+          </FormField>
+        </FormFieldMemoRow>
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.DESCRIPTION)}
+          fieldType={FormFieldType.TEXT_AREA}
+        >
+          <FormField>
+            <TextArea
+              onChange={this.onChange(VMSettingsField.DESCRIPTION)}
+              className="kubevirt-create-vm-modal__description"
+            />
+          </FormField>
+        </FormFieldMemoRow>
+        <FormFieldMemoRow
+          field={this.getField(VMSettingsField.START_VM)}
+          fieldType={FormFieldType.INLINE_CHECKBOX}
+        >
+          <FormField>
+            <Checkbox
+              className="kubevirt-create-vm-modal__start_vm_checkbox"
+              id={getFieldId(VMSettingsField.START_VM)}
+              onChange={this.onChange(VMSettingsField.START_VM)}
+            />
+          </FormField>
+        </FormFieldMemoRow>
+      </Form>
+    );
+  }
+}
+
+const stateToProps = (state, { wizardReduxID }) => ({
+  vmSettings: iGetVmSettings(state, wizardReduxID),
+  commonTemplates: iGetCommonData(state, wizardReduxID, VMWizardProps.commonTemplates),
+  userTemplates: iGetCommonData(state, wizardReduxID, VMWizardProps.userTemplates),
+  dataVolumes: iGetCommonData(state, wizardReduxID, VMWizardProps.dataVolumes),
+});
+
+type VMSettingsTabComponentProps = {
+  onFieldChange: (key: VMSettingsRenderableField, value: string) => void;
+  vmSettings: any;
+  commonTemplates: any;
+  userTemplates: any;
+  dataVolumes: any;
+};
+
+const dispatchToProps = (dispatch, props) => ({
+  onFieldChange: (key, value) =>
+    dispatch(vmWizardActions[ActionType.SetVmSettingsFieldValue](props.wizardReduxID, key, value)),
+});
+
+export const VMSettingsTab = connect(
+  stateToProps,
+  dispatchToProps,
+)(VMSettingsTabComponent);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/workload-profile.tsx b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/workload-profile.tsx
new file mode 100644
index 00000000000..6be96476744
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/tabs/vm-settings-tab/workload-profile.tsx
@@ -0,0 +1,80 @@
+import * as React from 'react';
+import { FormSelect, FormSelectOption } from '@patternfly/react-core';
+import {
+  concatImmutableLists,
+  iGetLoadedData,
+  immutableListToShallowJS,
+} from '../../../../utils/immutable';
+import { FormFieldRow } from '../../form/form-field-row';
+import { FormField, FormFieldType } from '../../form/form-field';
+import { FormSelectPlaceholderOption } from '../../../form/form-select-placeholder-option';
+import { getWorkloadProfiles } from '../../../../selectors/vm-template/combined-dependent';
+import { ignoreCaseSort } from '../../../../utils/sort';
+import { VMSettingsField } from '../../types';
+import { getPlaceholder } from '../../utils/vm-settings-tab-utils';
+import { nullOnEmptyChange } from '../../utils/utils';
+import { iGetFieldValue } from '../../selectors/immutable/vm-settings';
+
+export const WorkloadProfile: React.FC<WorkloadProps> = React.memo(
+  ({
+    userTemplates,
+    commonTemplates,
+    workloadProfileField,
+    userTemplate,
+    operatingSystem,
+    flavor,
+    onChange,
+  }) => {
+    const vanillaTemplates = immutableListToShallowJS(
+      concatImmutableLists(iGetLoadedData(commonTemplates), iGetLoadedData(userTemplates)),
+    );
+    const workloadProfiles = ignoreCaseSort(
+      getWorkloadProfiles(vanillaTemplates, {
+        userTemplate,
+        flavor,
+        os: operatingSystem,
+      }),
+    );
+
+    return (
+      <>
+        <FormFieldRow
+          field={workloadProfileField}
+          fieldType={FormFieldType.SELECT}
+          loadingResources={{
+            userTemplates,
+            commonTemplates,
+          }}
+        >
+          <FormField>
+            <FormSelect onChange={nullOnEmptyChange(onChange, VMSettingsField.WORKLOAD_PROFILE)}>
+              <FormSelectPlaceholderOption
+                placeholder={getPlaceholder(VMSettingsField.WORKLOAD_PROFILE)}
+                isDisabled={!!iGetFieldValue(workloadProfileField)}
+              />
+              {workloadProfiles.map((workloadProfile) => {
+                return (
+                  <FormSelectOption
+                    key={workloadProfile}
+                    value={workloadProfile}
+                    label={workloadProfile}
+                  />
+                );
+              })}
+            </FormSelect>
+          </FormField>
+        </FormFieldRow>
+      </>
+    );
+  },
+);
+
+type WorkloadProps = {
+  userTemplates: any;
+  commonTemplates: any;
+  workloadProfileField: any;
+  userTemplate: string;
+  flavor: string;
+  operatingSystem: string;
+  onChange: (key: string, value: string) => void;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/types.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/types.ts
new file mode 100644
index 00000000000..9cc3830c026
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/types.ts
@@ -0,0 +1,107 @@
+import { FirehoseResult } from '@console/internal/components/utils';
+import { TemplateKind } from '@console/internal/module/k8s';
+import { getStringEnumValues } from '../../utils/types';
+import { VMKind } from '../../types/vm';
+
+export enum VMWizardTab { // order important
+  VM_SETTINGS = 'VM_SETTINGS',
+  NETWORKS = 'NETWORKS',
+  STORAGE = 'STORAGE',
+  REVIEW = 'REVIEW',
+  RESULT = 'RESULT',
+}
+
+export enum VMWizardProps {
+  isCreateTemplate = 'isCreateTemplate',
+  activeNamespace = 'activeNamespace',
+  reduxID = 'reduxID',
+  virtualMachines = 'virtualMachines',
+  userTemplates = 'userTemplates',
+  commonTemplates = 'commonTemplates',
+  networkConfigs = 'networkConfigs',
+  storageClasses = 'storageClasses',
+  persistentVolumeClaims = 'persistentVolumeClaims',
+  dataVolumes = 'dataVolumes',
+}
+
+export const ALL_VM_WIZARD_TABS = getStringEnumValues<VMWizardTab>(VMWizardTab);
+
+export enum VMSettingsField { // TODO refactor to NAME = 'NAME' format for easier debugging once kubevirt-web-ui-components is deprecated
+  NAME = 'name',
+  DESCRIPTION = 'description',
+  PROVISION_SOURCE_TYPE = 'provisionSourceType',
+  CONTAINER_IMAGE = 'containerImage',
+  IMAGE_URL = 'imageURL',
+  PROVIDER = 'provider',
+  PROVIDERS_DATA = 'providersData',
+  USER_TEMPLATE = 'userTemplate',
+  OPERATING_SYSTEM = 'operatingSystem',
+  FLAVOR = 'flavor',
+  MEMORY = 'memory',
+  CPU = 'cpu',
+  WORKLOAD_PROFILE = 'workloadProfile',
+  START_VM = 'startVM',
+  USE_CLOUD_INIT = 'cloudInit',
+  USE_CLOUD_INIT_CUSTOM_SCRIPT = 'useCloudInitCustomScript',
+  HOST_NAME = 'hostname',
+  AUTHKEYS = 'authKeys',
+  CLOUD_INIT_CUSTOM_SCRIPT = 'cloudInitCustomScript',
+}
+
+export type VMSettingsRenderableField = Exclude<VMSettingsField, VMSettingsField.PROVIDERS_DATA>;
+export type VMSettingsRenderableFieldResolver = { [key in VMSettingsRenderableField]: string };
+
+export type VMSettingsFieldType = {
+  value: any;
+  key: VMSettingsField;
+  isRequired?: boolean;
+  isHidden?: boolean;
+  isDisabled?: boolean;
+  [k: string]: any;
+};
+
+export type ChangedCommonDataProp =
+  | VMWizardProps.activeNamespace
+  | VMWizardProps.virtualMachines
+  | VMWizardProps.dataVolumes
+  | VMWizardProps.userTemplates
+  | VMWizardProps.persistentVolumeClaims
+  | VMWizardProps.commonTemplates
+  | VMWizardProps.networkConfigs
+  | VMWizardProps.storageClasses;
+
+export type CommonDataProp = VMWizardProps.isCreateTemplate | ChangedCommonDataProp;
+
+export type ChangedCommonData = Set<ChangedCommonDataProp>;
+
+export const DetectCommonDataChanges = new Set<ChangedCommonDataProp>([
+  VMWizardProps.activeNamespace,
+  VMWizardProps.virtualMachines,
+  VMWizardProps.dataVolumes,
+  VMWizardProps.userTemplates,
+  VMWizardProps.commonTemplates,
+  VMWizardProps.persistentVolumeClaims,
+  VMWizardProps.networkConfigs,
+]);
+
+export type CommonData = {
+  data?: {
+    isCreateTemplate?: boolean;
+  };
+  dataIDReferences?: { [k in ChangedCommonDataProp]: string[] };
+};
+
+export type CreateVMWizardComponentProps = {
+  isCreateTemplate: boolean;
+  dataIDReferences: { [k in ChangedCommonDataProp]: string[] };
+  activeNamespace: string;
+  reduxID: string;
+  stepData: any;
+  userTemplates: FirehoseResult<TemplateKind[]>;
+  commonTemplates: FirehoseResult<TemplateKind[]>;
+  virtualMachines: FirehoseResult<VMKind[]>;
+  onInitialize: () => void;
+  onClose: () => void;
+  onCommonDataChanged: (commonData: CommonData, commonDataChanged: ChangedCommonData) => void;
+  onResultsChanged: (results, valid) => void;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/utils.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/utils.ts
new file mode 100644
index 00000000000..8d132bbc698
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/utils.ts
@@ -0,0 +1,17 @@
+import { VMSettingsField } from '../types';
+
+export const VM_SETTINGS_METADATA_ID = 'VM_SETTINGS_METADATA_ID';
+export const VMWARE_PROVIDER_METADATA_ID = 'VMWARE_PROVIDER_METADATA_ID';
+
+export const asRequired = (value: any, key: string = VM_SETTINGS_METADATA_ID) => ({
+  [key]: !!value,
+});
+export const asHidden = (value: any, key: string = VM_SETTINGS_METADATA_ID) => ({ [key]: !!value });
+export const asDisabled = (value: any, key: string = VM_SETTINGS_METADATA_ID) => ({
+  [key]: !!value,
+});
+
+export const nullOnEmptyChange = (
+  onChange: (k: VMSettingsField, v: string) => void,
+  fieldKey: VMSettingsField,
+) => (v) => onChange(fieldKey, v === '' ? null : v);
diff --git a/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/vm-settings-tab-utils.ts b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/vm-settings-tab-utils.ts
new file mode 100644
index 00000000000..b15154dcb3b
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/utils/vm-settings-tab-utils.ts
@@ -0,0 +1,35 @@
+import {
+  VMSettingsField,
+  VMSettingsRenderableField,
+  VMSettingsRenderableFieldResolver,
+} from '../types';
+import { titleResolver, placeholderResolver, helpResolver } from '../strings/vm-settings';
+
+const idResolver: VMSettingsRenderableFieldResolver = {
+  [VMSettingsField.NAME]: 'vm-name',
+  [VMSettingsField.DESCRIPTION]: 'vm-description',
+  [VMSettingsField.USER_TEMPLATE]: 'template-dropdown',
+  [VMSettingsField.PROVISION_SOURCE_TYPE]: 'image-source-type-dropdown',
+  [VMSettingsField.PROVIDER]: 'provider-dropdown',
+  [VMSettingsField.CONTAINER_IMAGE]: 'provision-source-container',
+  [VMSettingsField.IMAGE_URL]: 'provision-source-url',
+  [VMSettingsField.OPERATING_SYSTEM]: 'operating-system-dropdown',
+  [VMSettingsField.FLAVOR]: 'flavor-dropdown',
+  [VMSettingsField.MEMORY]: 'resources-memory',
+  [VMSettingsField.CPU]: 'resources-cpu',
+  [VMSettingsField.WORKLOAD_PROFILE]: 'workload-profile-dropdown',
+  [VMSettingsField.START_VM]: 'start-vm',
+  [VMSettingsField.USE_CLOUD_INIT]: 'use-cloud-init',
+  [VMSettingsField.USE_CLOUD_INIT_CUSTOM_SCRIPT]: 'use-cloud-init-custom-script',
+  [VMSettingsField.HOST_NAME]: 'cloud-init-hostname',
+  [VMSettingsField.AUTHKEYS]: 'cloud-init-ssh',
+  [VMSettingsField.CLOUD_INIT_CUSTOM_SCRIPT]: 'cloud-init-custom-script',
+};
+
+export const getFieldId = (key: VMSettingsRenderableField) => idResolver[key];
+export const getFieldTitle = (key: VMSettingsRenderableField) => titleResolver[key];
+export const getPlaceholder = (key: VMSettingsRenderableField) => placeholderResolver[key];
+export const getFieldHelp = (key: VMSettingsRenderableField, value: string) => {
+  const resolveFunction = helpResolver[key];
+  return resolveFunction ? resolveFunction(value) : null;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/errors/errors.scss b/frontend/packages/kubevirt-plugin/src/components/errors/errors.scss
new file mode 100644
index 00000000000..0bf976ca985
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/errors/errors.scss
@@ -0,0 +1,7 @@
+.kubevirt-errors__error-group--item {
+  margin-bottom: 0.5em;
+}
+
+.kubevirt-errors__error-group--end {
+  margin-bottom: 1.5em;
+}
diff --git a/frontend/packages/kubevirt-plugin/src/components/errors/errors.tsx b/frontend/packages/kubevirt-plugin/src/components/errors/errors.tsx
new file mode 100644
index 00000000000..6afbf9cf3b8
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/errors/errors.tsx
@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { Alert, AlertVariant } from '@patternfly/react-core';
+import * as classNames from 'classnames';
+
+import './errors.scss';
+
+export type Error = {
+  message: string;
+  variant?: AlertVariant;
+  title: string;
+  key: string;
+};
+
+type ErrorsProps = {
+  errors: Error[];
+};
+
+export const Errors: React.FC<ErrorsProps> = ({ errors }) => {
+  return (
+    <>
+      {errors &&
+        errors
+          .filter((e) => e && e.message)
+          .map(({ message, key, title, variant }, idx, arr) => (
+            <Alert
+              isInline
+              key={key}
+              variant={variant || AlertVariant.danger}
+              title={title}
+              className={classNames({
+                'kubevirt-errors__error-group--item': idx !== arr.length - 1,
+                'kubevirt-errors__error-group--end ': idx === arr.length - 1,
+              })}
+            >
+              {message}
+            </Alert>
+          ))}
+    </>
+  );
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/form/form-row.scss b/frontend/packages/kubevirt-plugin/src/components/form/form-row.scss
new file mode 100644
index 00000000000..f974d8be846
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/form/form-row.scss
@@ -0,0 +1,11 @@
+.kubevirt-form-row__loading-container {
+  margin-left: 0.5em;
+}
+
+.kubevirt-form-row__icon-status-container {
+  margin-left: 0.5em;
+}
+
+.kubevirt-form-row__help-icon--hidden {
+  color: #72767B;
+}
diff --git a/frontend/packages/kubevirt-plugin/src/components/form/form-row.tsx b/frontend/packages/kubevirt-plugin/src/components/form/form-row.tsx
new file mode 100644
index 00000000000..7ff3f7f5622
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/form/form-row.tsx
@@ -0,0 +1,67 @@
+import * as React from 'react';
+import { FormGroup } from '@patternfly/react-core';
+import { LoadingInline } from '@console/internal/components/utils';
+import PopoverStatus from '@console/shared/src/components/status/PopoverStatus';
+import { HelpIcon } from '@patternfly/react-icons';
+import { ValidationErrorType } from '../../utils/validations/types';
+
+import './form-row.scss';
+
+export const FormRow: React.FC<FormRowProps> = ({
+  fieldId,
+  title,
+  help,
+  isHidden,
+  isRequired,
+  isLoading,
+  validationMessage,
+  validationType,
+  children,
+}) => {
+  if (isHidden) {
+    return null;
+  }
+
+  return (
+    <FormGroup
+      label={title}
+      isRequired={isRequired}
+      fieldId={fieldId}
+      isValid={validationType !== ValidationErrorType.Error}
+      helperTextInvalid={validationMessage}
+    >
+      {help && (
+        <span className="kubevirt-form-row__icon-status-container">
+          <PopoverStatus
+            icon={<HelpIcon className="kubevirt-form-row__help-icon--hidden" />}
+            activeIcon={<HelpIcon />}
+            title={`${fieldId} help`}
+            iconOnly
+            hideHeader
+          >
+            {help}
+          </PopoverStatus>
+        </span>
+      )}
+      {isLoading && (
+        <span className="kubevirt-form-row__loading-container">
+          <LoadingInline />
+        </span>
+      )}
+      {children}
+    </FormGroup>
+  );
+};
+
+type FormRowProps = {
+  fieldId: string;
+  title: string;
+  help?: string;
+  helpTitle?: string;
+  isHidden?: boolean;
+  isRequired?: boolean;
+  isLoading?: boolean;
+  validationMessage?: string;
+  validationType?: ValidationErrorType;
+  children?: React.ReactNode;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/form/form-select-placeholder-option.tsx b/frontend/packages/kubevirt-plugin/src/components/form/form-select-placeholder-option.tsx
new file mode 100644
index 00000000000..006c920d70d
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/form/form-select-placeholder-option.tsx
@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { FormSelectOption } from '@patternfly/react-core';
+
+// renders only when props change (shallow compare)
+export const FormSelectPlaceholderOption: React.FC<FormSelectPlaceholderOptionProps> = ({
+  placeholder,
+  isDisabled,
+}) => {
+  return (
+    placeholder && (
+      <FormSelectOption isDisabled={isDisabled} key="defaultValue" value="" label={placeholder} />
+    )
+  );
+};
+
+type FormSelectPlaceholderOptionProps = {
+  placeholder?: string;
+  isDisabled?: boolean;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/form/integer/integer.tsx b/frontend/packages/kubevirt-plugin/src/components/form/integer/integer.tsx
new file mode 100644
index 00000000000..20873a0e778
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/components/form/integer/integer.tsx
@@ -0,0 +1,149 @@
+import * as React from 'react';
+import { TextInput } from '@patternfly/react-core';
+import { getSequence, setNativeValue } from '../../../utils/utils';
+import { isMinus, KEY_CODES, INPUT_NAVIGATION_KEYS } from '../../../constants/keys';
+
+const NON_NEGATIVE_INTEGER_KEYS = [
+  ...INPUT_NAVIGATION_KEYS,
+  ...getSequence(KEY_CODES[0], KEY_CODES[9]),
+  ...getSequence(KEY_CODES.NUMPAD[0], KEY_CODES.NUMPAD[9]),
+];
+
+const INTEGER_KEYS = [
+  ...NON_NEGATIVE_INTEGER_KEYS,
+  KEY_CODES.MINUS,
+  KEY_CODES.HYPHEN_MINUS,
+  KEY_CODES.NUMPAD.SUBTRACT,
+];
+
+const POSITIVE_INT_REGEX = /^[1-9]\d*$/;
+const NON_NEGATIVE_INT_REGEX = /^(0|[1-9]\d*)$/;
+const INT_REGEX = /^(-?0|-?[1-9]\d*)$/;
+
+const PRECEEDING_ZEROS_POSITIVE_INT_REGEX = /^0*([1-9]\d*)$/;
+const PRECEEDING_ZEROS_INT_REGEX = /^(-?)0*([1-9]\d*)$/;
+
+const fixPrecedingZerosPositiveInt = (value) => {
+  const match = PRECEEDING_ZEROS_POSITIVE_INT_REGEX.exec(value);
+  return match && match.length === 2 ? match[1] : '';
+};
+
+const fixPrecedingZerosNonNegativeInt = (value) => {
+  const match = PRECEEDING_ZEROS_POSITIVE_INT_REGEX.exec(value);
+  return match && match.length === 2 ? match[1] : '0';
+};
+
+const fixInt = (value, oldValue, keyCode) => {
+  if (value.length === 0 && isMinus(keyCode)) {
+    if (oldValue) {
+      return oldValue < 0 || oldValue === '-0' ? oldValue : `-${oldValue}`;
+    }
+    return '-0';
+  }
+
+  const match = PRECEEDING_ZEROS_INT_REGEX.exec(value);
+  if (match && match.length === 3) {
+    if (match[1]) {
+      return `${match[1]}${match[2]}`;
+    }
+    return match[2];
+  }
+  return '0';
+};
+
+const isInputValid = (allowedKeys, keyCode, targetValue, additionalValidation) => {
+  if (allowedKeys.includes(keyCode)) {
+    return additionalValidation ? additionalValidation(keyCode, targetValue) : true;
+  }
+  return false;
+};
+
+export const Integer: React.FC<IntegerProps> = ({
+  id,
+  value,
+  isDisabled,
+  defaultValue,
+  onChange,
+  onBlur,
+  isPositive,
+  isNonNegative,
+  className,
+}) => {
+  let allowedKeys;
+  let validRegex;
+  let fixAfterValue;
+  let min;
+  let additionalValidation;
+
+  if (isPositive) {
+    allowedKeys = NON_NEGATIVE_INTEGER_KEYS;
+    validRegex = POSITIVE_INT_REGEX;
+    fixAfterValue = fixPrecedingZerosPositiveInt;
+    min = 1;
+    additionalValidation = (keyCode, targetValue) =>
+      !(targetValue === '' && (keyCode === KEY_CODES[0] || keyCode === KEY_CODES.NUMPAD[0]));
+  } else if (isNonNegative) {
+    allowedKeys = NON_NEGATIVE_INTEGER_KEYS;
+    validRegex = NON_NEGATIVE_INT_REGEX;
+    fixAfterValue = fixPrecedingZerosNonNegativeInt;
+    min = 0;
+  } else {
+    allowedKeys = INTEGER_KEYS;
+    validRegex = INT_REGEX;
+    fixAfterValue = fixInt;
+  }
+
+  const onKeydown = (e) => {
+    const { keyCode, target } = e;
+
+    if (!isInputValid(allowedKeys, keyCode, target.value, additionalValidation)) {
+      e.preventDefault();
+      return false;
+    }
+
+    const oldValue = target.value;
+
+    window.setTimeout(() => {
+      if (!validRegex.test(target.value)) {
+        const v = fixAfterValue(target.value, oldValue, keyCode);
+        setNativeValue(target, v);
+        target.dispatchEvent(
+          new Event('input', {
+            bubbles: true,
+            cancelable: true,
+          }),
+        );
+      }
+    }, 0);
+    return true;
+  };
+
+  return (
+    <TextInput
+      id={id}
+      type="number"
+      onKeyDown={onKeydown}
+      min={min}
+      value={value}
+      defaultValue={defaultValue}
+      onBlur={
+        typeof onBlur === 'function' ? (event) => onBlur(event.target.value || '', event) : null
+      }
+      onChange={onChange}
+      className={className}
+      isDisabled={isDisabled}
+    />
+  );
+};
+
+type IntegerProps = {
+  id?: string;
+  className?: string;
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string, event: React.FormEvent<HTMLInputElement>) => void;
+  onBlur?: (value: string, event: React.FormEvent<HTMLInputElement>) => void;
+  isPositive?: boolean;
+  isNonNegative?: boolean; // is ignored when positive == true
+  isDisabled?: boolean;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/_clone-vm-modal.scss b/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/_clone-vm-modal.scss
index c7f7e267fd6..b57c5bab2df 100644
--- a/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/_clone-vm-modal.scss
+++ b/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/_clone-vm-modal.scss
@@ -17,11 +17,3 @@
   min-height: 3em;
   resize: vertical;
 }
-
-.kubevirt-clone-vm-modal__error-group--item {
-  margin-bottom: 0.5em;
-}
-
-.kubevirt-clone-vm-modal__error-group--end {
-  margin-bottom: 1.5em;
-}
diff --git a/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/clone-vm-modal.tsx b/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/clone-vm-modal.tsx
index b7ed7d58f9e..0efe652832b 100644
--- a/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/clone-vm-modal.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/modals/clone-vm-modal/clone-vm-modal.tsx
@@ -1,6 +1,4 @@
 import * as React from 'react';
-import * as classNames from 'classnames';
-import { getResource } from 'kubevirt-web-ui-components';
 import { connect } from 'react-redux';
 import {
   Form,
@@ -30,17 +28,20 @@ import { NamespaceModel, PersistentVolumeClaimModel, ProjectModel } from '@conso
 import { getName, getNamespace } from '@console/shared';
 import { VMKind } from '../../../types';
 import { getDescription } from '../../../selectors/selectors';
-import { getLoadedData, getLoadError, prefixedID } from '../../../utils';
+import { getLoadedData, getLoadError, getResource, prefixedID } from '../../../utils';
 import { DataVolumeModel, VirtualMachineModel } from '../../../models';
 import { cloneVM } from '../../../k8s/requests/vm/clone';
-import { validateVmName } from '../../../utils/validations/vm';
+import { validateVmLikeEntityName } from '../../../utils/validations/vm';
 import {
   getVolumeDataVolumeName,
   getVolumePersistentVolumeClaimName,
   getVolumes,
   isVMRunning,
 } from '../../../selectors/vm';
-import { ValidationErrorType } from '../../../utils/validations/common';
+import { ValidationErrorType } from '../../../utils/validations/types';
+import { VIRTUAL_MACHINE_EXISTS } from '../../../utils/validations/strings';
+import { Errors } from '../../errors/errors';
+import { COULD_NOT_LOAD_DATA } from '../../../utils/strings';
 import { ConfigurationSummary } from './configuration-summary';
 
 import './_clone-vm-modal.scss';
@@ -77,7 +78,10 @@ export const CloneVMModal = withHandlePromise((props: CloneVMModalProps) => {
   const persistentVolumeClaimsData = getLoadedData(persistentVolumeClaims, []);
   const dataVolumesData = getLoadedData(dataVolumes, []);
 
-  const nameError = validateVmName(name, namespace, getLoadedData(virtualMachines, []));
+  const nameError = validateVmLikeEntityName(name, namespace, getLoadedData(virtualMachines, []), {
+    existsErrorMessage: VIRTUAL_MACHINE_EXISTS,
+    subject: 'Name',
+  });
 
   const dataVolumesValid = !(dataVolumesError || (requestsDataVolumes && !dataVolumes.loaded));
   const pvcsValid = !(pvcsError || (requestsPVCs && !persistentVolumeClaims.loaded));
@@ -108,25 +112,25 @@ export const CloneVMModal = withHandlePromise((props: CloneVMModalProps) => {
     <div className="modal-content">
       <ModalTitle>Clone Virtual Machine</ModalTitle>
       <ModalBody>
-        {[
-          { error: namespacesError, key: 'namespacesError' },
-          { error: pvcsError, key: 'pvcsError' },
-          { error: dataVolumesError, key: 'dataVolumesError' },
-        ]
-          .filter((e) => e.error)
-          .map(({ error, key }, idx, arr) => (
-            <Alert
-              key={key}
-              variant="danger"
-              title="Could not load data"
-              className={classNames({
-                'kubevirt-clone-vm-modal__error-group--item': idx !== arr.length - 1,
-                'kubevirt-clone-vm-modal__error-group--end ': idx === arr.length - 1,
-              })}
-            >
-              {error}
-            </Alert>
-          ))}
+        <Errors
+          errors={[
+            {
+              key: 'namespacesError',
+              message: namespacesError,
+              title: COULD_NOT_LOAD_DATA,
+            },
+            {
+              key: 'pvcsError',
+              message: pvcsError,
+              title: COULD_NOT_LOAD_DATA,
+            },
+            {
+              key: 'dataVolumesError',
+              message: dataVolumesError,
+              title: COULD_NOT_LOAD_DATA,
+            },
+          ]}
+        />
         {isVMRunning(vm) && (
           <Alert
             variant="warning"
diff --git a/frontend/packages/kubevirt-plugin/src/components/modals/create-vm-wizard.tsx b/frontend/packages/kubevirt-plugin/src/components/modals/create-vm-wizard.tsx
index 81f5592b37d..420d16501ba 100644
--- a/frontend/packages/kubevirt-plugin/src/components/modals/create-vm-wizard.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/modals/create-vm-wizard.tsx
@@ -2,7 +2,6 @@ import * as _ from 'lodash';
 import { connect } from 'react-redux';
 import {
   CreateVmWizard,
-  getResource,
   TEMPLATE_TYPE_LABEL,
   TEMPLATE_TYPE_VM,
   TEMPLATE_TYPE_BASE,
@@ -22,6 +21,7 @@ import {
   DataVolumeModel,
   V2VVMwareModel,
 } from '../../models';
+import { getResource } from '../../utils';
 import { createModalResourceLauncher } from './modal-resource-launcher';
 
 const mapStateToProps = ({ k8s }) => {
diff --git a/frontend/packages/kubevirt-plugin/src/components/modals/vm-flavor-modal/vm-flavor-modal.tsx b/frontend/packages/kubevirt-plugin/src/components/modals/vm-flavor-modal/vm-flavor-modal.tsx
index 91853389a26..79633c23fd2 100644
--- a/frontend/packages/kubevirt-plugin/src/components/modals/vm-flavor-modal/vm-flavor-modal.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/modals/vm-flavor-modal/vm-flavor-modal.tsx
@@ -19,11 +19,17 @@ import {
 } from '@console/internal/components/factory';
 import { k8sPatch, TemplateKind } from '@console/internal/module/k8s';
 import { Form, FormGroup, TextInput } from '@patternfly/react-core';
-import { VMKind, VMLikeEntityKind } from '../../../types';
-import { getFlavor, getMemory, getCPU, isVM, vCPUCount } from '../../../selectors/vm';
-import { selectVM, getFlavors } from '../../../selectors/vm-template/selectors';
+import { VMLikeEntityKind } from '../../../types';
+import {
+  getFlavor,
+  getMemory,
+  getCPU,
+  vCPUCount,
+  asVM,
+  getVMLikeModel,
+} from '../../../selectors/vm';
+import { getFlavors } from '../../../selectors/vm-template/selectors';
 import { getUpdateFlavorPatches } from '../../../k8s/patches/vm/vm-patches';
-import { VirtualMachineModel } from '../../../models';
 import {
   CUSTOM_FLAVOR,
   NAMESPACE_OPENSHIFT,
@@ -55,19 +61,15 @@ const VMFlavorModal = withHandlePromise((props: VMFlavornModalProps) => {
     loadError,
     loaded,
   } = props;
-
+  const vm = asVM(vmLike);
   const flattenTemplates = _.get(templates, 'data', []) as TemplateKind[];
 
   const vmFlavor = getFlavor(vmLike);
   const flavors = getFlavors(vmLike, flattenTemplates);
 
-  const sourceMemory = isVM(vmLike)
-    ? getMemory(vmLike as VMKind)
-    : getMemory(selectVM(vmLike as TemplateKind));
+  const sourceMemory = getMemory(vm);
 
-  const sourceCPURaw = isVM(vmLike)
-    ? getCPU(vmLike as VMKind)
-    : getCPU(selectVM(vmLike as TemplateKind));
+  const sourceCPURaw = getCPU(vm);
   const sourceCPU = vCPUCount(sourceCPURaw);
 
   const [flavor, setFlavor] = React.useState(vmFlavor);
@@ -83,8 +85,7 @@ const VMFlavorModal = withHandlePromise((props: VMFlavornModalProps) => {
     if (patches.length === 0) {
       close();
     } else {
-      const model = isVM(vmLike) ? VirtualMachineModel : TemplateModel;
-      const promise = k8sPatch(model, vmLike, patches);
+      const promise = k8sPatch(getVMLikeModel(vmLike), vmLike, patches);
       handlePromise(promise).then(close); // eslint-disable-line promise/catch-or-return
     }
   };
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-disks/create-disk-row.tsx b/frontend/packages/kubevirt-plugin/src/components/vm-disks/create-disk-row.tsx
index 57d1d23e21f..ade044c2f92 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-disks/create-disk-row.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-disks/create-disk-row.tsx
@@ -1,11 +1,5 @@
 import * as React from 'react';
-import {
-  Text,
-  Integer,
-  Dropdown,
-  CancelAcceptButtons,
-  getResource,
-} from 'kubevirt-web-ui-components';
+import { Text, Integer, Dropdown, CancelAcceptButtons } from 'kubevirt-web-ui-components';
 import { TableData, TableRow } from '@console/internal/components/factory';
 import { Firehose, FirehoseResult, LoadingInline } from '@console/internal/components/utils';
 import { HelpBlock, FormGroup } from 'patternfly-react';
@@ -16,9 +10,10 @@ import { k8sPatch, K8sResourceKind } from '@console/internal/module/k8s';
 import { getVmPreferableDiskBus, getVMLikeModel } from '../../selectors/vm';
 import { getAddDiskPatches } from '../../k8s/patches/vm/vm-disk-patches';
 import { VMLikeEntityKind } from '../../types';
-import { ValidationErrorType } from '../../utils/validations/common';
 import { validateDiskName } from '../../utils/validations/vm';
 import { GENERAL_ERROR_MSG } from '../../utils/validations/strings';
+import { ValidationErrorType } from '../../utils/validations/types';
+import { getResource } from '../../utils';
 import { VMDiskRowProps } from './types';
 import './_create-device-row.scss';
 
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-disks/types.ts b/frontend/packages/kubevirt-plugin/src/components/vm-disks/types.ts
index 70750fc5995..2ac77bec828 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-disks/types.ts
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-disks/types.ts
@@ -1,7 +1,7 @@
 import { EntityMap } from '@console/shared';
 import { VMLikeEntityKind, VMKind } from '../../types';
 
-export enum StorageType {
+export enum StorageRowType {
   STORAGE_TYPE_VM = 'storage-type-vm',
   STORAGE_TYPE_CREATE = 'storage-type-create',
 }
@@ -10,7 +10,7 @@ export type StorageBundle = {
   name: string;
   size: string;
   storageClass: string;
-  storageType: StorageType;
+  storageType: StorageRowType;
   disk: any;
 };
 
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-disks/vm-disks.tsx b/frontend/packages/kubevirt-plugin/src/components/vm-disks/vm-disks.tsx
index 50cb5f85594..13e0e596e20 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-disks/vm-disks.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-disks/vm-disks.tsx
@@ -5,7 +5,6 @@ import { Alert, AlertActionCloseButton } from '@patternfly/react-core';
 import { Table } from '@console/internal/components/factory';
 import { PersistentVolumeClaimModel } from '@console/internal/models';
 import { Firehose, FirehoseResult, Kebab } from '@console/internal/components/utils';
-import { getResource } from 'kubevirt-web-ui-components';
 import { getNamespace, getName, createBasicLookup, createLookup } from '@console/shared';
 import { useSafetyFirst } from '@console/internal/components/safety-first';
 import { K8sResourceKind } from '@console/internal/module/k8s';
@@ -26,16 +25,17 @@ import {
   getDataVolumeStorageSize,
 } from '../../selectors/dv/selectors';
 import { VMLikeEntityTabProps } from '../vms/types';
+import { getResource } from '../../utils';
 import { DiskRow } from './disk-row';
-import { StorageBundle, StorageType, VMDiskRowProps } from './types';
+import { StorageBundle, StorageRowType, VMDiskRowProps } from './types';
 import { CreateDiskRowFirehose } from './create-disk-row';
 
 export const VMDiskRow: React.FC<VMDiskRowProps> = (props) => {
   switch (props.obj.storageType) {
-    case StorageType.STORAGE_TYPE_VM:
-      return <DiskRow {...props} key={StorageType.STORAGE_TYPE_VM} />;
-    case StorageType.STORAGE_TYPE_CREATE:
-      return <CreateDiskRowFirehose {...props} key={StorageType.STORAGE_TYPE_CREATE} />;
+    case StorageRowType.STORAGE_TYPE_VM:
+      return <DiskRow {...props} key={StorageRowType.STORAGE_TYPE_VM} />;
+    case StorageRowType.STORAGE_TYPE_CREATE:
+      return <CreateDiskRowFirehose {...props} key={StorageRowType.STORAGE_TYPE_CREATE} />;
     default:
       return null;
   }
@@ -96,13 +96,13 @@ const getStoragesData = (
       ...disk, // for sorting
       size,
       storageClass,
-      storageType: StorageType.STORAGE_TYPE_VM,
+      storageType: StorageRowType.STORAGE_TYPE_VM,
       disk,
     };
   });
 
   return addNewDisk
-    ? [{ storageType: StorageType.STORAGE_TYPE_CREATE, rerenderFlag }, ...disksWithType]
+    ? [{ storageType: StorageRowType.STORAGE_TYPE_CREATE, rerenderFlag }, ...disksWithType]
     : disksWithType;
 };
 
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-nics/create-nic-row.tsx b/frontend/packages/kubevirt-plugin/src/components/vm-nics/create-nic-row.tsx
index b8c8615ac0c..0bb147be2dd 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-nics/create-nic-row.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-nics/create-nic-row.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import * as _ from 'lodash';
-import { CancelAcceptButtons, Dropdown, getResource, Text } from 'kubevirt-web-ui-components';
+import { CancelAcceptButtons, Dropdown, Text } from 'kubevirt-web-ui-components';
 import { connect } from 'react-redux';
 import { TableData, TableRow } from '@console/internal/components/factory';
 import { Firehose, FirehoseResult, LoadingInline } from '@console/internal/components/utils';
@@ -17,6 +17,7 @@ import { NetworkType } from '../../constants/vm';
 import { getValidationErrorMessage, getValidationErrorType } from '../../utils/validations/common';
 import { validateMACAddress, validateNicName } from '../../utils/validations/vm';
 import { GENERAL_ERROR_MSG } from '../../utils/validations/strings';
+import { getResource } from '../../utils';
 import { getDefaultNetworkBinding, getNetworkBindings, nicTableColumnClasses } from './utils';
 import { VMNicRowProps } from './types';
 import '../vm-disks/_create-device-row.scss';
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template-details.tsx b/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template-details.tsx
index 011870ac271..950f54386f7 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template-details.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template-details.tsx
@@ -1,7 +1,6 @@
 import * as React from 'react';
 import * as _ from 'lodash';
 import { connect } from 'react-redux';
-import { getResource } from 'kubevirt-web-ui-components';
 import { getNamespace } from '@console/shared';
 import {
   Firehose,
@@ -14,6 +13,7 @@ import {
 import { TemplateKind } from '@console/internal/module/k8s';
 import { TemplateModel } from '@console/internal/models';
 import { DataVolumeModel } from '../../models';
+import { getResource } from '../../utils';
 import { VMTemplateResourceSummary, VMTemplateDetailsList } from './vm-template-resource';
 
 const VMTemplateDetailsFirehose: React.FC<VMTemplateDetailsFirehoseProps> = (props) => {
diff --git a/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template.tsx b/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template.tsx
index 781c40e1193..187b0a6b152 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vm-templates/vm-template.tsx
@@ -14,9 +14,11 @@ import { getNamespace, DASH } from '@console/shared';
 import { TemplateModel } from '@console/internal/models';
 import { TemplateKind } from '@console/internal/module/k8s';
 import { match } from 'react-router';
+import { connect } from 'react-redux';
 import { dimensifyHeader, dimensifyRow } from '../../utils/table';
 import { openCreateVmWizard } from '../modals';
 import { VM_TEMPLATE_LABEL_PLURAL } from '../../constants/vm-templates';
+import { getCreateVMWizards } from '../create-vm-wizard/selectors/selectors';
 import { menuActions } from './menu-actions';
 import { VMTemplateLink } from './vm-template-link';
 
@@ -101,7 +103,7 @@ const VMTemplateTableRow: React.FC<VMTemplateTableRowProps> = ({
       <TableData className={dimensify()}>
         <TemplateSource template={template} />
       </TableData>
-      <TableData className={dimensify()}>{os ? os.name || os.id : DASH}</TableData>
+      <TableData className={dimensify()}>{os ? os.name || os.fieldId : DASH}</TableData>
       <TableData className={dimensify()}>{getTemplateFlavors([template])[0]}</TableData>
       <TableData className={dimensify(true)}>
         <ResourceKebab actions={menuActions} kind={kind} resource={template} />
@@ -122,17 +124,34 @@ const VirtualMachineTemplates: React.FC<React.ComponentProps<typeof Table>> = (p
     />
   );
 };
-
-const getCreateProps = (namespace: string) => ({
-  items: {
+const getCreateProps = ({
+  namespace,
+  hasCreateVMWizardsSupport,
+}: {
+  namespace: string;
+  hasCreateVMWizardsSupport: boolean;
+}) => {
+  const items: any = {
     wizard: 'Create with Wizard',
     yaml: 'Create from YAML',
-  },
-  createLink: () => `/k8s/ns/${namespace || 'default'}/vmtemplates/~new/`,
-  action: (itemName) => (itemName === 'wizard' ? () => openCreateVmWizard(namespace, true) : null),
-});
+  };
+
+  if (hasCreateVMWizardsSupport) {
+    items.wizardNew = 'Create with New Wizard';
+  }
 
-const VirtualMachineTemplatesPage: React.FC<
+  return {
+    items,
+    createLink: (itemName) =>
+      `/k8s/ns/${namespace || 'default'}/vmtemplates/${
+        !hasCreateVMWizardsSupport || itemName === 'yaml' ? '~new' : '~new-wizard'
+      }`, // covers 'yaml', new-wizard and default
+    action: (itemName) =>
+      itemName === 'wizard' ? () => openCreateVmWizard(namespace, true) : null,
+  };
+};
+
+const VirtualMachineTemplatesPageComponent: React.FC<
   VirtualMachineTemplatesPageProps & React.ComponentProps<typeof ListPage>
 > = (props) => (
   <ListPage
@@ -142,10 +161,17 @@ const VirtualMachineTemplatesPage: React.FC<
     kind={kind}
     selector={selector}
     canCreate
-    createProps={getCreateProps(props.match.params.ns)}
+    createProps={getCreateProps({
+      namespace: props.match.params.ns,
+      hasCreateVMWizardsSupport: props.hasCreateVMWizardsSupport,
+    })}
   />
 );
 
+const VirtualMachineTemplatesPage = connect((state) => ({
+  hasCreateVMWizardsSupport: !!getCreateVMWizards(state),
+}))(VirtualMachineTemplatesPageComponent);
+
 type VMTemplateTableRowProps = {
   obj: TemplateKind;
   index: number;
@@ -155,6 +181,7 @@ type VMTemplateTableRowProps = {
 
 type VirtualMachineTemplatesPageProps = {
   match: match<{ ns?: string }>;
+  hasCreateVMWizardsSupport: boolean;
 };
 
 export { VirtualMachineTemplatesPage };
diff --git a/frontend/packages/kubevirt-plugin/src/components/vms/vm-console.tsx b/frontend/packages/kubevirt-plugin/src/components/vms/vm-console.tsx
index f44f993e0d0..aa3fb4d4606 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vms/vm-console.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vms/vm-console.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { Firehose, FirehoseResult, LoadingInline } from '@console/internal/components/utils';
-import { VmConsoles, isWindows, getResource } from 'kubevirt-web-ui-components';
+import { VmConsoles, isWindows } from 'kubevirt-web-ui-components';
 import { getName, getNamespace } from '@console/shared';
 import { WSFactory } from '@console/internal/module/ws-factory';
 import { K8sResourceKind } from '@console/internal/module/k8s';
@@ -19,8 +19,8 @@ import {
 } from '../../selectors/vmi';
 import { findVMPod } from '../../selectors/pod/selectors';
 import { VMIKind, VMKind } from '../../types/vm';
-import { getLoadedData } from '../../utils';
 import { getVMStatus } from '../../statuses/vm/vm';
+import { getLoadedData, getResource } from '../../utils';
 import { menuActionStart } from './menu-actions';
 import { VMTabProps } from './types';
 
diff --git a/frontend/packages/kubevirt-plugin/src/components/vms/vm-details-page.tsx b/frontend/packages/kubevirt-plugin/src/components/vms/vm-details-page.tsx
index 097aa67d425..e95df7f74b8 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vms/vm-details-page.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vms/vm-details-page.tsx
@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { getResource } from 'kubevirt-web-ui-components';
 import { navFactory } from '@console/internal/components/utils';
 import { DetailsPage } from '@console/internal/components/factory';
 import { K8sResourceKindReference } from '@console/internal/module/k8s';
@@ -7,6 +6,7 @@ import { PodModel } from '@console/internal/models';
 import { VMDisksFirehose } from '../vm-disks';
 import { VMNics } from '../vm-nics';
 import { VirtualMachineInstanceMigrationModel, VirtualMachineInstanceModel } from '../../models';
+import { getResource } from '../../utils';
 import { VMEvents } from './vm-events';
 import { VMConsoleFirehose } from './vm-console';
 import { VMDetailsFirehose } from './vm-details';
diff --git a/frontend/packages/kubevirt-plugin/src/components/vms/vm-details.tsx b/frontend/packages/kubevirt-plugin/src/components/vms/vm-details.tsx
index 7212037bac4..00144b4a042 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vms/vm-details.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vms/vm-details.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { getResource, getServicesForVm } from 'kubevirt-web-ui-components';
+import { getServicesForVm } from 'kubevirt-web-ui-components';
 import {
   Firehose,
   StatusBox,
@@ -14,7 +14,7 @@ import { K8sResourceKind, PodKind, TemplateKind } from '@console/internal/module
 import { ServiceModel } from '@console/internal/models';
 import { ServicesList } from '@console/internal/components/service';
 import { VMKind, VMIKind } from '../../types';
-import { getLoadedData } from '../../utils';
+import { getLoadedData, getResource } from '../../utils';
 import { VirtualMachineInstanceModel } from '../../models';
 import { VMResourceSummary, VMDetailsList } from './vm-resource';
 import { VMTabProps } from './types';
diff --git a/frontend/packages/kubevirt-plugin/src/components/vms/vm.tsx b/frontend/packages/kubevirt-plugin/src/components/vms/vm.tsx
index 61b18ee4a39..9d1d83e70ad 100644
--- a/frontend/packages/kubevirt-plugin/src/components/vms/vm.tsx
+++ b/frontend/packages/kubevirt-plugin/src/components/vms/vm.tsx
@@ -1,8 +1,8 @@
 import * as React from 'react';
+import { connect } from 'react-redux';
 import * as classNames from 'classnames';
 import { sortable } from '@patternfly/react-table';
 import {
-  getResource,
   VmStatus,
   // getSimpleVmStatus,
   // VM_SIMPLE_STATUS_ALL,
@@ -22,9 +22,10 @@ import {
 import { VMIKind, VMKind } from '../../types';
 import { getMigrationVMIName, isMigrating } from '../../selectors/vmi-migration';
 import { dimensifyHeader, dimensifyRow } from '../../utils/table';
-import { getBasicID, getLoadedData } from '../../utils';
+import { getBasicID, getLoadedData, getResource } from '../../utils';
 import { openCreateVmWizard } from '../modals';
 import { getVMStatus } from '../../statuses/vm/vm';
+import { getCreateVMWizards } from '../create-vm-wizard/selectors/selectors';
 import { vmStatusFilter } from './table-filters';
 import { menuActions } from './menu-actions';
 
@@ -129,17 +130,34 @@ const VMList: React.FC<React.ComponentProps<typeof Table> & VMListProps> = (prop
 
 VMList.displayName = 'VMList';
 
-const getCreateProps = (namespace: string) => ({
-  items: {
+const getCreateProps = ({
+  namespace,
+  hasCreateVMWizardsSupport,
+}: {
+  namespace: string;
+  hasCreateVMWizardsSupport: boolean;
+}) => {
+  const items: any = {
     wizard: 'Create with Wizard',
     yaml: 'Create from YAML',
-  },
-  createLink: () => `/k8s/ns/${namespace || 'default'}/virtualmachines/~new/`, // covers 'yaml' and default
-  action: (itemName) => (itemName === 'wizard' ? () => openCreateVmWizard(namespace) : null),
-});
+  };
+
+  if (hasCreateVMWizardsSupport) {
+    items.wizardNew = 'Create with New Wizard';
+  }
 
-export const VirtualMachinesPage: React.FC<VirtualMachinesPageProps> = (props) => {
-  const { namespace } = props;
+  return {
+    items,
+    createLink: (itemName) =>
+      `/k8s/ns/${namespace || 'default'}/virtualmachines/${
+        !hasCreateVMWizardsSupport || itemName === 'yaml' ? '~new' : '~new-wizard'
+      }`, // covers 'yaml', new-wizard and default
+    action: (itemName) => (itemName === 'wizard' ? () => openCreateVmWizard(namespace) : null),
+  };
+};
+
+const VirtualMachinesPageComponent: React.FC<VirtualMachinesPageProps> = (props) => {
+  const { namespace, hasCreateVMWizardsSupport } = props;
 
   const resources = [
     getResource(VirtualMachineModel, { namespace, prop: 'vms' }),
@@ -161,13 +179,17 @@ export const VirtualMachinesPage: React.FC<VirtualMachinesPageProps> = (props) =
       title={VirtualMachineModel.labelPlural}
       rowFilters={[vmStatusFilter]}
       ListComponent={VMList}
-      createProps={getCreateProps(props.namespace)}
+      createProps={getCreateProps({ namespace, hasCreateVMWizardsSupport })}
       resources={resources}
       flatten={flatten}
     />
   );
 };
 
+export const VirtualMachinesPage = connect((state) => ({
+  hasCreateVMWizardsSupport: !!getCreateVMWizards(state),
+}))(VirtualMachinesPageComponent);
+
 type VMRowProps = {
   obj: VMKind;
   index: number;
@@ -193,4 +215,5 @@ type VMListProps = {
 type VirtualMachinesPageProps = {
   namespace: string;
   obj: VMKind;
+  hasCreateVMWizardsSupport: boolean;
 };
diff --git a/frontend/packages/kubevirt-plugin/src/constants/keys.ts b/frontend/packages/kubevirt-plugin/src/constants/keys.ts
new file mode 100644
index 00000000000..860b5d99b4e
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/constants/keys.ts
@@ -0,0 +1,37 @@
+export const KEY_CODES = {
+  BACKSPACE: 8,
+  SHIFT: 16,
+  LEFT_KEY: 37,
+  RIGHT_KEY: 39,
+  DELETE_KEY: 46,
+  0: 48,
+  1: 49,
+  9: 57,
+  NUMPAD: {
+    0: 96,
+    1: 97,
+    9: 105,
+    SUBTRACT: 109,
+  },
+  HYPHEN_MINUS: 173,
+  MINUS: 189,
+};
+
+export const INPUT_NAVIGATION_KEYS = [
+  KEY_CODES.BACKSPACE,
+  KEY_CODES.SHIFT,
+  KEY_CODES.LEFT_KEY,
+  KEY_CODES.RIGHT_KEY,
+  KEY_CODES.DELETE_KEY,
+];
+
+export const isMinus = (keyCode) => {
+  switch (keyCode) {
+    case KEY_CODES.HYPHEN_MINUS:
+    case KEY_CODES.MINUS:
+    case KEY_CODES.NUMPAD.SUBTRACT:
+      return true;
+    default:
+      return false;
+  }
+};
diff --git a/frontend/packages/kubevirt-plugin/src/constants/vm/nic.ts b/frontend/packages/kubevirt-plugin/src/constants/vm/nic.ts
index 197deb0651b..e6a3d8ac275 100644
--- a/frontend/packages/kubevirt-plugin/src/constants/vm/nic.ts
+++ b/frontend/packages/kubevirt-plugin/src/constants/vm/nic.ts
@@ -1,7 +1,7 @@
 export const POD_NETWORK = 'Pod Networking';
 
 export enum NetworkType {
-  MULTUS = 'multus',
+  MULTUS = 'multus', // compatible with web-ui-components constants
   POD = 'pod',
 }
 
diff --git a/frontend/packages/kubevirt-plugin/src/constants/vm/storage.ts b/frontend/packages/kubevirt-plugin/src/constants/vm/storage.ts
new file mode 100644
index 00000000000..be82778c21e
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/constants/vm/storage.ts
@@ -0,0 +1,4 @@
+export enum StorageType { // TODO add other types / refactor
+  DATAVOLUME = 'datavolume', // compatible with web-ui-components constants
+  CONTAINER = 'container',
+}
diff --git a/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/enhancedK8sMethods.ts b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/enhancedK8sMethods.ts
new file mode 100644
index 00000000000..05b395f68df
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/enhancedK8sMethods.ts
@@ -0,0 +1,183 @@
+import { get } from 'lodash';
+import {
+  k8sGet as _k8sGet,
+  k8sCreate as _k8sCreate,
+  k8sPatch as _k8sPatch,
+  k8sKill as _k8sKill,
+  K8sResourceKind,
+  K8sKind,
+  Patch,
+  referenceForModel,
+} from '@console/internal/module/k8s';
+import { getFullResourceId } from '../../utils/utils';
+import {
+  K8sCreateError,
+  K8sGetError,
+  K8sKillError,
+  K8sMultipleErrors,
+  K8sPatchError,
+} from './errors';
+
+export enum HistoryType {
+  GET = 'GET',
+  CREATE = 'CREATE',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+  NOT_FOUND = 'NOT_FOUND',
+}
+
+export class HistoryItem {
+  readonly type: HistoryType;
+
+  readonly object: K8sResourceKind;
+
+  constructor(type: HistoryType, object: K8sResourceKind) {
+    this.type = type;
+    this.object = object;
+  }
+}
+
+export type EnhancedOpts = {
+  disableHistory: boolean;
+};
+
+export class EnhancedK8sMethods {
+  private readonly history: HistoryItem[] = [];
+
+  private readonly modelMap: { [k: string]: K8sKind } = {};
+
+  private registerKind = (kind: K8sKind) => {
+    this.modelMap[referenceForModel(kind)] = kind;
+  };
+
+  private appendHistory = (historyItem: HistoryItem, enhancedOpts?: EnhancedOpts) => {
+    if (!enhancedOpts || !enhancedOpts.disableHistory) {
+      this.history.push(historyItem);
+    }
+  };
+
+  k8sGet = async (
+    kind: K8sKind,
+    name: string,
+    namespace: string,
+    opts?,
+    enhancedOpts?: EnhancedOpts,
+  ) => {
+    try {
+      this.registerKind(kind);
+      const result = await _k8sGet(kind, name, namespace, opts);
+      this.appendHistory(new HistoryItem(HistoryType.GET, result), enhancedOpts);
+      return result;
+    } catch (error) {
+      throw new K8sGetError(error.message, { name, namespace });
+    }
+  };
+
+  k8sCreate = async (kind: K8sKind, data: K8sResourceKind, opts?, enhancedOpts?: EnhancedOpts) => {
+    try {
+      this.registerKind(kind);
+      const result = await _k8sCreate(kind, data, opts);
+      this.appendHistory(new HistoryItem(HistoryType.CREATE, result), enhancedOpts);
+      return result;
+    } catch (error) {
+      throw new K8sCreateError(error.message, data);
+    }
+  };
+
+  k8sPatch = async (
+    kind: K8sKind,
+    resource: K8sResourceKind,
+    patches: Patch[],
+    enhancedOpts?: EnhancedOpts,
+  ) => {
+    try {
+      this.registerKind(kind);
+      const result = await _k8sPatch(kind, resource, patches);
+      this.appendHistory(new HistoryItem(HistoryType.PATCH, result), enhancedOpts);
+      return result;
+    } catch (error) {
+      throw new K8sPatchError(error.message, resource, patches);
+    }
+  };
+
+  k8sKill = async (
+    kind: K8sKind,
+    resource: K8sResourceKind,
+    opts?,
+    json?,
+    enhancedOpts?: EnhancedOpts,
+  ) => {
+    try {
+      this.registerKind(kind);
+      const result = await _k8sKill(kind, resource, opts, json);
+      this.appendHistory(new HistoryItem(HistoryType.DELETE, resource), enhancedOpts);
+      return result;
+    } catch (error) {
+      throw new K8sKillError(error.message, error.json, resource);
+    }
+  };
+
+  getHistory = () => [...this.history];
+
+  // replay history and resolve actual state
+  getActualState = () => {
+    const currentIndexes = {};
+    const currentUnfilteredState = [];
+
+    this.history.forEach(({ type, object }) => {
+      const id = getFullResourceId(object);
+      const currentIdx = currentIndexes[id];
+      switch (type) {
+        case HistoryType.GET:
+        case HistoryType.CREATE:
+        case HistoryType.PATCH:
+          if (currentIdx != null && currentIdx >= 0) {
+            currentUnfilteredState[currentIdx] = object;
+          } else {
+            currentIndexes[id] = currentUnfilteredState.push(object) - 1;
+          }
+          break;
+        case HistoryType.DELETE:
+        case HistoryType.NOT_FOUND:
+          currentUnfilteredState[currentIdx] = null;
+          currentIndexes[id] = null;
+          break;
+        default:
+          break;
+      }
+    });
+
+    return currentUnfilteredState.filter((a) => a);
+  };
+
+  rollback = async () => {
+    const state = this.getActualState();
+    const errors = [];
+    const deleteStatuses = [];
+
+    // delete one by one in reverse order the objects were created in
+    for (let i = state.length - 1; i >= 0; i--) {
+      let obj;
+      try {
+        obj = state[i];
+        // eslint-disable-next-line no-await-in-loop
+        const result = await this.k8sKill(this.modelMap[referenceForModel(obj)], obj);
+        deleteStatuses.push(result);
+      } catch (error) {
+        if (get(error, 'json.code') === 404 || get(error, 'json.reason') === 'NotFound') {
+          // happy path
+          this.appendHistory(new HistoryItem(HistoryType.NOT_FOUND, obj));
+          deleteStatuses.push(error.json);
+        } else {
+          errors.push(error);
+        }
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new K8sMultipleErrors('rollback', errors);
+    }
+
+    return deleteStatuses;
+  };
+}
diff --git a/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/errors.ts b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/errors.ts
new file mode 100644
index 00000000000..058c13457f4
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/errors.ts
@@ -0,0 +1,55 @@
+import { K8sResourceKind, Patch } from '@console/internal/module/k8s';
+
+type K8sError = K8sGetError | K8sCreateError | K8sPatchError | K8sKillError;
+type K8sGetObject = { name: string; namespace: string };
+
+export class K8sGetError extends Error {
+  readonly failedObject: K8sGetObject;
+
+  constructor(message: string, failedObject: K8sGetObject) {
+    super(message);
+    this.failedObject = failedObject;
+  }
+}
+
+export class K8sCreateError extends Error {
+  readonly failedObject: K8sResourceKind;
+
+  constructor(message: string, failedObject: K8sResourceKind) {
+    super(message);
+    this.failedObject = failedObject;
+  }
+}
+
+export class K8sPatchError extends Error {
+  readonly failedObject: K8sResourceKind;
+
+  readonly failedPatches: Patch[];
+
+  constructor(message: string, failedObject: K8sResourceKind, failedPatches: Patch[]) {
+    super(message);
+    this.failedObject = failedObject;
+    this.failedPatches = failedPatches;
+  }
+}
+
+export class K8sKillError extends Error {
+  readonly failedObject: K8sResourceKind;
+
+  readonly json: any;
+
+  constructor(message: string, json, failedObject: K8sResourceKind) {
+    super(message);
+    this.json = json;
+    this.failedObject = failedObject;
+  }
+}
+
+export class K8sMultipleErrors extends Error {
+  readonly errors: K8sError[];
+
+  constructor(message: string, errors: K8sError[]) {
+    super(message);
+    this.errors = errors;
+  }
+}
diff --git a/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/k8sMethodsUtils.ts b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/k8sMethodsUtils.ts
new file mode 100644
index 00000000000..3cea86fd1eb
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/k8s/enhancedK8sMethods/k8sMethodsUtils.ts
@@ -0,0 +1,125 @@
+import { getName } from '@console/shared';
+import { K8sResourceKind } from '@console/internal/module/k8s';
+import {
+  CREATED,
+  CREATED_WITH_CLEANUP,
+  CREATED_WITH_FAILED_CLEANUP,
+  ERROR,
+  FAILED_TO_CREATE,
+  FAILED_TO_PATCH,
+} from '../../utils/strings';
+import { getGeneratedName, getKind } from '../../selectors/selectors';
+import { getFullResourceId } from '../../utils/utils';
+import { EnhancedK8sMethods } from './enhancedK8sMethods';
+
+const k8sObjectToResult = ({
+  obj,
+  content,
+  message,
+  isExpanded,
+  isError,
+}: {
+  obj?: K8sResourceKind;
+  content: any;
+  message: string;
+  isExpanded?: boolean;
+  isError?: boolean;
+}) => ({
+  title: [getKind(obj), getName(obj) || getGeneratedName(obj), message].filter((a) => a).join(' '),
+  content,
+  isExpanded,
+  isError,
+});
+
+type Result = {
+  title: string;
+  content: any;
+  isExpanded: boolean;
+  isError: boolean;
+};
+
+type ResultsWrapper = {
+  valid: boolean;
+  results: Result[];
+};
+
+export const cleanupAndGetResults = async (
+  enhancedK8sMethods,
+  { message, failedObject, failedPatches },
+): Promise<ResultsWrapper> => {
+  const actualState = enhancedK8sMethods.getActualState(); // actual state will differ after cleanup
+
+  let errors;
+  try {
+    await enhancedK8sMethods.rollback();
+  } catch (e) {
+    // eslint-disable-next-line prefer-destructuring
+    errors = e.errors;
+  }
+
+  const failedObjectsMap = {};
+
+  if (errors) {
+    errors.forEach((error) => {
+      failedObjectsMap[getFullResourceId(error.failedObject)] = error.failedObject;
+    });
+  }
+
+  const cleanupArray = actualState
+    .map((resource) => {
+      const failedToCleanup = !!failedObjectsMap[getFullResourceId(resource)];
+
+      return k8sObjectToResult({
+        obj: resource,
+        content: resource,
+        message: failedToCleanup ? CREATED_WITH_FAILED_CLEANUP : CREATED_WITH_CLEANUP,
+        isExpanded: failedToCleanup,
+        isError: failedToCleanup,
+      });
+    })
+    .reverse();
+
+  const errorResults = [
+    k8sObjectToResult({
+      content: message,
+      message: ERROR,
+      isExpanded: true,
+      isError: true,
+    }),
+  ];
+
+  if (failedPatches || failedObject) {
+    errorResults.push(
+      k8sObjectToResult({
+        obj: failedObject,
+        content: failedPatches || failedObject,
+        message: failedPatches ? FAILED_TO_PATCH : FAILED_TO_CREATE,
+        isError: true,
+      }),
+    );
+  }
+
+  return {
+    valid: false,
+    results: [...errorResults, ...cleanupArray],
+  };
+};
+
+export const getResults = (enhancedK8sMethods: EnhancedK8sMethods): ResultsWrapper => ({
+  valid: true,
+  results: enhancedK8sMethods
+    .getActualState()
+    .map((obj) => k8sObjectToResult({ obj, content: obj, message: CREATED }))
+    .reverse(),
+});
+
+export const errorsFirstSort = (results: Result[]) =>
+  results
+    .map((result, sortIndex) => ({ ...result, sortIndex }))
+    // move errors to the top
+    .sort((a, b) => {
+      if (a.isError === b.isError) {
+        return a.sortIndex - b.sortIndex;
+      }
+      return a.isError ? -1 : 1;
+    });
diff --git a/frontend/packages/kubevirt-plugin/src/plugin.tsx b/frontend/packages/kubevirt-plugin/src/plugin.tsx
index 7dd256d85b6..e1b170b44bf 100644
--- a/frontend/packages/kubevirt-plugin/src/plugin.tsx
+++ b/frontend/packages/kubevirt-plugin/src/plugin.tsx
@@ -145,7 +145,29 @@ const plugin: Plugin<ConsumedExtensions> = [
   {
     type: 'Page/Route',
     properties: {
-      path: `/k8s/ns/:ns/vmtemplates/:name`,
+      exact: true,
+      path: ['/k8s/ns/:ns/virtualmachines/~new-wizard'],
+      loader: () =>
+        import(
+          './components/create-vm-wizard' /* webpackChunkName: "kubevirt-create-vm-wizard" */
+        ).then((m) => m.CreateVMWizardPage),
+    },
+  },
+  {
+    type: 'Page/Route',
+    properties: {
+      exact: true,
+      path: ['/k8s/ns/:ns/vmtemplates/~new-wizard'],
+      loader: () =>
+        import(
+          './components/create-vm-wizard' /* webpackChunkName: "kubevirt-create-vm-wizard" */
+        ).then((m) => m.CreateVMWizardPage),
+    },
+  },
+  {
+    type: 'Page/Route',
+    properties: {
+      path: '/k8s/ns/:ns/vmtemplates/:name',
       loader: () =>
         import(
           './components/vm-templates/vm-template-details-page' /* webpackChunkName: "kubevirt" */
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/dv/selectors.ts b/frontend/packages/kubevirt-plugin/src/selectors/dv/selectors.ts
index 8c5d1b4bfe8..54676779c19 100644
--- a/frontend/packages/kubevirt-plugin/src/selectors/dv/selectors.ts
+++ b/frontend/packages/kubevirt-plugin/src/selectors/dv/selectors.ts
@@ -1,6 +1,7 @@
 import * as _ from 'lodash';
 import { K8sResourceKind } from '@console/internal/module/k8s';
 import { getStorageSize } from '../selectors';
+import { DataVolumeSource } from '../../types/dv';
 
 export const getDataVolumeResources = (dataVolume: K8sResourceKind) =>
   _.get(dataVolume, 'spec.pvc.resources');
@@ -14,3 +15,28 @@ export const getDataVolumeVolumeMode = (dataVolume: K8sResourceKind) =>
   _.get(dataVolume, 'spec.pvc.volumeMode');
 export const getDataVolumeStorageClassName = (dataVolume: K8sResourceKind): string =>
   _.get(dataVolume, 'spec.pvc.storageClassName');
+
+export const getDataVolumeSourceType = (dataVolume: K8sResourceKind) => {
+  const source = _.get(dataVolume, 'spec.source');
+  if (_.get(source, 'http')) {
+    return {
+      type: DataVolumeSource.URL,
+      url: _.get(dataVolume, 'spec.source.http.url'),
+    };
+  }
+  if (_.get(source, 'pvc')) {
+    return {
+      type: DataVolumeSource.PVC,
+      name: _.get(dataVolume, 'spec.source.pvc.name'),
+      namespace: _.get(dataVolume, 'spec.source.pvc.namespace'),
+    };
+  }
+  if (_.get(source, 'blank')) {
+    return {
+      type: DataVolumeSource.BLANK,
+    };
+  }
+  return {
+    type: DataVolumeSource.UNKNOWN,
+  };
+};
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/selectors.ts b/frontend/packages/kubevirt-plugin/src/selectors/selectors.ts
index 3df0a1cd357..d378394f334 100644
--- a/frontend/packages/kubevirt-plugin/src/selectors/selectors.ts
+++ b/frontend/packages/kubevirt-plugin/src/selectors/selectors.ts
@@ -2,13 +2,24 @@ import * as _ from 'lodash';
 import { K8sResourceKind } from '@console/internal/module/k8s';
 import { VMLikeEntityKind } from '../types';
 
+export const getKind = (value) => _.get(value, 'kind') as K8sResourceKind['kind'];
+
+export const getGeneratedName = (value) =>
+  _.get(value, 'metadata.generateName') as K8sResourceKind['metadata']['generateName'];
+
 export const getLabels = (entity: K8sResourceKind, defaultValue?: any) =>
   _.get(entity, 'metadata.labels', defaultValue) as K8sResourceKind['metadata']['labels'];
 export const getAnnotations = (vm: VMLikeEntityKind, defaultValue?: any) =>
   _.get(vm, 'metadata.annotations', defaultValue);
+export const getAnnotation = (vm: VMLikeEntityKind, annotationName: string, defaultValue?: any) =>
+  _.get(vm, ['metadata', 'annotations', annotationName], defaultValue);
+
 export const getDescription = (vm: VMLikeEntityKind) =>
   _.get(vm, 'metadata.annotations.description');
 
+export const getLabelValue = (entity: K8sResourceKind, label: string): string =>
+  _.get(entity, ['metadata', 'labels', label]);
+
 export const getStorageSize = (value): string => _.get(value, 'requests.storage');
 
 export const getValueByPrefix = (obj = {}, keyPrefix: string): string => {
@@ -26,6 +37,3 @@ export const getAnnotationKeySuffix = (
   ) as K8sResourceKind['metadata']['annotations'];
   return getValueByPrefix(annotations, annotationPrefix);
 };
-
-export const getLabelValue = (entity: K8sResourceKind, label: string): string =>
-  _.get(entity, ['metadata', 'labels', label]);
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/vm-template/advanced.ts b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/advanced.ts
new file mode 100644
index 00000000000..f9f6a6e603a
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/advanced.ts
@@ -0,0 +1,67 @@
+import * as _ from 'lodash';
+import { TemplateKind } from '@console/internal/module/k8s';
+import { getAnnotation, getAnnotations, getLabels } from '../selectors';
+import {
+  TEMPLATE_FLAVOR_LABEL,
+  TEMPLATE_OS_LABEL,
+  TEMPLATE_OS_NAME_ANNOTATION,
+  TEMPLATE_TYPE_LABEL,
+  TEMPLATE_TYPE_VM,
+  TEMPLATE_WORKLOAD_LABEL,
+} from '../../constants/vm';
+
+export const getTemplatesWithLabels = (templates: TemplateKind[], labels: string[]) => {
+  const requiredLabels = labels.filter((label) => label);
+  return templates.filter((template) => {
+    const templateLabels = new Set(Object.keys(getLabels(template, {})));
+    const missingLabel = requiredLabels.find((requiredLabel) => !templateLabels.has(requiredLabel));
+    return !missingLabel;
+  });
+};
+
+export const getTemplatesOfLabelType = (templates: TemplateKind[], type: string) =>
+  (templates || []).filter(
+    (template) => _.get(template, ['metadata', 'labels', TEMPLATE_TYPE_LABEL]) === type,
+  );
+
+export const getUserTemplate = (templates: TemplateKind[], userTemplateName: string) => {
+  const userTemplates = getTemplatesOfLabelType(templates, TEMPLATE_TYPE_VM);
+  return userTemplates.find((template) => template.metadata.name === userTemplateName);
+};
+
+export const getTemplatesLabelValues = (templates: TemplateKind[], label: string): string[] => {
+  const labelValues = [];
+  (templates || []).forEach((template) => {
+    const labels = Object.keys(getLabels(template, {})).filter((l) => l.startsWith(label));
+    labels.forEach((l) => {
+      const labelParts = l.split('/');
+      if (labelParts.length > 1) {
+        const labelName = labelParts[labelParts.length - 1];
+        if (labelValues.indexOf(labelName) === -1) {
+          labelValues.push(labelName);
+        }
+      }
+    });
+  });
+  return labelValues;
+};
+
+export const getTemplateFlavors = (templates: TemplateKind[]) =>
+  getTemplatesLabelValues(templates, TEMPLATE_FLAVOR_LABEL);
+
+export const getTemplateOperatingSystems = (templates: TemplateKind[]) => {
+  const osIds = getTemplatesLabelValues(templates, TEMPLATE_OS_LABEL);
+  return osIds.map((osId) => {
+    const nameAnnotation = `${TEMPLATE_OS_NAME_ANNOTATION}/${osId}`;
+    const template = templates.find(
+      (t) => !!Object.keys(getAnnotations(t)).find((annotation) => annotation === nameAnnotation),
+    );
+    return {
+      id: osId,
+      name: getAnnotation(template, nameAnnotation),
+    };
+  });
+};
+
+export const getTemplateWorkloadProfiles = (templates: TemplateKind[]) =>
+  getTemplatesLabelValues(templates, TEMPLATE_WORKLOAD_LABEL);
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined-dependent.ts b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined-dependent.ts
new file mode 100644
index 00000000000..6a8df12d1d0
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined-dependent.ts
@@ -0,0 +1,92 @@
+import * as _ from 'lodash';
+import { getName } from '@console/shared';
+import { TemplateKind } from '@console/internal/module/k8s';
+import {
+  CUSTOM_FLAVOR,
+  TEMPLATE_FLAVOR_LABEL,
+  TEMPLATE_OS_LABEL,
+  TEMPLATE_TYPE_BASE,
+  TEMPLATE_TYPE_VM,
+  TEMPLATE_WORKLOAD_LABEL,
+} from '../../constants/vm';
+import {
+  getTemplatesOfLabelType,
+  getTemplateFlavors,
+  getTemplateOperatingSystems,
+  getTemplatesWithLabels,
+  getTemplateWorkloadProfiles,
+} from './advanced';
+
+const getLabel = (labelPrefix: string, value: string) => {
+  if (value == null) {
+    return undefined;
+  }
+  return `${labelPrefix}/${_.get(value, 'id') || value}`;
+};
+
+export const getWorkloadLabel = (workload: string) => getLabel(TEMPLATE_WORKLOAD_LABEL, workload);
+export const getOsLabel = (os: string) => getLabel(TEMPLATE_OS_LABEL, os);
+export const getFlavorLabel = (flavor: string) => {
+  if (flavor && flavor !== CUSTOM_FLAVOR) {
+    return `${TEMPLATE_FLAVOR_LABEL}/${flavor}`;
+  }
+  return undefined;
+};
+
+export const getOperatingSystems = (
+  templates: TemplateKind[],
+  { workload, flavor, userTemplate }: { workload: string; flavor: string; userTemplate: string },
+) => {
+  let templatesWithLabels;
+  if (userTemplate) {
+    templatesWithLabels = [
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_VM).find((t) => getName(t) === userTemplate),
+    ];
+  } else {
+    templatesWithLabels = getTemplatesWithLabels(
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_BASE),
+      [getWorkloadLabel(workload), getFlavorLabel(flavor)],
+    );
+  }
+  return getTemplateOperatingSystems(templatesWithLabels);
+};
+
+export const getWorkloadProfiles = (
+  templates: TemplateKind[],
+  { flavor, os, userTemplate }: { flavor: string; os: string; userTemplate: string },
+) => {
+  let templatesWithLabels;
+  if (userTemplate) {
+    templatesWithLabels = [
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_VM).find((t) => getName(t) === userTemplate),
+    ];
+  } else {
+    templatesWithLabels = getTemplatesWithLabels(
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_BASE),
+      [getOsLabel(os), getFlavorLabel(flavor)],
+    );
+  }
+  return getTemplateWorkloadProfiles(templatesWithLabels);
+};
+
+export const getFlavors = (
+  templates: TemplateKind[],
+  { workload, os, userTemplate }: { workload: string; os: string; userTemplate: string },
+) => {
+  let templatesWithLabels;
+  if (userTemplate) {
+    templatesWithLabels = [
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_VM).find((t) => getName(t) === userTemplate),
+    ];
+  } else {
+    templatesWithLabels = getTemplatesWithLabels(
+      getTemplatesOfLabelType(templates, TEMPLATE_TYPE_BASE),
+      [getWorkloadLabel(workload), getOsLabel(os)],
+    );
+  }
+  const flavors = getTemplateFlavors(templatesWithLabels);
+  if (!flavors.some((flavor) => flavor === CUSTOM_FLAVOR)) {
+    flavors.push(CUSTOM_FLAVOR);
+  }
+  return flavors;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined.ts b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined.ts
new file mode 100644
index 00000000000..2ff81bf2d08
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/selectors/vm-template/combined.ts
@@ -0,0 +1,109 @@
+import { K8sResourceKind, TemplateKind } from '@console/internal/module/k8s';
+import { getName, getNamespace } from '@console/shared';
+import {
+  getDataVolumeTemplates,
+  getDisks,
+  getInterfaces,
+  getVolumeDataVolumeName,
+  getVolumes,
+} from '../vm';
+import { ProvisionSource } from '../../types/vm';
+import { getDataVolumeSourceType } from '../dv/selectors';
+import { DataVolumeSource } from '../../types/dv';
+import { selectVM } from './selectors';
+
+export const getTemplateProvisionSource = (
+  template: TemplateKind,
+  dataVolumes: K8sResourceKind[],
+): { type: ProvisionSource; source?: string; error?: string } => {
+  const vm = selectVM(template);
+  if (getInterfaces(vm).some((i) => i.bootOrder === 1)) {
+    return {
+      type: ProvisionSource.PXE,
+    };
+  }
+  const bootDisk = getDisks(vm).find((disk) => disk.bootOrder === 1);
+  if (bootDisk) {
+    const bootVolume = getVolumes(vm).find((volume) => volume.name === bootDisk.name);
+    if (bootVolume && bootVolume.containerDisk) {
+      return {
+        type: ProvisionSource.CONTAINER,
+        source: bootVolume.containerDisk.image,
+      };
+    }
+    if (bootVolume && bootVolume.dataVolume) {
+      let dataVolume = getDataVolumeTemplates(vm).find(
+        (dv) => getName(dv) === getVolumeDataVolumeName(bootVolume),
+      );
+      if (!dataVolume) {
+        dataVolume = dataVolumes.find(
+          (d) =>
+            getName(d) === getVolumeDataVolumeName(bootVolume) &&
+            getNamespace(d) === getNamespace(template),
+        );
+      }
+      if (dataVolume) {
+        const source = getDataVolumeSourceType(dataVolume);
+        switch (source.type) {
+          case DataVolumeSource.URL:
+            return {
+              type: ProvisionSource.URL,
+              source: source.url,
+            };
+          case DataVolumeSource.PVC:
+            return {
+              type: ProvisionSource.CLONED_DISK,
+              source: `${source.namespace}/${source.name}`,
+            };
+          case DataVolumeSource.BLANK:
+            return {
+              type: ProvisionSource.UNKNOWN,
+              error: `Datavolume ${bootVolume.dataVolume.name} does not have a supported source (${
+                source.type
+              }).`,
+            };
+          case DataVolumeSource.UNKNOWN:
+          default:
+            return {
+              type: ProvisionSource.UNKNOWN,
+              error: `Datavolume ${bootVolume.dataVolume.name} does not have a supported source.`,
+            };
+        }
+      } else {
+        return {
+          type: ProvisionSource.UNKNOWN,
+          error: `Datavolume ${bootVolume.dataVolume.name} does not exist.`,
+        };
+      }
+    }
+  }
+  return {
+    type: ProvisionSource.UNKNOWN,
+    error: 'No bootable device found.',
+  };
+};
+
+export const getTemplateStorages = (template: TemplateKind, dataVolumes: K8sResourceKind[]) => {
+  const vm = selectVM(template);
+
+  const volumes = getVolumes(vm);
+  const dataVolumeTemplates = getDataVolumeTemplates(vm);
+  return getDisks(vm).map((disk) => {
+    const volume = volumes.find((v) => v.name === disk.name);
+    const storage: any = {
+      disk,
+      volume,
+    };
+    if (getVolumeDataVolumeName(volume)) {
+      storage.dataVolumeTemplate = dataVolumeTemplates.find(
+        (d) => getName(d) === getVolumeDataVolumeName(volume),
+      );
+      storage.dataVolume = dataVolumes.find(
+        (d) =>
+          getName(d) === getVolumeDataVolumeName(volume) &&
+          getNamespace(d) === getNamespace(template),
+      );
+    }
+    return storage;
+  });
+};
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/vm/selectors.ts b/frontend/packages/kubevirt-plugin/src/selectors/vm/selectors.ts
index 8def016c841..04298a04100 100644
--- a/frontend/packages/kubevirt-plugin/src/selectors/vm/selectors.ts
+++ b/frontend/packages/kubevirt-plugin/src/selectors/vm/selectors.ts
@@ -14,17 +14,19 @@ import { getAnnotations, getLabels } from '../selectors';
 import { getDiskBus } from './disk';
 import { getNicBus } from './nic';
 import { Network } from './types';
+import { getVolumeCloudInitUserData } from './volume';
+import { vCPUCount } from './cpu';
 
 export const getMemory = (vm: VMKind) =>
   _.get(vm, 'spec.template.spec.domain.resources.requests.memory');
 export const getCPU = (vm: VMKind): CPURaw => _.get(vm, 'spec.template.spec.domain.cpu');
 export const getDisks = (vm: VMKind) => _.get(vm, 'spec.template.spec.domain.devices.disks', []);
 export const getInterfaces = (vm: VMKind) =>
-  _.get(vm, 'spec.template.spec.domain.devices.interfaces', []);
+  _.get(vm, 'spec.template.spec.domain.devices.interfaces') || [];
 
-export const getNetworks = (vm: VMKind) => _.get(vm, 'spec.template.spec.networks', []);
-export const getVolumes = (vm: VMKind) => _.get(vm, 'spec.template.spec.volumes', []);
-export const getDataVolumeTemplates = (vm: VMKind) => _.get(vm, 'spec.dataVolumeTemplates', []);
+export const getNetworks = (vm: VMKind) => _.get(vm, 'spec.template.spec.networks') || [];
+export const getVolumes = (vm: VMKind) => _.get(vm, 'spec.template.spec.volumes') || [];
+export const getDataVolumeTemplates = (vm: VMKind) => _.get(vm, 'spec.dataVolumeTemplates') || [];
 
 export const getOperatingSystem = (vm: VMLikeEntityKind) =>
   findKeySuffixValue(getLabels(vm), TEMPLATE_OS_LABEL);
@@ -77,8 +79,8 @@ export const getUsedNetworks = (vm: VMKind): Network[] => {
     .filter((i) => i);
 };
 
-export const getFlavorDescription = (vm) => {
-  const cpu = getCPU(vm);
+export const getFlavorDescription = (vm: VMKind) => {
+  const cpu = vCPUCount(getCPU(vm));
   const memory = getMemory(vm);
   const cpuStr = cpu ? `${cpu} CPU` : '';
   const memoryStr = memory ? `${memory} Memory` : '';
@@ -88,3 +90,22 @@ export const getFlavorDescription = (vm) => {
 
 export const getVMStatusConditions = (vm: VMKind) =>
   _.get(vm, 'status.conditions', []) as VMKind['status']['conditions'];
+
+export const getCloudInitVolume = (vm: VMKind) => {
+  const cloudInitVolume = getVolumes(vm).find(getVolumeCloudInitUserData);
+
+  if (cloudInitVolume) {
+    // make sure volume is used by disk
+    const disks = getDisks(vm);
+    if (disks.find((disk) => disk.name === cloudInitVolume.name)) {
+      return cloudInitVolume;
+    }
+  }
+  return null;
+};
+
+export const getCloudInitUserData = (vm: VMKind) =>
+  getVolumeCloudInitUserData(getCloudInitVolume(vm));
+
+export const hasAutoAttachPodInterface = (vm: VMKind, defaultValue = false) =>
+  _.get(vm, 'spec.template.spec.domain.devices.autoattachPodInterface', defaultValue);
diff --git a/frontend/packages/kubevirt-plugin/src/selectors/vm/volume.ts b/frontend/packages/kubevirt-plugin/src/selectors/vm/volume.ts
index 5e3fa5acb51..bf207df2f45 100644
--- a/frontend/packages/kubevirt-plugin/src/selectors/vm/volume.ts
+++ b/frontend/packages/kubevirt-plugin/src/selectors/vm/volume.ts
@@ -3,3 +3,5 @@ import * as _ from 'lodash';
 export const getVolumePersistentVolumeClaimName = (volume) =>
   _.get(volume, 'persistentVolumeClaim.claimName');
 export const getVolumeDataVolumeName = (volume) => _.get(volume, 'dataVolume.name');
+
+export const getVolumeCloudInitUserData = (volume) => _.get(volume, 'cloudInitNoCloud.userData');
diff --git a/frontend/packages/kubevirt-plugin/src/types/dv/index.ts b/frontend/packages/kubevirt-plugin/src/types/dv/index.ts
new file mode 100644
index 00000000000..2c2203b4049
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/types/dv/index.ts
@@ -0,0 +1,6 @@
+export enum DataVolumeSource {
+  BLANK = 'BLANK',
+  URL = 'URL',
+  PVC = 'PVC',
+  UNKNOWN = 'UNKNOWN',
+}
diff --git a/frontend/packages/kubevirt-plugin/src/types/vm/index.ts b/frontend/packages/kubevirt-plugin/src/types/vm/index.ts
index 980e5bd770b..b5a78ea6b0f 100644
--- a/frontend/packages/kubevirt-plugin/src/types/vm/index.ts
+++ b/frontend/packages/kubevirt-plugin/src/types/vm/index.ts
@@ -72,3 +72,12 @@ export type CPURaw =
       threads: string;
     }
   | string;
+
+export enum ProvisionSource {
+  PXE = 'PXE',
+  CONTAINER = 'Container',
+  URL = 'URL',
+  IMPORT = 'Import',
+  CLONED_DISK = 'Cloned Disk', // PVC or upload image to PVC
+  UNKNOWN = 'Unknown',
+}
diff --git a/frontend/packages/kubevirt-plugin/src/utils/grammar.ts b/frontend/packages/kubevirt-plugin/src/utils/grammar.ts
index 8149b337877..779a455f1b0 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/grammar.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/grammar.ts
@@ -16,7 +16,9 @@ export const makeSentence = (sentence: string, capitalize = true) => {
 
 export const addMissingSubject = (sentence: string, subject: string) => {
   const c = sentence ? sentence.charAt(0) : '';
-  return c.toLowerCase() === c.toUpperCase() || c.toLowerCase() !== c
-    ? sentence
-    : `${_.capitalize(subject)} ${sentence}`;
+  if (c.toLowerCase() === c.toUpperCase() || c.toLowerCase() !== c) {
+    // c is an upper case letter
+    return sentence;
+  }
+  return subject ? `${_.capitalize(subject)} ${sentence}` : sentence;
 };
diff --git a/frontend/packages/kubevirt-plugin/src/utils/immutable.ts b/frontend/packages/kubevirt-plugin/src/utils/immutable.ts
new file mode 100644
index 00000000000..4732feaf434
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/immutable.ts
@@ -0,0 +1,20 @@
+import { List } from 'immutable';
+
+export const concatImmutableLists = (...args) =>
+  args.filter((list) => list).reduce((acc, nextArray) => acc.concat(nextArray), List());
+
+export const immutableListToShallowJS = (list, defaultValue = []) =>
+  list ? list.toArray().map((p) => p.toJSON()) : defaultValue;
+
+export const hasTruthyValue = (obj) => !!(obj && !!obj.find((value) => value));
+
+export const iGet = (obj, key: string, defaultValue = undefined) =>
+  obj ? obj.get(key, defaultValue) : defaultValue;
+
+export const iGetIn = (obj, path: string[], defaultValue = undefined) =>
+  obj ? obj.getIn(path, defaultValue) : defaultValue;
+
+export const iGetIsLoaded = (result): boolean => iGet(result, 'loaded', false);
+
+export const iGetLoadedData = (result, defaultValue = undefined) =>
+  iGetIsLoaded(result) && !iGet(result, 'loadError') ? iGet(result, 'data') : defaultValue;
diff --git a/frontend/packages/kubevirt-plugin/src/utils/index.ts b/frontend/packages/kubevirt-plugin/src/utils/index.ts
index 0c48b007e50..4d029263cc3 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/index.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/index.ts
@@ -1,6 +1,12 @@
 import * as _ from 'lodash';
 import { FirehoseResult } from '@console/internal/components/utils';
-import { K8sKind, K8sResourceKind, OwnerReference } from '@console/internal/module/k8s';
+import {
+  K8sKind,
+  K8sResourceKind,
+  OwnerReference,
+  MatchExpression,
+} from '@console/internal/module/k8s';
+import { NamespaceModel, ProjectModel } from '@console/internal/models';
 import {
   getName,
   getNamespace,
@@ -74,3 +80,60 @@ export const compareOwnerReference = (obj: OwnerReference, otherObj: OwnerRefere
 
 export const isCPUEqual = (a: CPU, b: CPU) =>
   a.sockets === b.sockets && a.cores === b.cores && a.threads === b.threads;
+
+export const getResource = (
+  model: K8sResourceKind,
+  {
+    name,
+    namespaced = true,
+    namespace,
+    isList = true,
+    matchLabels,
+    matchExpressions,
+    prop,
+    fieldSelector,
+    optional,
+  }: {
+    name?: string;
+    namespace?: string;
+    namespaced?: boolean;
+    isList?: boolean;
+    matchLabels?: { [key: string]: string };
+    matchExpressions?: MatchExpression[];
+    prop?: string;
+    fieldSelector?: string;
+    isImmutable?: boolean;
+    optional?: boolean;
+  } = {
+    namespaced: true,
+    isList: true,
+  },
+) => {
+  const m = model.kind === NamespaceModel.kind ? ProjectModel : model;
+  const res: any = {
+    // non-admin user cannot list namespaces (k8s wont return only namespaces available to user but 403 forbidden, ).
+    // Instead we need to use ProjectModel which will return available projects (namespaces)
+    kind: m.kind,
+    model: m,
+    namespaced,
+    namespace,
+    isList,
+    prop: prop || model.kind,
+    optional,
+  };
+
+  if (name) {
+    res.name = name;
+  }
+  if (matchLabels) {
+    res.selector = { matchLabels };
+  }
+  if (matchExpressions) {
+    res.selector = { matchExpressions };
+  }
+  if (fieldSelector) {
+    res.fieldSelector = fieldSelector;
+  }
+
+  return res;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/utils/redux/common.tsx b/frontend/packages/kubevirt-plugin/src/utils/redux/common.tsx
new file mode 100644
index 00000000000..f2b23986d68
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/redux/common.tsx
@@ -0,0 +1,17 @@
+import * as React from 'react';
+
+let lastID = 0;
+
+export const getNextReduxID = () => String(++lastID);
+
+export const withReduxID = <T, _>(Component: React.ComponentType<T>) => {
+  class IdComponent extends React.Component<T> {
+    id = getNextReduxID();
+
+    render() {
+      return <Component reduxID={this.id} {...this.props} />;
+    }
+  }
+
+  return IdComponent;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/utils/redux/reducers.ts b/frontend/packages/kubevirt-plugin/src/utils/redux/reducers.ts
new file mode 100644
index 00000000000..d5af1264ceb
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/redux/reducers.ts
@@ -0,0 +1,6 @@
+import { combineReducers } from 'redux';
+import createVmWizardReducers from '../../components/create-vm-wizard/redux/reducers';
+
+export const kubevirtReducer = combineReducers({
+  createVmWizards: createVmWizardReducers,
+});
diff --git a/frontend/packages/kubevirt-plugin/src/utils/sort.ts b/frontend/packages/kubevirt-plugin/src/utils/sort.ts
new file mode 100644
index 00000000000..08810ebad51
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/sort.ts
@@ -0,0 +1,38 @@
+import * as _ from 'lodash';
+import { CUSTOM_FLAVOR } from '../constants/vm';
+
+const FLAVOR_ORDER = {
+  tiny: 0,
+  small: 1,
+  medium: 2,
+  large: 3,
+};
+
+export const flavorSort = (array = []) =>
+  array.sort((a, b) => {
+    if (a === CUSTOM_FLAVOR) {
+      return 1;
+    }
+    if (b === CUSTOM_FLAVOR) {
+      return -1;
+    }
+    const resolvedFlavorA = FLAVOR_ORDER[a];
+    const resolvedFlavorB = FLAVOR_ORDER[b];
+    if (resolvedFlavorA == null && resolvedFlavorB == null) {
+      return a.toLowerCase().localeCompare(b.toLowerCase());
+    }
+    if (resolvedFlavorA == null) {
+      return 1;
+    }
+    if (resolvedFlavorB == null) {
+      return -1;
+    }
+    return resolvedFlavorA - resolvedFlavorB;
+  });
+
+export const ignoreCaseSort = (array = [], byPath: string[] = undefined) =>
+  array.sort((a, b) =>
+    (byPath ? _.get(a, byPath, '') : a)
+      .toLowerCase()
+      .localeCompare((byPath ? _.get(b, byPath, '') : b).toLowerCase()),
+  );
diff --git a/frontend/packages/kubevirt-plugin/src/utils/strings.ts b/frontend/packages/kubevirt-plugin/src/utils/strings.ts
new file mode 100644
index 00000000000..88768ef1868
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/strings.ts
@@ -0,0 +1,8 @@
+export const COULD_NOT_LOAD_DATA = 'Could not load data';
+
+export const ERROR = 'Error';
+export const CREATED = 'created';
+export const CREATED_WITH_FAILED_CLEANUP = 'created & failed to clean up';
+export const CREATED_WITH_CLEANUP = 'created & cleaned up';
+export const FAILED_TO_CREATE = 'failed to create';
+export const FAILED_TO_PATCH = 'failed to patch';
diff --git a/frontend/packages/kubevirt-plugin/src/utils/types.ts b/frontend/packages/kubevirt-plugin/src/utils/types.ts
new file mode 100644
index 00000000000..cedac68c3aa
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/types.ts
@@ -0,0 +1 @@
+export const getStringEnumValues = <T>(enu) => Object.keys(enu).map((k) => enu[k] as T);
diff --git a/frontend/packages/kubevirt-plugin/src/utils/url.ts b/frontend/packages/kubevirt-plugin/src/utils/url.ts
index 022b5c468f2..622edef2c6d 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/url.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/url.ts
@@ -7,3 +7,11 @@ export const getConsoleApiBase = () => {
 };
 
 export const isConnectionEncrypted = () => window.location.protocol === 'https:';
+
+export const parseUrl = (url: string) => {
+  try {
+    return new URL(url);
+  } catch (e) {
+    return null;
+  }
+};
diff --git a/frontend/packages/kubevirt-plugin/src/utils/utils.ts b/frontend/packages/kubevirt-plugin/src/utils/utils.ts
new file mode 100644
index 00000000000..70cd6b4e82d
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/utils.ts
@@ -0,0 +1,19 @@
+import { referenceForModel } from '@console/internal/module/k8s';
+import { getName, getNamespace } from '@console/shared';
+
+export const getSequence = (from, to) => Array.from({ length: to - from + 1 }, (v, i) => i + from);
+
+export const setNativeValue = (element, value) => {
+  const valueSetter = Object.getOwnPropertyDescriptor(element, 'value').set;
+  const prototype = Object.getPrototypeOf(element);
+  const prototypeValueSetter = Object.getOwnPropertyDescriptor(prototype, 'value').set;
+
+  if (valueSetter && valueSetter !== prototypeValueSetter) {
+    prototypeValueSetter.call(element, value);
+  } else {
+    valueSetter.call(element, value);
+  }
+};
+
+export const getFullResourceId = (obj) =>
+  `${referenceForModel(obj)}~${getNamespace(obj)}~${getName(obj)}`;
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/common.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/common.ts
index 02a887bb49b..2d5373de38d 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/common.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/common.ts
@@ -1,11 +1,18 @@
-import { joinGrammaticallyListOfItems, makeSentence } from '../grammar';
+import { getName, getNamespace } from '@console/shared';
+import * as _ from 'lodash';
+import { addMissingSubject, joinGrammaticallyListOfItems, makeSentence } from '../grammar';
+import { parseUrl } from '../url';
 import {
   DNS1123_END_ERROR,
   DNS1123_START_END_ERROR,
   DNS1123_START_ERROR,
   DNS1123_TOO_LONG_ERROR,
   EMPTY_ERROR,
+  END_WHITESPACE_ERROR,
+  START_WHITESPACE_ERROR,
+  URL_INVALID_ERROR,
 } from './strings';
+import { ValidationErrorType, ValidationObject } from './types';
 
 const alphanumericRegex = '[a-zA-Z0-9]';
 
@@ -15,13 +22,6 @@ const DNS_1123_OFFENDING_CHARACTERS = {
   _: 'underscore',
 };
 
-export enum ValidationErrorType {
-  Error = 'error',
-  TrivialError = 'trivial-error',
-  Warn = 'warning',
-  Info = 'info',
-}
-
 export const getValidationObject = (
   message: string,
   type: ValidationErrorType = ValidationErrorType.Error,
@@ -44,10 +44,41 @@ export const getValidationErrorMessage = (validationObject: ValidationObject): s
   );
 };
 
-// DNS-1123 subdomain
-export const validateDNS1123SubdomainValue = (value: string): ValidationObject => {
+export const isPositiveNumber = (value) => value && value.toString().match(/^[1-9]\d*$/);
+
+export const validateEntityAlreadyExists = (
+  name,
+  namespace,
+  entities,
+  { errorMessage, subject } = { errorMessage: undefined, subject: undefined },
+): ValidationObject => {
+  const exists =
+    entities &&
+    entities.some((entity) => getName(entity) === name && getNamespace(entity) === namespace);
+  return exists ? getValidationObject(addMissingSubject(errorMessage, subject)) : null;
+};
+
+export const validateEmptyValue = (
+  value: string,
+  { subject } = { subject: undefined },
+): ValidationObject => {
   if (!value) {
-    return getValidationObject(makeSentence(EMPTY_ERROR, false), ValidationErrorType.TrivialError);
+    return getValidationObject(
+      addMissingSubject(makeSentence(EMPTY_ERROR, false), subject),
+      ValidationErrorType.TrivialError,
+    );
+  }
+  return null;
+};
+
+// DNS-1123 subdomain
+export const validateDNS1123SubdomainValue = (
+  value: string,
+  { subject } = { subject: undefined },
+): ValidationObject => {
+  const emptyError = validateEmptyValue(value, { subject });
+  if (emptyError) {
+    return emptyError;
   }
 
   const forbiddenCharacters = new Set<string>();
@@ -99,10 +130,55 @@ export const validateDNS1123SubdomainValue = (value: string): ValidationObject =
     result = result ? `${result} ${forbiddenCharsSentence}` : forbiddenCharsSentence;
   }
 
-  return result && getValidationObject(result, ValidationErrorType.Error);
+  return (
+    result && getValidationObject(addMissingSubject(result, subject), ValidationErrorType.Error)
+  );
+};
+
+export const validatePositiveInteger = (
+  value: string,
+  { subject } = { subject: undefined },
+): ValidationObject => {
+  const emptyError = validateEmptyValue(value, { subject });
+  if (emptyError) {
+    return emptyError;
+  }
+  return isPositiveNumber(value) ? null : getValidationObject('must be positive integer');
+};
+
+export const validateTrim = (
+  value: string,
+  { subject }: { subject: string } = { subject: undefined },
+) => {
+  const emptyError = validateEmptyValue(value, { subject });
+  if (emptyError) {
+    return emptyError;
+  }
+
+  let resultErrror;
+  if (_.trimStart(value).length !== value.length) {
+    resultErrror = START_WHITESPACE_ERROR;
+  }
+
+  if (_.trimEnd(value).length !== value.length) {
+    resultErrror = END_WHITESPACE_ERROR;
+  }
+
+  return resultErrror
+    ? getValidationObject(addMissingSubject(resultErrror, subject), ValidationErrorType.Error)
+    : null;
 };
 
-export type ValidationObject = {
-  message: string;
-  type?: ValidationErrorType;
+export const validateURL = (
+  value: string,
+  { subject }: { subject: string } = { subject: undefined },
+) => {
+  const trimError = validateTrim(value, { subject });
+  if (trimError) {
+    return trimError;
+  }
+
+  return parseUrl(value)
+    ? null
+    : getValidationObject(addMissingSubject(URL_INVALID_ERROR, subject));
 };
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/strings.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/strings.ts
index f7f5e187e53..189e539322e 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/strings.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/strings.ts
@@ -1,5 +1,8 @@
 export const GENERAL_ERROR_MSG = 'An error occurred. Please try again';
 export const EMPTY_ERROR = 'cannot be empty';
+export const START_WHITESPACE_ERROR = 'cannot start with whitespace characters';
+export const END_WHITESPACE_ERROR = 'cannot end with whitespace characters';
+export const URL_INVALID_ERROR = 'has to be a valid URL';
 
 export const DNS1123_START_END_ERROR = 'has to start/end with alphanumeric characters';
 export const DNS1123_START_ERROR = 'has to start with alphanumeric character';
@@ -8,6 +11,7 @@ export const DNS1123_TOO_LONG_ERROR = 'cannot have more than 253 characters';
 
 export const VIRTUAL_MACHINE_EXISTS =
   'is already used by another virtual machine in this namespace';
+export const VIRTUAL_MACHINE_TEMPLATE_EXISTS = 'is already used in another template';
 
 export const MAC_ADDRESS_INVALID_ERROR = 'Invalid MAC address format';
 export const NIC_NAME_EXISTS = 'Interface with this name already exists';
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/types.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/types.ts
new file mode 100644
index 00000000000..457c31bf8c1
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/types.ts
@@ -0,0 +1,11 @@
+export enum ValidationErrorType {
+  Error = 'error',
+  TrivialError = 'trivial-error',
+  Warn = 'warning',
+  Info = 'info',
+}
+
+export type ValidationObject = {
+  message: string;
+  type?: ValidationErrorType;
+};
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/disk.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/disk.ts
index 79c0f3ac3a6..b119bafb1b6 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/disk.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/disk.ts
@@ -1,6 +1,7 @@
 import { EntityMap } from '@console/shared';
-import { validateDNS1123SubdomainValue, ValidationErrorType } from '../common';
+import { validateDNS1123SubdomainValue } from '../common';
 import { addMissingSubject } from '../../grammar';
+import { ValidationErrorType } from '../types';
 
 export const validateDiskName = (name: string, diskLookup: EntityMap<any>) => {
   let validation = validateDNS1123SubdomainValue(name);
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/index.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/index.ts
index 5d5a3051188..a96eca0ceca 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/index.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/index.ts
@@ -1,3 +1,4 @@
 export * from './disk';
 export * from './nic';
 export * from './validations';
+export * from './vm';
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/nic.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/nic.ts
index a257e090532..621509898e3 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/nic.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/nic.ts
@@ -1,7 +1,8 @@
 import { EntityMap } from '@console/shared';
-import { getValidationObject, validateDNS1123SubdomainValue, ValidationObject } from '../common';
+import { getValidationObject, validateDNS1123SubdomainValue } from '../common';
 import { addMissingSubject, makeSentence } from '../../grammar';
 import { MAC_ADDRESS_INVALID_ERROR, NIC_NAME_EXISTS } from '../strings';
+import { ValidationObject } from '../types';
 import { isValidMAC } from './validations';
 
 export const validateNicName = (
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/validations.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/validations.ts
index 8f87862d80b..1d915184833 100644
--- a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/validations.ts
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/validations.ts
@@ -1,25 +1,3 @@
-import { getName, getNamespace } from '@console/shared';
-import { VIRTUAL_MACHINE_EXISTS } from '../strings';
-import {
-  getValidationObject,
-  validateDNS1123SubdomainValue,
-  ValidationErrorType,
-  ValidationObject,
-} from '../common';
-import { addMissingSubject } from '../../grammar';
-
-export const vmAlreadyExists = (name, namespace, vms): ValidationObject => {
-  const exists = vms && vms.some((vm) => getNamespace(vm) === namespace && getName(vm) === name);
-  return exists ? getValidationObject(addMissingSubject(VIRTUAL_MACHINE_EXISTS, 'Name')) : null;
-};
-
-export const validateVmName = (value, namespace, vms): ValidationObject => {
-  const dnsValidation = validateDNS1123SubdomainValue(value);
-  return dnsValidation && dnsValidation.type === ValidationErrorType.Error
-    ? getValidationObject(addMissingSubject(dnsValidation.message, 'Name'), dnsValidation.type)
-    : vmAlreadyExists(value, namespace, vms);
-};
-
 const HEXCH_REGEX = '[0-9A-Fa-f]';
 const MAC_REGEX_COLON_DELIMITER = new RegExp(
   `^((${HEXCH_REGEX}{2}[:]){19}${HEXCH_REGEX}{2})$|` + // 01:23:45:67:89:ab:cd:ef:00:00:01:23:45:67:89:ab:cd:ef:00:00
diff --git a/frontend/packages/kubevirt-plugin/src/utils/validations/vm/vm.ts b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/vm.ts
new file mode 100644
index 00000000000..46f85cb3bf0
--- /dev/null
+++ b/frontend/packages/kubevirt-plugin/src/utils/validations/vm/vm.ts
@@ -0,0 +1,38 @@
+import { K8sResourceKind, TemplateKind } from '@console/internal/module/k8s';
+import { ValidationErrorType, ValidationObject } from '../types';
+import {
+  getValidationObject,
+  validateDNS1123SubdomainValue,
+  validateEntityAlreadyExists,
+} from '../common';
+import { getTemplateProvisionSource } from '../../../selectors/vm-template/combined';
+import { ProvisionSource } from '../../../types/vm';
+
+export const validateVmLikeEntityName = (
+  value: string,
+  namespace: string,
+  vmLikeEntities,
+  { existsErrorMessage, subject }: { existsErrorMessage: string; subject: string } = {
+    existsErrorMessage: undefined,
+    subject: undefined,
+  },
+): ValidationObject => {
+  const dnsValidation = validateDNS1123SubdomainValue(value, { subject });
+  return dnsValidation && dnsValidation.type === ValidationErrorType.Error
+    ? dnsValidation
+    : validateEntityAlreadyExists(value, namespace, vmLikeEntities, {
+        errorMessage: existsErrorMessage,
+        subject,
+      });
+};
+
+export const validateUserTemplateProvisionSource = (
+  userTemplate: TemplateKind,
+  dataVolumes: K8sResourceKind[],
+): ValidationObject => {
+  const provisionSource = getTemplateProvisionSource(userTemplate, dataVolumes);
+
+  return provisionSource.type === ProvisionSource.UNKNOWN
+    ? getValidationObject(`Could not select Provision Source. ${provisionSource.error}`)
+    : null;
+};