diff --git a/public/locales/en.json b/public/locales/en.json
index dd5c315b..e24cb086 100644
--- a/public/locales/en.json
+++ b/public/locales/en.json
@@ -90,6 +90,9 @@
     "menuDownload": "Download",
     "menuCopy": "Copy to clipboard"
   },
+  "ComponentsSelection": {
+    "chooseVersion": "Please select version"
+  },
   "IllustratedBanner": {
     "titleMessage": "No Managed Control Planes found",
     "subtitleMessage": "Get started by creating your first Managed Control Plane.",
diff --git a/src/components/ComponentsSelection/ComponentsSelection.tsx b/src/components/ComponentsSelection/ComponentsSelection.tsx
index 602602e3..b08fbbec 100644
--- a/src/components/ComponentsSelection/ComponentsSelection.tsx
+++ b/src/components/ComponentsSelection/ComponentsSelection.tsx
@@ -22,13 +22,19 @@ import { Infobox } from '../Ui/Infobox/Infobox.tsx';
 import { useTranslation } from 'react-i18next';
 import { ComponentsListItem } from '../../lib/api/types/crate/createManagedControlPlane.ts';
 import { getSelectedComponents } from './ComponentsSelectionContainer.tsx';
+import IllustratedError from '../Shared/IllustratedError.tsx';
 
 export interface ComponentsSelectionProps {
   componentsList: ComponentsListItem[];
   setComponentsList: (components: ComponentsListItem[]) => void;
+  templateDefaultsError?: string;
 }
 
-export const ComponentsSelection: React.FC<ComponentsSelectionProps> = ({ componentsList, setComponentsList }) => {
+export const ComponentsSelection: React.FC<ComponentsSelectionProps> = ({
+  componentsList,
+  setComponentsList,
+  templateDefaultsError,
+}) => {
   const [searchTerm, setSearchTerm] = useState('');
   const { t } = useTranslation();
 
@@ -132,8 +138,19 @@ export const ComponentsSelection: React.FC<ComponentsSelectionProps> = ({ compon
                       value={component.selectedVersion}
                       disabled={!component.isSelected || providerDisabled}
                       aria-label={`${component.name} version`}
+                      valueState={component.isSelected && !component.selectedVersion ? 'Negative' : 'None'}
+                      valueStateMessage={
+                        component.isSelected && !component.selectedVersion ? (
+                          <span>{t('ComponentsSelection.chooseVersion')}</span>
+                        ) : undefined
+                      }
                       onChange={handleVersionChange}
                     >
+                      {!component.selectedVersion && (
+                        <Option key="__placeholder" data-version="" data-name={component.name} selected>
+                          {t('ComponentsSelection.chooseVersion')}
+                        </Option>
+                      )}
                       {component.versions.map((version) => (
                         <Option
                           key={version}
@@ -155,7 +172,14 @@ export const ComponentsSelection: React.FC<ComponentsSelectionProps> = ({ compon
             </Infobox>
           )}
         </div>
+
         <div data-layout-span="XL4 L4 M4 S4">
+          {templateDefaultsError ? (
+            <div style={{ marginBottom: 8 }}>
+              <IllustratedError title={templateDefaultsError} compact />
+            </div>
+          ) : null}
+
           {selectedComponents.length > 0 ? (
             <List headerText={t('componentsSelection.selectedComponents')}>
               {selectedComponents.map((component) => (
diff --git a/src/components/ComponentsSelection/ComponentsSelectionContainer.tsx b/src/components/ComponentsSelection/ComponentsSelectionContainer.tsx
index a836b5e1..998f8b7b 100644
--- a/src/components/ComponentsSelection/ComponentsSelectionContainer.tsx
+++ b/src/components/ComponentsSelection/ComponentsSelectionContainer.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
 import { ComponentsSelection } from './ComponentsSelection.tsx';
 
 import IllustratedError from '../Shared/IllustratedError.tsx';
@@ -9,10 +9,12 @@ import { useApiResource } from '../../lib/api/useApiResource.ts';
 import Loading from '../Shared/Loading.tsx';
 import { ComponentsListItem, removeComponents } from '../../lib/api/types/crate/createManagedControlPlane.ts';
 import { useTranslation } from 'react-i18next';
+import { ManagedControlPlaneTemplate } from '../../lib/api/types/templates/mcpTemplate.ts';
 
 export interface ComponentsSelectionProps {
   componentsList: ComponentsListItem[];
   setComponentsList: (components: ComponentsListItem[]) => void;
+  managedControlPlaneTemplate?: ManagedControlPlaneTemplate;
 }
 
 /**
@@ -30,39 +32,82 @@ export const getSelectedComponents = (components: ComponentsListItem[]) => {
   });
 };
 
+type TemplateDefaultComponent = {
+  name: string;
+  version: string;
+  removable?: boolean;
+  versionChangeable?: boolean;
+};
+
 export const ComponentsSelectionContainer: React.FC<ComponentsSelectionProps> = ({
   setComponentsList,
   componentsList,
+  managedControlPlaneTemplate,
 }) => {
   const { data: availableManagedComponentsListData, error, isLoading } = useApiResource(ListManagedComponents());
   const { t } = useTranslation();
   const initialized = useRef(false);
+  const [templateDefaultsError, setTemplateDefaultsError] = useState<string | null>(null);
+  const defaultComponents = useMemo<TemplateDefaultComponent[]>(
+    () => managedControlPlaneTemplate?.spec?.spec?.components?.defaultComponents ?? [],
+    [managedControlPlaneTemplate],
+  );
 
   useEffect(() => {
-    if (
-      initialized.current ||
-      !availableManagedComponentsListData?.items ||
-      availableManagedComponentsListData.items.length === 0
-    ) {
+    const items = availableManagedComponentsListData?.items ?? [];
+
+    if (!items.length) {
+      if (!initialized.current) return;
+      setTemplateDefaultsError(null);
+      return;
+    }
+
+    if (!initialized.current) {
+      const newComponentsList = items
+        .map((item) => {
+          const versions = sortVersions(item.status.versions);
+          const template = defaultComponents.find((dc) => dc.name === item.metadata.name);
+          const templateVersion = template?.version;
+          const selectedVersion = template
+            ? templateVersion && versions.includes(templateVersion)
+              ? templateVersion
+              : ''
+            : (versions[0] ?? '');
+          return {
+            name: item.metadata.name,
+            versions,
+            selectedVersion,
+            isSelected: !!template,
+            documentationUrl: '',
+          };
+        })
+        .filter((component) => !removeComponents.find((item) => item === component.name));
+
+      setComponentsList(newComponentsList);
+      initialized.current = true;
+    }
+
+    if (!defaultComponents.length) {
+      setTemplateDefaultsError(null);
       return;
     }
 
-    const newComponentsList = availableManagedComponentsListData.items
-      .map((item) => {
-        const versions = sortVersions(item.status.versions);
-        return {
-          name: item.metadata.name,
-          versions,
-          selectedVersion: versions[0] ?? '',
-          isSelected: false,
-          documentationUrl: '',
-        };
-      })
-      .filter((component) => !removeComponents.find((item) => item === component.name));
-
-    setComponentsList(newComponentsList);
-    initialized.current = true;
-  }, [availableManagedComponentsListData, setComponentsList]);
+    const errors: string[] = [];
+    defaultComponents.forEach((dc: TemplateDefaultComponent) => {
+      if (!dc?.name) return;
+      const item = items.find((it) => it.metadata.name === dc.name);
+      if (!item) {
+        errors.push(`Component "${dc.name}" from template is not available.`);
+        return;
+      }
+      const versions: string[] = Array.isArray(item.status?.versions) ? item.status.versions : [];
+      if (dc.version && !versions.includes(dc.version)) {
+        errors.push(`Component "${dc.name}" version "${dc.version}" from template is not available.`);
+      }
+    });
+
+    setTemplateDefaultsError(errors.length ? errors.join('\n') : null);
+  }, [availableManagedComponentsListData, defaultComponents, setComponentsList]);
 
   if (isLoading) {
     return <Loading />;
@@ -77,5 +122,11 @@ export const ComponentsSelectionContainer: React.FC<ComponentsSelectionProps> =
     return <IllustratedError title={t('componentsSelection.cannotLoad')} compact={true} />;
   }
 
-  return <ComponentsSelection componentsList={componentsList} setComponentsList={setComponentsList} />;
+  return (
+    <ComponentsSelection
+      componentsList={componentsList}
+      setComponentsList={setComponentsList}
+      templateDefaultsError={templateDefaultsError || undefined}
+    />
+  );
 };
diff --git a/src/components/ControlPlanes/ControlPlanesListMenu.tsx b/src/components/ControlPlanes/ControlPlanesListMenu.tsx
index a9bb438b..f5398673 100644
--- a/src/components/ControlPlanes/ControlPlanesListMenu.tsx
+++ b/src/components/ControlPlanes/ControlPlanesListMenu.tsx
@@ -5,21 +5,27 @@ import '@ui5/webcomponents-icons/dist/copy';
 import '@ui5/webcomponents-icons/dist/accept';
 
 import { useTranslation } from 'react-i18next';
+import { ManagedControlPlaneTemplate } from '../../lib/api/types/templates/mcpTemplate.ts';
 
 type ControlPlanesListMenuProps = {
   setDialogDeleteWsIsOpen: Dispatch<SetStateAction<boolean>>;
   setIsCreateManagedControlPlaneWizardOpen: Dispatch<SetStateAction<boolean>>;
+  setInitialTemplateName: Dispatch<SetStateAction<string | undefined>>;
 };
 
 export const ControlPlanesListMenu: FC<ControlPlanesListMenuProps> = ({
   setDialogDeleteWsIsOpen,
   setIsCreateManagedControlPlaneWizardOpen,
+  setInitialTemplateName,
 }) => {
   const popoverRef = useRef<MenuDomRef>(null);
   const [open, setOpen] = useState(false);
 
   const { t } = useTranslation();
 
+  // Here we will pass template list from OnboardingAPI
+  const allTemplates: ManagedControlPlaneTemplate[] = [];
+
   const handleOpenerClick = (e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => {
     if (popoverRef.current && e.currentTarget) {
       popoverRef.current.opener = e.currentTarget as HTMLElement;
@@ -34,14 +40,20 @@ export const ControlPlanesListMenu: FC<ControlPlanesListMenuProps> = ({
         ref={popoverRef}
         open={open}
         onItemClick={(event) => {
-          const action = (event.detail.item as HTMLElement).dataset.action;
+          const item = event.detail.item as HTMLElement;
+          const action = item.dataset.action;
           if (action === 'newManagedControlPlane') {
+            setInitialTemplateName(undefined);
+            setIsCreateManagedControlPlaneWizardOpen(true);
+          }
+          if (action === 'newManagedControlPlaneWithTemplate') {
+            const tplName = item.dataset.templateName || undefined;
+            setInitialTemplateName(tplName);
             setIsCreateManagedControlPlaneWizardOpen(true);
           }
           if (action === 'deleteWorkspace') {
             setDialogDeleteWsIsOpen(true);
           }
-
           setOpen(false);
         }}
       >
@@ -51,6 +63,17 @@ export const ControlPlanesListMenu: FC<ControlPlanesListMenuProps> = ({
           data-action="newManagedControlPlane"
           icon="add"
         />
+        {allTemplates.map((tpl) => (
+          <MenuItem
+            key={`tpl-${tpl.metadata.name}`}
+            text={tpl.metadata.name}
+            title={tpl.metadata.descriptionText || ''}
+            data-action="newManagedControlPlaneWithTemplate"
+            data-template-name={tpl.metadata.name}
+            icon="document-text"
+          />
+        ))}
+
         <MenuItem
           key={'delete'}
           text={t('ControlPlaneListToolbar.deleteWorkspace')}
diff --git a/src/components/ControlPlanes/List/ControlPlaneListWorkspaceGridTile.tsx b/src/components/ControlPlanes/List/ControlPlaneListWorkspaceGridTile.tsx
index c7469c7f..b3bf9556 100644
--- a/src/components/ControlPlanes/List/ControlPlaneListWorkspaceGridTile.tsx
+++ b/src/components/ControlPlanes/List/ControlPlaneListWorkspaceGridTile.tsx
@@ -5,7 +5,7 @@ import '@ui5/webcomponents-icons/dist/delete';
 import { CopyButton } from '../../Shared/CopyButton.tsx';
 import { ControlPlaneCard } from '../ControlPlaneCard/ControlPlaneCard.tsx';
 import { ListWorkspacesType, isWorkspaceReady } from '../../../lib/api/types/crate/listWorkspaces.ts';
-import { useState } from 'react';
+import { useMemo, useState } from 'react';
 import { MembersAvatarView } from './MembersAvatarView.tsx';
 import { DeleteWorkspaceResource, DeleteWorkspaceType } from '../../../lib/api/types/crate/deleteWorkspace.ts';
 import { useApiResourceMutation, useApiResource } from '../../../lib/api/useApiResource.ts';
@@ -32,6 +32,7 @@ interface Props {
 
 export function ControlPlaneListWorkspaceGridTile({ projectName, workspace }: Props) {
   const [isCreateManagedControlPlaneWizardOpen, setIsCreateManagedControlPlaneWizardOpen] = useState(false);
+  const [initialTemplateName, setInitialTemplateName] = useState<string | undefined>(undefined);
   const workspaceName = workspace.metadata.name;
   const workspaceDisplayName = workspace.metadata.annotations?.[DISPLAY_NAME_ANNOTATION] || '';
   const showDisplayName = workspaceDisplayName.length > 0;
@@ -68,6 +69,24 @@ export function ControlPlaneListWorkspaceGridTile({ projectName, workspace }: Pr
     return null;
   }
 
+  const uniqueMembers = useMemo(() => {
+    const seenKeys = new Set<string>();
+    const fallbackNamespace = workspace.status?.namespace ?? '';
+
+    return (workspace.spec.members ?? []).filter((member: { name?: string; namespace?: string }) => {
+      const memberNamespace = member?.namespace ?? fallbackNamespace;
+      const memberName = String(member?.name ?? '')
+        .trim()
+        .toLowerCase();
+      if (!memberName) return false;
+
+      const dedupeKey = `${memberNamespace}::${memberName}`;
+      if (seenKeys.has(dedupeKey)) return false;
+      seenKeys.add(dedupeKey);
+      return true;
+    });
+  }, [workspace.spec.members, workspace.status?.namespace]);
+
   return (
     <>
       <ObjectPageSection
@@ -98,7 +117,7 @@ export function ControlPlaneListWorkspaceGridTile({ projectName, workspace }: Pr
 
               <CopyButton text={workspace.status?.namespace || '-'} style={{ justifyContent: 'start' }} />
 
-              <MembersAvatarView members={workspace.spec.members} project={projectName} workspace={workspaceName} />
+              <MembersAvatarView members={uniqueMembers} project={projectName} workspace={workspaceName} />
               <FlexBox justifyContent={'SpaceBetween'} gap={10}>
                 <YamlViewButtonWithLoader
                   workspaceName={workspace.metadata.namespace}
@@ -108,6 +127,7 @@ export function ControlPlaneListWorkspaceGridTile({ projectName, workspace }: Pr
                 <ControlPlanesListMenu
                   setDialogDeleteWsIsOpen={setDialogDeleteWsIsOpen}
                   setIsCreateManagedControlPlaneWizardOpen={setIsCreateManagedControlPlaneWizardOpen}
+                  setInitialTemplateName={setInitialTemplateName}
                 />
               </FlexBox>
             </div>
@@ -168,6 +188,7 @@ export function ControlPlaneListWorkspaceGridTile({ projectName, workspace }: Pr
         setIsOpen={setIsCreateManagedControlPlaneWizardOpen}
         projectName={projectNamespace}
         workspaceName={workspaceName}
+        initialTemplateName={initialTemplateName}
       />
     </>
   );
diff --git a/src/components/Dialogs/CreateProjectWorkspaceDialog.module.css b/src/components/Dialogs/MetadataForm.module.css
similarity index 50%
rename from src/components/Dialogs/CreateProjectWorkspaceDialog.module.css
rename to src/components/Dialogs/MetadataForm.module.css
index 05707b43..6baa4d23 100644
--- a/src/components/Dialogs/CreateProjectWorkspaceDialog.module.css
+++ b/src/components/Dialogs/MetadataForm.module.css
@@ -1,3 +1,9 @@
+.affixRow {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
 .input {
   width: 100%;
   margin-bottom: 2rem;
diff --git a/src/components/Dialogs/MetadataForm.tsx b/src/components/Dialogs/MetadataForm.tsx
index f8b051ee..ac9ad207 100644
--- a/src/components/Dialogs/MetadataForm.tsx
+++ b/src/components/Dialogs/MetadataForm.tsx
@@ -1,8 +1,19 @@
 import { FieldErrors, UseFormRegister, UseFormSetValue, UseFormWatch } from 'react-hook-form';
 import { CreateDialogProps } from './CreateWorkspaceDialogContainer.tsx';
 import { useTranslation } from 'react-i18next';
-import { Form, FormGroup, Input, Label, Option, Select, SelectDomRef, Ui5CustomEvent } from '@ui5/webcomponents-react';
-import styles from './CreateProjectWorkspaceDialog.module.css';
+import {
+  Form,
+  FormGroup,
+  Input,
+  Label,
+  Option,
+  Select,
+  SelectDomRef,
+  Ui5CustomEvent,
+  InputDomRef,
+} from '@ui5/webcomponents-react';
+
+import styles from './MetadataForm.module.css';
 import React from 'react';
 
 export interface MetadataFormProps {
@@ -12,6 +23,11 @@ export interface MetadataFormProps {
   sideFormContent?: React.ReactNode;
   requireChargingTarget?: boolean;
   watch: UseFormWatch<CreateDialogProps>;
+  disableChargingFields?: boolean;
+  namePrefix?: string;
+  displayNamePrefix?: string;
+  nameSuffix?: string;
+  displayNameSuffix?: string;
 }
 
 interface SelectOption {
@@ -26,42 +42,156 @@ export function MetadataForm({
   setValue,
   sideFormContent,
   requireChargingTarget = false,
+  disableChargingFields = false,
+  namePrefix = '',
+  displayNamePrefix = '',
+  nameSuffix: propNameSuffix = '',
+  displayNameSuffix: propDisplayNameSuffix = '',
 }: MetadataFormProps) {
   const { t } = useTranslation();
+
   const handleChargingTargetTypeChange = (event: Ui5CustomEvent<SelectDomRef, { selectedOption: HTMLElement }>) => {
     const selectedOption = event.detail.selectedOption as HTMLElement;
-    setValue('chargingTargetType', selectedOption.dataset.value);
-    if (selectedOption.dataset.value === '') {
-      setValue('chargingTarget', '');
+    const value = selectedOption.dataset.value ?? '';
+    setValue('chargingTargetType', value, { shouldValidate: true, shouldDirty: true });
+    if (value === '') {
+      setValue('chargingTarget', '', { shouldValidate: true, shouldDirty: true });
     }
   };
+
   const chargingTypes: SelectOption[] = [
     ...(!requireChargingTarget ? [{ label: t('common.notSelected'), value: '' }] : []),
     { label: t('common.btp'), value: 'btp' },
   ];
+
+  const currentChargingTargetType = (watch?.('chargingTargetType') ?? '').toLowerCase();
+
+  const currentName = watch?.('name') ?? '';
+  const currentDisplayName = watch?.('displayName') ?? '';
+
+  const resolvedNamePrefix = (namePrefix || '').trim();
+  const resolvedDisplayNamePrefix = (displayNamePrefix || '').trim();
+  const resolvedNameSuffix = (propNameSuffix || '').trim();
+  const resolvedDisplayNameSuffix = (propDisplayNameSuffix || '').trim();
+
+  const computeCore = (full: string, prefix: string, suffix: string) => {
+    let name = full ?? '';
+    if (prefix && name.startsWith(prefix)) name = name.slice(prefix.length);
+    if (suffix && name.endsWith(suffix)) name = name.slice(0, name.length - suffix.length);
+    return name;
+  };
+
+  const nameCore = computeCore(currentName, resolvedNamePrefix, resolvedNameSuffix);
+  const displayNameCore = computeCore(currentDisplayName, resolvedDisplayNamePrefix, resolvedDisplayNameSuffix);
+
+  const onNameCoreInput = (e: Ui5CustomEvent<InputDomRef, { value: string }>) => {
+    const middle = typeof e.detail?.value === 'string' ? e.detail.value : (e.target.value ?? '');
+    setValue('name', `${resolvedNamePrefix}${middle}${resolvedNameSuffix}`, {
+      shouldValidate: true,
+      shouldDirty: true,
+    });
+  };
+
+  const onDisplayNameCoreInput = (e: Ui5CustomEvent<InputDomRef, { value: string }>) => {
+    const middle = typeof e.detail?.value === 'string' ? e.detail.value : (e.target.value ?? '');
+    setValue('displayName', `${resolvedDisplayNamePrefix}${middle}${resolvedDisplayNameSuffix}`, {
+      shouldValidate: true,
+      shouldDirty: true,
+    });
+  };
+
+  const affixWidth = (val?: string) => (val && val.length ? `${val.length + 1}ch` : 'auto');
+
   return (
     <Form>
       <FormGroup headerText={t('CreateProjectWorkspaceDialog.metadataHeader')} columnSpan={12}>
         <Label for="name" required>
           {t('CreateProjectWorkspaceDialog.nameLabel')}
         </Label>
-        <Input
-          className={styles.input}
-          id="name"
-          {...register('name')}
-          valueState={errors.name ? 'Negative' : 'None'}
-          valueStateMessage={<span>{errors.name?.message}</span>}
-          required
-        />
+
+        {resolvedNamePrefix || resolvedNameSuffix ? (
+          <div className={styles.affixRow}>
+            {resolvedNamePrefix ? (
+              <Input
+                className={styles.input}
+                id="namePrefix"
+                value={resolvedNamePrefix}
+                disabled
+                style={{ width: affixWidth(resolvedNamePrefix) }}
+              />
+            ) : null}
+            {/* hidden input to keep RHF registration and validation for 'name' */}
+            <input type="hidden" {...register('name')} value={currentName} readOnly />
+            <Input
+              className={styles.input}
+              id="name"
+              value={nameCore}
+              valueState={errors.name ? 'Negative' : 'None'}
+              valueStateMessage={<span>{errors.name?.message}</span>}
+              required
+              onInput={onNameCoreInput}
+            />
+            {resolvedNameSuffix ? (
+              <Input
+                className={styles.input}
+                id="nameSuffix"
+                value={resolvedNameSuffix}
+                disabled
+                style={{ width: affixWidth(resolvedNameSuffix) }}
+              />
+            ) : null}
+          </div>
+        ) : (
+          <Input
+            className={styles.input}
+            id="name"
+            {...register('name')}
+            valueState={errors.name ? 'Negative' : 'None'}
+            valueStateMessage={<span>{errors.name?.message}</span>}
+            required
+          />
+        )}
+
         <Label for={'displayName'}>{t('CreateProjectWorkspaceDialog.displayNameLabel')}</Label>
-        <Input id="displayName" {...register('displayName')} className={styles.input} />
+
+        {resolvedDisplayNamePrefix || resolvedDisplayNameSuffix ? (
+          <div className={styles.affixRow}>
+            {resolvedDisplayNamePrefix ? (
+              <Input
+                className={styles.input}
+                id="displayNamePrefix"
+                value={resolvedDisplayNamePrefix}
+                disabled
+                style={{ width: affixWidth(resolvedDisplayNamePrefix) }}
+              />
+            ) : null}
+            <input type="hidden" {...register('displayName')} value={currentDisplayName} readOnly />
+            <Input className={styles.input} id="displayName" value={displayNameCore} onInput={onDisplayNameCoreInput} />
+            {resolvedDisplayNameSuffix ? (
+              <Input
+                className={styles.input}
+                id="displayNameSuffix"
+                value={resolvedDisplayNameSuffix}
+                disabled
+                style={{ width: affixWidth(resolvedDisplayNameSuffix) }}
+              />
+            ) : null}
+          </div>
+        ) : (
+          <Input id="displayName" {...register('displayName')} className={styles.input} />
+        )}
 
         <div>
           <Label for={'chargingTargetType'}>{t('CreateProjectWorkspaceDialog.chargingTargetTypeLabel')}</Label>
         </div>
-        <Select id={'chargingTargetType'} className={styles.input} onChange={handleChargingTargetTypeChange}>
+        <Select
+          id={'chargingTargetType'}
+          className={styles.input}
+          disabled={disableChargingFields}
+          onChange={handleChargingTargetTypeChange}
+        >
           {chargingTypes.map((option) => (
-            <Option key={option.value} data-value={option.value}>
+            <Option key={option.value} data-value={option.value} selected={currentChargingTargetType === option.value}>
               {option.label}
             </Option>
           ))}
@@ -76,7 +206,7 @@ export function MetadataForm({
           className={styles.input}
           valueState={errors.chargingTarget ? 'Negative' : 'None'}
           valueStateMessage={<span>{errors.chargingTarget?.message}</span>}
-          disabled={!watch?.('chargingTargetType')}
+          disabled={disableChargingFields || !watch?.('chargingTargetType')}
         />
       </FormGroup>
 
diff --git a/src/components/Wizards/CreateManagedControlPlane/CreateManagedControlPlaneWizardContainer.tsx b/src/components/Wizards/CreateManagedControlPlane/CreateManagedControlPlaneWizardContainer.tsx
index e6b63c42..93c2b72d 100644
--- a/src/components/Wizards/CreateManagedControlPlane/CreateManagedControlPlaneWizardContainer.tsx
+++ b/src/components/Wizards/CreateManagedControlPlane/CreateManagedControlPlaneWizardContainer.tsx
@@ -39,12 +39,16 @@ import { MetadataForm } from '../../Dialogs/MetadataForm.tsx';
 import { EditMembers } from '../../Members/EditMembers.tsx';
 import { ComponentsSelectionContainer } from '../../ComponentsSelection/ComponentsSelectionContainer.tsx';
 import { IllustratedBanner } from '../../Ui/IllustratedBanner/IllustratedBanner.tsx';
+import { ManagedControlPlaneTemplate, noTemplateValue } from '../../../lib/api/types/templates/mcpTemplate.ts';
+import { stripIdpPrefix } from '../../../utils/stripIdpPrefix.ts';
+import { buildNameWithPrefixesAndSuffixes } from '../../../utils/buildNameWithPrefixesAndSuffixes.ts';
 
 type CreateManagedControlPlaneWizardContainerProps = {
   isOpen: boolean;
   setIsOpen: (isOpen: boolean) => void;
   projectName?: string;
   workspaceName?: string;
+  initialTemplateName?: string;
 };
 
 type WizardStepType = 'metadata' | 'members' | 'componentSelection' | 'summarize' | 'success';
@@ -56,12 +60,49 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
   setIsOpen,
   projectName = '',
   workspaceName = '',
+  initialTemplateName,
 }) => {
   const { t } = useTranslation();
   const { user } = useAuthOnboarding();
   const errorDialogRef = useRef<ErrorDialogHandle>(null);
 
   const [selectedStep, setSelectedStep] = useState<WizardStepType>('metadata');
+  const [metadataFormKey, setMetadataFormKey] = useState(0);
+
+  const normalizeChargingTargetType = useCallback((val?: string | null) => (val ?? '').trim().toLowerCase(), []);
+
+  // Here we will use OnboardingAPI to get all available templates
+  const templates = useMemo<ManagedControlPlaneTemplate[]>(() => [], []);
+
+  const [selectedTemplateValue, setSelectedTemplateValue] = useState<string>(noTemplateValue);
+
+  const selectedTemplate = useMemo(
+    () => templates.find((t) => t.metadata.name === selectedTemplateValue),
+    [templates, selectedTemplateValue],
+  );
+
+  const templateAffixes = useMemo(
+    () => ({
+      namePrefix: selectedTemplate?.spec.meta.name?.prefix ?? '',
+      nameSuffix: selectedTemplate?.spec.meta.name?.suffix ?? '',
+      displayNamePrefix: selectedTemplate?.spec.meta.displayName?.prefix ?? '',
+      displayNameSuffix: selectedTemplate?.spec.meta.displayName?.suffix ?? '',
+    }),
+    [selectedTemplate],
+  );
+
+  useEffect(() => {
+    const exists = templates.some((t) => t.metadata.name === selectedTemplateValue);
+    if (!exists && selectedTemplateValue !== noTemplateValue) {
+      setSelectedTemplateValue(noTemplateValue);
+    }
+  }, [templates, selectedTemplateValue]);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    setSelectedTemplateValue(initialTemplateName ?? noTemplateValue);
+  }, [isOpen, initialTemplateName]);
+
   const validationSchemaCreateManagedControlPlane = useMemo(() => createManagedControlPlaneSchema(t), [t]);
 
   const {
@@ -85,6 +126,26 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
     mode: 'onChange',
   });
 
+  useEffect(() => {
+    if (selectedStep !== 'metadata') return;
+
+    if (selectedTemplate) {
+      setValue('chargingTarget', selectedTemplate.spec.meta.chargingTarget.value, {
+        shouldValidate: true,
+        shouldDirty: true,
+      });
+      setValue('chargingTargetType', normalizeChargingTargetType(selectedTemplate.spec.meta.chargingTarget.type), {
+        shouldValidate: true,
+        shouldDirty: true,
+      });
+    } else {
+      setValue('chargingTarget', '', { shouldValidate: true, shouldDirty: true });
+      setValue('chargingTargetType', '', { shouldValidate: true, shouldDirty: true });
+    }
+
+    setMetadataFormKey((k) => k + 1);
+  }, [selectedTemplate, selectedStep, setValue, normalizeChargingTargetType]);
+
   const nextButtonText = useMemo(
     () => ({
       metadata: t('buttons.next'),
@@ -123,17 +184,25 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
   );
   const componentsList = watch('componentsList');
 
+  const hasMissingComponentVersions = useMemo(() => {
+    const list = (componentsList ?? []) as ComponentsListItem[];
+    return list.some(({ isSelected, selectedVersion }) => isSelected && !selectedVersion);
+  }, [componentsList]);
+
   const handleCreateManagedControlPlane = useCallback(
     async ({ name, displayName, chargingTarget, members, chargingTargetType }: OnCreatePayload): Promise<boolean> => {
       try {
+        const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes(name, displayName, templateAffixes);
+
+        const normalizedType = (chargingTargetType ?? '').trim().toUpperCase();
         await trigger(
           CreateManagedControlPlane(
-            name,
+            finalName,
             `${projectName}--ws-${workspaceName}`,
             {
-              displayName,
+              displayName: finalDisplayName,
               chargingTarget,
-              chargingTargetType,
+              chargingTargetType: normalizedType,
               members,
               componentsList,
             },
@@ -151,7 +220,7 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
         return false;
       }
     },
-    [trigger, projectName, workspaceName, componentsList],
+    [trigger, projectName, workspaceName, componentsList, templateAffixes],
   );
 
   const handleStepChange = useCallback((e: Ui5CustomEvent<WizardDomRef, WizardStepChangeEventDetail>) => {
@@ -168,6 +237,9 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
         setSelectedStep('componentSelection');
         break;
       case 'componentSelection':
+        if (hasMissingComponentVersions) {
+          return;
+        }
         setSelectedStep('summarize');
         break;
       case 'summarize':
@@ -179,7 +251,24 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
       default:
         break;
     }
-  }, [selectedStep, handleSubmit, setSelectedStep, handleCreateManagedControlPlane, watch, resetFormAndClose]);
+  }, [
+    selectedStep,
+    handleSubmit,
+    setSelectedStep,
+    handleCreateManagedControlPlane,
+    watch,
+    resetFormAndClose,
+    hasMissingComponentVersions,
+  ]);
+
+  const normalizeMemberRole = useCallback((roleInput?: string | null) => {
+    const normalizedRole = (roleInput ?? '').toString().trim().toLowerCase();
+    if (normalizedRole === 'admin' || normalizedRole === 'administrator') return MemberRoles.admin;
+    if (normalizedRole === 'viewer' || normalizedRole === 'view' || normalizedRole === 'readonly') {
+      return MemberRoles.view;
+    }
+    return MemberRoles.view;
+  }, []);
 
   const setMembers = useCallback(
     (members: Member[]) => {
@@ -209,16 +298,16 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
             selectedStep === 'metadata' ||
             selectedStep === 'members' ||
             selectedStep === 'componentSelection' ||
-            !isValid
+            !isValid ||
+            hasMissingComponentVersions
           );
-
         case 'success':
           return selectedStep !== 'success';
         default:
           return false;
       }
     },
-    [selectedStep, isValid],
+    [selectedStep, isValid, hasMissingComponentVersions],
   );
 
   const onBackClick = useCallback(() => {
@@ -228,6 +317,96 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
     }
   }, [selectedStep]);
 
+  const normalizeMemberKind = useCallback((kindInput?: string | null) => {
+    const normalizedKind = (kindInput ?? '').toString().trim().toLowerCase();
+    return normalizedKind === 'serviceaccount' ? 'ServiceAccount' : 'User';
+  }, []);
+
+  const appliedTemplateMembersRef = useRef(false);
+  const appliedTemplateComponentsRef = useRef(false);
+
+  useEffect(() => {
+    appliedTemplateMembersRef.current = false;
+    appliedTemplateComponentsRef.current = false;
+  }, [selectedTemplateValue, isOpen]);
+
+  useEffect(() => {
+    if (selectedStep !== 'members') return;
+    if (!selectedTemplate) return;
+    if (appliedTemplateMembersRef.current) return;
+
+    const templateMembers = (selectedTemplate?.spec?.spec?.authorization?.defaultMembers ??
+      []) as ManagedControlPlaneTemplate['spec']['spec']['authorization']['defaultMembers'];
+    if (!templateMembers?.length) {
+      appliedTemplateMembersRef.current = true;
+      return;
+    }
+
+    const currentMembers = (watch('members') ?? []) as Member[];
+
+    let merged = currentMembers;
+    if (user?.email && !currentMembers.some((m) => m.name === user.email)) {
+      merged = [{ name: user.email, roles: [MemberRoles.admin], kind: 'User' }, ...currentMembers];
+    }
+
+    const mappedFromTemplate: Member[] = templateMembers
+      .map((m) => ({
+        name: stripIdpPrefix(String(m?.name ?? ''), idpPrefix),
+        roles: [normalizeMemberRole(m?.role)],
+        kind: normalizeMemberKind(m?.kind),
+      }))
+      .filter((m) => !!m.name);
+
+    const byName = new Map<string, Member>();
+    merged.forEach((m) => m?.name && byName.set(m.name, m));
+    mappedFromTemplate.forEach((m) => {
+      if (m.name && !byName.has(m.name)) byName.set(m.name, m);
+    });
+
+    const normalizedMembers = Array.from(byName.values()).map((m) => ({
+      ...m,
+      roles: (m.roles ?? []).length
+        ? m.roles.map((r) => normalizeMemberRole(r as unknown as string))
+        : [MemberRoles.view],
+    }));
+
+    setValue('members', normalizedMembers, { shouldValidate: true });
+    appliedTemplateMembersRef.current = true;
+  }, [selectedStep, selectedTemplate, watch, setValue, user?.email, normalizeMemberRole, normalizeMemberKind]);
+
+  useEffect(() => {
+    if (selectedStep !== 'componentSelection') return;
+    if (!selectedTemplate) return;
+    if (appliedTemplateComponentsRef.current) return;
+
+    const defaults = (selectedTemplate?.spec?.spec?.components?.defaultComponents ??
+      []) as ManagedControlPlaneTemplate['spec']['spec']['components']['defaultComponents'];
+    if (!defaults?.length) {
+      appliedTemplateComponentsRef.current = true;
+      return;
+    }
+
+    const current = (watch('componentsList') ?? []) as ComponentsListItem[];
+    if (current.length > 0) {
+      appliedTemplateComponentsRef.current = true;
+      return;
+    }
+
+    const mapped = defaults
+      .filter((c) => !!c?.name && !!c?.version)
+      .map((c) => ({
+        name: String(c.name),
+        version: String(c.version),
+        selectedVersion: String(c.version),
+        selected: true,
+        removable: Boolean(c.removable),
+        versionChangeable: Boolean(c.versionChangeable),
+      })) as unknown as ComponentsListItem[];
+
+    setValue('componentsList', mapped, { shouldValidate: false });
+    appliedTemplateComponentsRef.current = true;
+  }, [selectedStep, selectedTemplate, watch, setValue]);
+
   if (!isOpen) return null;
 
   return (
@@ -266,7 +445,18 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
           selected={selectedStep === 'metadata'}
           data-step="metadata"
         >
-          <MetadataForm watch={watch} setValue={setValue} register={register} errors={errors} />
+          <MetadataForm
+            key={metadataFormKey}
+            watch={watch}
+            setValue={setValue}
+            register={register}
+            errors={errors}
+            disableChargingFields={!!selectedTemplate}
+            namePrefix={templateAffixes.namePrefix}
+            displayNamePrefix={templateAffixes.displayNamePrefix}
+            nameSuffix={templateAffixes.nameSuffix}
+            displayNameSuffix={templateAffixes.displayNameSuffix}
+          />
         </WizardStep>
         <WizardStep
           icon="user-edit"
@@ -296,7 +486,11 @@ export const CreateManagedControlPlaneWizardContainer: FC<CreateManagedControlPl
           data-step="componentSelection"
           disabled={isStepDisabled('componentSelection')}
         >
-          <ComponentsSelectionContainer componentsList={componentsList ?? []} setComponentsList={setComponentsList} />
+          <ComponentsSelectionContainer
+            componentsList={componentsList ?? []}
+            setComponentsList={setComponentsList}
+            managedControlPlaneTemplate={selectedTemplate}
+          />
         </WizardStep>
         <WizardStep
           icon="activities"
diff --git a/src/lib/api/types/templates/mcpTemplate.ts b/src/lib/api/types/templates/mcpTemplate.ts
new file mode 100644
index 00000000..d31a5475
--- /dev/null
+++ b/src/lib/api/types/templates/mcpTemplate.ts
@@ -0,0 +1,95 @@
+export type ManagedControlPlaneTemplateList = {
+  apiVersion: string;
+  items: ManagedControlPlaneTemplate[];
+};
+
+export type ManagedControlPlaneTemplate = {
+  apiVersion: string;
+  kind: string;
+  metadata: {
+    annotations?: Record<string, string>;
+    creationTimestamp?: string;
+    finalizers?: string[];
+    generation?: number;
+    labels?: Record<string, string>;
+    name: string;
+    namespace: string;
+    resourceVersion?: string;
+    uid?: string;
+    descriptionText?: string;
+  };
+  spec: {
+    meta: {
+      chargingTarget: {
+        type: string;
+        value: string;
+      };
+      displayName: {
+        prefix?: string;
+        suffix?: string;
+      };
+      name: {
+        prefix?: string;
+        suffix?: string;
+      };
+    };
+    spec: {
+      authentication: {
+        allowAdd?: boolean;
+        system: {
+          changeable: boolean;
+          enabled: boolean;
+        };
+      };
+      authorization: {
+        allowAddMembers?: boolean;
+        defaultMembers: {
+          name: string;
+          removable: boolean;
+          kind?: string;
+          role?: string;
+          namespace?: string;
+        }[];
+      };
+      components: {
+        defaultComponents: {
+          name: string;
+          removable?: boolean;
+          version: string;
+          versionChangeable?: boolean;
+        }[];
+      };
+    };
+  };
+  status?: {
+    conditions?: {
+      lastTransitionTime: string;
+      message: string;
+      observedGeneration: number;
+      reason: string;
+      status: string;
+      type: string;
+    }[];
+    state?: string;
+  };
+};
+
+export type TemplateDropdownOption = {
+  value: string;
+  label: string;
+};
+
+export const noTemplateValue = 'no-template';
+
+export function toTemplateDropdownOptions(
+  templates: ManagedControlPlaneTemplate[],
+  noTemplateLabel: string,
+): TemplateDropdownOption[] {
+  return [
+    { value: noTemplateValue, label: noTemplateLabel },
+    ...templates.map((t) => ({
+      value: t.metadata.name,
+      label: t.metadata.name,
+    })),
+  ];
+}
diff --git a/src/utils/buildNameWithPrefixesAndSuffixes.spec.ts b/src/utils/buildNameWithPrefixesAndSuffixes.spec.ts
new file mode 100644
index 00000000..f3c06ba1
--- /dev/null
+++ b/src/utils/buildNameWithPrefixesAndSuffixes.spec.ts
@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { buildNameWithPrefixesAndSuffixes } from './buildNameWithPrefixesAndSuffixes';
+
+describe('buildNameWithPrefixesAndSuffixes', () => {
+  it('returns provided values when no affixes provided', () => {
+    const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes('name', 'Display', {});
+    expect(finalName).to.equal('name');
+    expect(finalDisplayName).to.equal('Display');
+  });
+
+  it('applies prefix only', () => {
+    const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes('name', 'displayName', {
+      namePrefix: 'pre-',
+      displayNamePrefix: 'PRE-',
+    });
+    expect(finalName).to.equal('pre-name');
+    expect(finalDisplayName).to.equal('PRE-displayName');
+  });
+
+  it('applies suffix only', () => {
+    const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes('name', 'displayName', {
+      nameSuffix: '-suf',
+      displayNameSuffix: 'SUF',
+    });
+    expect(finalName).to.equal('name-suf');
+    expect(finalDisplayName).to.equal('displayNameSUF');
+  });
+
+  it('applies both prefix and suffix', () => {
+    const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes('name', 'displayName', {
+      namePrefix: 'pre-',
+      nameSuffix: '-suf',
+      displayNamePrefix: 'PRE',
+      displayNameSuffix: 'SUF',
+    });
+    expect(finalName).to.equal('pre-name-suf');
+    expect(finalDisplayName).to.equal('PREdisplayNameSUF');
+  });
+
+  it('trims whitespace around affixes', () => {
+    const { finalName, finalDisplayName } = buildNameWithPrefixesAndSuffixes('name', 'displayName', {
+      namePrefix: '  pre- ',
+      nameSuffix: ' -suf  ',
+      displayNamePrefix: '  PRE ',
+      displayNameSuffix: ' SUF   ',
+    });
+    expect(finalName).to.equal('pre-name-suf');
+    expect(finalDisplayName).to.equal('PREdisplayNameSUF');
+  });
+});
diff --git a/src/utils/buildNameWithPrefixesAndSuffixes.ts b/src/utils/buildNameWithPrefixesAndSuffixes.ts
new file mode 100644
index 00000000..6ff45374
--- /dev/null
+++ b/src/utils/buildNameWithPrefixesAndSuffixes.ts
@@ -0,0 +1,25 @@
+export function buildNameWithPrefixesAndSuffixes(
+  name: string | undefined,
+  displayName: string | undefined,
+  affixes?: {
+    namePrefix?: string;
+    nameSuffix?: string;
+    displayNamePrefix?: string;
+    displayNameSuffix?: string;
+  },
+): { finalName: string; finalDisplayName: string } {
+  const applyAffixes = (value: string | undefined, prefix?: string, suffix?: string) => {
+    const p = (prefix ?? '').trim();
+    const s = (suffix ?? '').trim();
+    if (!p && !s) return value ?? '';
+    let middle = value ?? '';
+    if (p && middle.startsWith(p)) middle = middle.slice(p.length);
+    if (s && middle.endsWith(s)) middle = middle.slice(0, middle.length - s.length);
+    return `${p}${middle}${s}`;
+  };
+
+  const finalName = applyAffixes(name, affixes?.namePrefix, affixes?.nameSuffix);
+  const finalDisplayName = applyAffixes(displayName, affixes?.displayNamePrefix, affixes?.displayNameSuffix);
+
+  return { finalName, finalDisplayName };
+}
diff --git a/src/utils/stripIdpPrefix.spec.ts b/src/utils/stripIdpPrefix.spec.ts
new file mode 100644
index 00000000..10b47f35
--- /dev/null
+++ b/src/utils/stripIdpPrefix.spec.ts
@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { stripIdpPrefix } from './stripIdpPrefix';
+
+describe('stripIdpPrefix', () => {
+  it('removes known idp prefix when it matches', () => {
+    expect(stripIdpPrefix('openmcp:john@doe.com', 'openmcp')).to.equal('john@doe.com');
+  });
+
+  it('falls back to removing text before first colon when idpPrefix does not match', () => {
+    expect(stripIdpPrefix('azuread:svc-account', 'openmcp')).to.equal('svc-account');
+  });
+
+  it('removes text before the first colon when idpPrefix is not provided', () => {
+    expect(stripIdpPrefix('anything:rest')).to.equal('rest');
+  });
+
+  it('returns original value when there is no colon', () => {
+    expect(stripIdpPrefix('john@doe.com')).to.equal('john@doe.com');
+  });
+
+  it('handles empty string input', () => {
+    expect(stripIdpPrefix('')).to.equal('');
+  });
+
+  it('removes only the first matching prefix (supports multiple colons)', () => {
+    expect(stripIdpPrefix('p1:p2:val', 'p1')).to.equal('p2:val');
+  });
+
+  it('with empty idpPrefix still uses fallback behavior', () => {
+    expect(stripIdpPrefix('prefix:value', '')).to.equal('value');
+  });
+
+  it('when principal starts with non-matching similar text, uses fallback', () => {
+    expect(stripIdpPrefix('openmcpuser:john', 'openmcp')).to.equal('john');
+  });
+});
diff --git a/src/utils/stripIdpPrefix.ts b/src/utils/stripIdpPrefix.ts
new file mode 100644
index 00000000..3cd78a76
--- /dev/null
+++ b/src/utils/stripIdpPrefix.ts
@@ -0,0 +1,11 @@
+export function stripIdpPrefix(principal: string, idpPrefix?: string): string {
+  const value = String(principal ?? '');
+  const expected = idpPrefix ? `${idpPrefix}:` : '';
+
+  if (expected && value.startsWith(expected)) {
+    return value.slice(expected.length);
+  }
+
+  const firstColonIndex = value.indexOf(':');
+  return firstColonIndex >= 0 ? value.slice(firstColonIndex + 1) : value;
+}