diff --git a/src/api/api.ts b/src/api/api.ts
index 86f9e5e8..15b712c7 100644
--- a/src/api/api.ts
+++ b/src/api/api.ts
@@ -76,6 +76,9 @@ import type {
   AccessControlResponse,
   AccessControlUpdateRequest,
   AccessControlBulkDeployRequest,
+  CustomResourceBuildRequest,
+  MicroDomainDeployRequest,
+  BulkMicroDomainDeployResult,
 } from "./apiTypes.ts";
 import { RestApi } from "./rest/restApi.ts";
 import { isVsCode, VSCodeExtensionApi } from "./rest/vscodeExtensionApi.ts";
@@ -167,6 +170,8 @@ export interface Api {
 
   revertToSnapshot(chainId: string, snapshotId: string): Promise<Snapshot>;
 
+  buildCR(request: CustomResourceBuildRequest): Promise<string>;
+
   getLibraryElementByType(type: string): Promise<LibraryElement>;
 
   getDeployments(chainId: string): Promise<Deployment[]>;
@@ -537,6 +542,21 @@ export interface Api {
   bulkDeployChainsAccessControl(
     searchRequest: AccessControlBulkDeployRequest[],
   ): Promise<AccessControlResponse>;
+
+  deployToMicroDomain(
+    request: BulkMicroDomainDeployResult,
+  ): Promise<BulkDeploymentResult[]>;
+
+  deploySnapshotsToMicroDomain(
+    request: MicroDomainDeployRequest,
+  ): Promise<void>;
+
+  deleteMicroDomain(name: string): Promise<void>;
+
+  deleteSnapshotFromMicroDomain(
+    name: string,
+    snapshotId: string,
+  ): Promise<void>;
 }
 
 export const api: Api = isVsCode ? new VSCodeExtensionApi() : new RestApi();
diff --git a/src/api/apiTypes.ts b/src/api/apiTypes.ts
index 15a3ad4a..84a59c66 100644
--- a/src/api/apiTypes.ts
+++ b/src/api/apiTypes.ts
@@ -265,6 +265,7 @@ export type Deployment = {
   snapshotId: string;
   name: string;
   domain: string;
+  domainType: DomainType;
   createdWhen: number;
   createdBy: User;
   runtime?: RuntimeStates;
@@ -283,8 +284,14 @@ export type EngineDomain = {
   replicas: number;
   namespace: string;
   version?: string;
+  type: DomainType;
 };
 
+export enum DomainType {
+  NATIVE = "NATIVE",
+  MICRO = "MICRO",
+}
+
 export type ChainLoggingSettings = {
   fallbackDefault: ChainLoggingProperties;
   consulDefault?: ChainLoggingProperties;
@@ -1241,6 +1248,37 @@ export type AccessControlProperty = {
   abacParameters?: AbacParameters;
 };
 
+export type CustomResourceBuildRequest = {
+  options: CustomResourceOptions;
+  chainIds: string[];
+};
+
+export type CustomResourceOptions = {
+  language?: string;
+  name?: string;
+  namespace?: string;
+  container?: ContainerOptions;
+  monitoring?: MonitoringOptions;
+  service?: ServiceOptions;
+  environment?: Record<string, string>;
+  resources?: string[];
+  serviceAccount?: string;
+};
+
+export type MonitoringOptions = {
+  enabled: boolean;
+  interval: string;
+};
+
+export type ServiceOptions = {
+  enabled: boolean;
+};
+
+export type ContainerOptions = {
+  image?: string;
+  imagePoolPolicy?: "Always" | "Never" | "IfNotPresent";
+};
+
 export type LiveExchange = {
   exchangeId: string;
   deploymentId: string;
@@ -1317,6 +1355,24 @@ export type BulkDeploymentRequest = {
   chainIds: string[];
 };
 
+export type MicroDomainDeployRequest = {
+  name: string;
+  snapshotIds: string[];
+  mode?: DeployMode;
+};
+
+export type BulkMicroDomainDeployResult = {
+  domains: string[];
+  chainIds: string[];
+  snapshotAction: BulkDeploymentSnapshotAction;
+  mode?: DeployMode;
+};
+
+export enum DeployMode {
+  REWRITE = "REWRITE",
+  APPEND = "APPEND",
+}
+
 export type BulkDeploymentResult = {
   chainId: string;
   chainName: string;
diff --git a/src/api/rest/restApi.ts b/src/api/rest/restApi.ts
index 95987b55..ea39f867 100644
--- a/src/api/rest/restApi.ts
+++ b/src/api/rest/restApi.ts
@@ -66,19 +66,22 @@ import {
   Element,
   SystemOperation,
   SpecApiFile,
+  CustomResourceBuildRequest,
   LiveExchange,
   ContextSystem,
   IntegrationSystemType,
   DiagnosticValidation,
   BulkDeploymentRequest,
   BulkDeploymentResult,
+  MicroDomainDeployRequest,
+  BulkMicroDomainDeployResult,
   ImportVariablesResult,
   VariableImportPreview,
   UsedProperty,
   AccessControlSearchRequest,
   AccessControlResponse,
   AccessControlUpdateRequest,
-  AccessControlBulkDeployRequest,
+  AccessControlBulkDeployRequest
 } from "../apiTypes.ts";
 import { Api } from "../api.ts";
 import { getFileFromResponse } from "../../misc/download-utils.ts";
@@ -91,7 +94,7 @@ import type {
   ApiResponse,
   SecretResponse,
   SecretWithVariables,
-  Variable,
+  Variable
 } from "../apiTypes.ts";
 
 export class RestApi implements Api {
@@ -104,12 +107,12 @@ export class RestApi implements Api {
       axios.create({
         baseURL: gateway,
         timeout: 2000,
-        headers: { "content-type": "application/json" },
+        headers: { "content-type": "application/json" }
       }),
       {
         maxRequests: 50,
-        perMilliseconds: 1000,
-      },
+        perMilliseconds: 1000
+      }
     );
 
     registerRestAxiosInstance(this.instance);
@@ -142,9 +145,9 @@ export class RestApi implements Api {
           }
         }
         return Promise.reject(
-          new RestApiError(message, responseCode, responseBody, error),
+          new RestApiError(message, responseCode, responseBody, error)
         );
-      },
+      }
     );
   }
 
@@ -156,22 +159,22 @@ export class RestApi implements Api {
     serviceName: string,
     message: string,
     errorDate: string,
-    stacktrace?: string,
+    stacktrace?: string
   ): ApiError => {
     return {
       responseBody: {
         serviceName,
         errorMessage: message,
         errorDate,
-        stacktrace,
-      },
+        stacktrace
+      }
     };
   };
 
   private wrapApiResponse = async <T>(
     serviceName: string,
     fallbackMessage: string,
-    fn: () => Promise<T>,
+    fn: () => Promise<T>
   ): Promise<ApiResponse<T>> => {
     try {
       const data = await fn();
@@ -193,8 +196,8 @@ export class RestApi implements Api {
               body.serviceName,
               body.errorMessage,
               body.errorDate,
-              body.stackTrace,
-            ),
+              body.stackTrace
+            )
           };
         }
         if (e.message) {
@@ -203,8 +206,8 @@ export class RestApi implements Api {
             error: this.toApiError(
               serviceName,
               e.message,
-              new Date().toISOString(),
-            ),
+              new Date().toISOString()
+            )
           };
         }
       }
@@ -214,15 +217,15 @@ export class RestApi implements Api {
         error: this.toApiError(
           serviceName,
           fallbackMessage,
-          new Date().toISOString(),
-        ),
+          new Date().toISOString()
+        )
       };
     }
   };
 
   private wrapBoolean = async (
     fallbackMessage: string,
-    fn: () => Promise<void>,
+    fn: () => Promise<void>
   ): Promise<boolean> => {
     try {
       await fn();
@@ -236,7 +239,7 @@ export class RestApi implements Api {
 
   getChains = async (): Promise<Chain[]> => {
     const response = await this.instance.get<Chain[]>(
-      `${this.v1()}/catalog/chains`,
+      `${this.v1()}/catalog/chains`
     );
     return response.data;
   };
@@ -251,30 +254,30 @@ export class RestApi implements Api {
       "Failed to fetch common variables",
       async () => {
         const response = await this.instance.get<unknown>(
-          `${prefix}/common-variables`,
+          `${prefix}/common-variables`
         );
         const rawData = response.data;
         if (rawData && typeof rawData === "object" && !Array.isArray(rawData)) {
           return Object.entries(rawData as Record<string, unknown>).map(
             ([key, value]) => ({
               key,
-              value: String(value),
-            }),
+              value: String(value)
+            })
           );
         }
         throw new Error("Unexpected response format");
-      },
+      }
     );
   };
 
   createCommonVariable = async (
-    variable: Variable,
+    variable: Variable
   ): Promise<ApiResponse<string[]>> => {
     return this.createCommonVariables({ [variable.key]: variable.value });
   };
 
   private createCommonVariables = async (
-    variables: Record<string, string>,
+    variables: Record<string, string>
   ): Promise<ApiResponse<string[]>> => {
     const serviceName = "Common Variables API";
     const prefix = `${this.v1()}/variables-management`;
@@ -285,15 +288,15 @@ export class RestApi implements Api {
       async () => {
         const response = await this.instance.post<string[]>(
           `${prefix}/common-variables`,
-          variables,
+          variables
         );
         return response.data;
-      },
+      }
     );
   };
 
   updateCommonVariable = async (
-    variable: Variable,
+    variable: Variable
   ): Promise<ApiResponse<Variable>> => {
     const serviceName = "Common Variables API";
     const prefix = `${this.v1()}/variables-management`;
@@ -305,10 +308,10 @@ export class RestApi implements Api {
         const response = await this.instance.patch<Variable>(
           `${prefix}/common-variables/${variable.key}`,
           variable.value,
-          { headers: { "Content-Type": "text/plain" } },
+          { headers: { "Content-Type": "text/plain" } }
         );
         return response.data;
-      },
+      }
     );
   };
 
@@ -329,13 +332,13 @@ export class RestApi implements Api {
 
     const response = await this.instance.get<Blob>(
       `${prefix}/common-variables/export?${params}`,
-      { responseType: "blob" },
+      { responseType: "blob" }
     );
     return getFileFromResponse(response);
   };
 
   importVariablesPreview = async (
-    formData: FormData,
+    formData: FormData
   ): Promise<ApiResponse<VariableImportPreview[]>> => {
     const serviceName = "Common Variables API";
     if (!formData) {
@@ -344,8 +347,8 @@ export class RestApi implements Api {
         error: this.toApiError(
           serviceName,
           "No file selected or form data is empty.",
-          new Date().toISOString(),
-        ),
+          new Date().toISOString()
+        )
       };
     }
     const path = `${this.v1()}/variables-management/common-variables/preview`;
@@ -356,15 +359,15 @@ export class RestApi implements Api {
         const response = await this.instance.post<VariableImportPreview[]>(
           path,
           formData,
-          { headers: { "Content-Type": "multipart/form-data" } },
+          { headers: { "Content-Type": "multipart/form-data" } }
         );
         return response.data;
-      },
+      }
     );
   };
 
   importVariables = async (
-    formData: FormData,
+    formData: FormData
   ): Promise<ApiResponse<ImportVariablesResult>> => {
     const serviceName = "Common Variables API";
     if (!formData) {
@@ -373,8 +376,8 @@ export class RestApi implements Api {
         error: this.toApiError(
           serviceName,
           "No file selected or form data is empty.",
-          new Date().toISOString(),
-        ),
+          new Date().toISOString()
+        )
       };
     }
     const path = `${this.v2()}/common-variables/import`;
@@ -382,7 +385,7 @@ export class RestApi implements Api {
       const response = await this.instance.post<ImportVariablesResult>(
         path,
         formData,
-        { headers: { "Content-Type": "multipart/form-data" } },
+        { headers: { "Content-Type": "multipart/form-data" } }
       );
       return response.data;
     });
@@ -398,24 +401,24 @@ export class RestApi implements Api {
       "Failed to fetch secured variables",
       async () => {
         const response = await this.instance.get<SecretResponse[]>(
-          `${this.v2()}/secured-variables`,
+          `${this.v2()}/secured-variables`
         );
         return response.data.map(
           ({ secretName, variablesNames, defaultSecret }) => ({
             secretName,
             variables: variablesNames.map((key: string) => ({
               key,
-              value: "******",
+              value: "******"
             })),
-            isDefaultSecret: defaultSecret,
-          }),
+            isDefaultSecret: defaultSecret
+          })
         );
-      },
+      }
     );
   };
 
   getSecuredVariablesForSecret = async (
-    secretName: string,
+    secretName: string
   ): Promise<ApiResponse<Variable[]>> => {
     const serviceName = "Secured Variables API";
 
@@ -424,16 +427,16 @@ export class RestApi implements Api {
       "Failed to fetch variables for secret",
       async () => {
         const response = await this.instance.get<string[]>(
-          `${this.v2()}/secured-variables/${secretName}`,
+          `${this.v2()}/secured-variables/${secretName}`
         );
         return response.data.map((key: string) => ({ key, value: "******" }));
-      },
+      }
     );
   };
 
   createSecuredVariables = async (
     secretName: string,
-    variables: Variable[],
+    variables: Variable[]
   ): Promise<ApiResponse<Variable[]>> => {
     const serviceName = "Secured Variables API";
     const keyRegex = /^[a-zA-Z0-9_-]+$/;
@@ -444,8 +447,8 @@ export class RestApi implements Api {
           error: this.toApiError(
             serviceName,
             `Invalid key: ${v.key}`,
-            new Date().toISOString(),
-          ),
+            new Date().toISOString()
+          )
         };
       }
     }
@@ -455,16 +458,16 @@ export class RestApi implements Api {
       async () => {
         await this.instance.post(`${this.v2()}/secured-variables`, {
           secretName,
-          variables: Object.fromEntries(variables.map((v) => [v.key, v.value])),
+          variables: Object.fromEntries(variables.map((v) => [v.key, v.value]))
         });
         return variables;
-      },
+      }
     );
   };
 
   updateSecuredVariables = async (
     secretName: string,
-    variables: Variable[],
+    variables: Variable[]
   ): Promise<ApiResponse<Variable[]>> => {
     const serviceName = "Secured Variables API";
     return this.wrapApiResponse(
@@ -473,16 +476,16 @@ export class RestApi implements Api {
       async () => {
         await this.instance.patch(`${this.v2()}/secured-variables`, {
           secretName,
-          variables: Object.fromEntries(variables.map((v) => [v.key, v.value])),
+          variables: Object.fromEntries(variables.map((v) => [v.key, v.value]))
         });
         return variables;
-      },
+      }
     );
   };
 
   deleteSecuredVariables = async (
     secretName: string,
-    keys: string[],
+    keys: string[]
   ): Promise<ApiResponse<boolean>> => {
     const serviceName = "Secured Variables API";
     return this.wrapApiResponse(
@@ -492,10 +495,10 @@ export class RestApi implements Api {
         const params = new URLSearchParams();
         keys.forEach((key) => params.append("variablesNames", key));
         await this.instance.delete(
-          `${this.v2()}/secured-variables/${secretName}?${params}`,
+          `${this.v2()}/secured-variables/${secretName}?${params}`
         );
         return true;
-      },
+      }
     );
   };
 
@@ -507,28 +510,28 @@ export class RestApi implements Api {
       async () => {
         await this.instance.post(`${this.v2()}/secret/${secretName}`);
         return true;
-      },
+      }
     );
   };
 
   downloadHelmChart = async (secretName: string): Promise<File> => {
     const response = await this.instance.get<Blob>(
       `${this.v2()}/secret/template/${secretName}`,
-      { responseType: "blob" },
+      { responseType: "blob" }
     );
     return getFileFromResponse(response);
   };
 
   getChain = async (id: string): Promise<Chain> => {
     const response = await this.instance.get<Chain>(
-      `${this.v1()}/catalog/chains/${id}`,
+      `${this.v1()}/catalog/chains/${id}`
     );
     return response.data;
   };
 
   findChainByElementId = async (elementId: string): Promise<Chain> => {
     const response = await this.instance.get<Chain>(
-      `${this.v1()}/catalog/chains/find-by-element/${elementId}`,
+      `${this.v1()}/catalog/chains/find-by-element/${elementId}`
     );
     return response.data;
   };
@@ -536,7 +539,7 @@ export class RestApi implements Api {
   updateChain = async (id: string, chain: Partial<Chain>): Promise<Chain> => {
     const response = await this.instance.put<Chain>(
       `${this.v1()}/catalog/chains/${id}`,
-      chain,
+      chain
     );
     return response.data;
   };
@@ -544,7 +547,7 @@ export class RestApi implements Api {
   createChain = async (chain: ChainCreationRequest): Promise<Chain> => {
     const response = await this.instance.post<Chain>(
       `${this.v1()}/catalog/chains`,
-      chain,
+      chain
     );
     return response.data;
   };
@@ -556,13 +559,13 @@ export class RestApi implements Api {
   deleteChains = async (chainIds: string[]): Promise<void> => {
     await this.instance.post(
       `${this.v1()}/catalog/chains/bulk-delete`,
-      chainIds,
+      chainIds
     );
   };
 
   duplicateChain = async (chainId: string): Promise<Chain> => {
     const response = await this.instance.post<Chain>(
-      `${this.v1()}/catalog/chains/${chainId}/duplicate`,
+      `${this.v1()}/catalog/chains/${chainId}/duplicate`
     );
     return response.data;
   };
@@ -572,8 +575,8 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/chains/${chainId}/copy`,
       null,
       {
-        params: { targetFolderId: folderId },
-      },
+        params: { targetFolderId: folderId }
+      }
     );
     return response.data;
   };
@@ -583,8 +586,8 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/chains/${chainId}/move`,
       null,
       {
-        params: { targetFolderId: folder },
-      },
+        params: { targetFolderId: folder }
+      }
     );
     return response.data;
   };
@@ -593,67 +596,67 @@ export class RestApi implements Api {
     const response = await this.instance.get<Blob>(
       `${this.v1()}/catalog/export`,
       {
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     return getFileFromResponse(response);
   };
 
   exportChains = async (
     chainIds: string[],
-    exportSubchains: boolean,
+    exportSubchains: boolean
   ): Promise<File> => {
     const response = await this.instance.get<Blob>(
       `${this.v1()}/catalog/export/chains`,
       {
         params: { chainIds, exportWithSubChains: exportSubchains },
         paramsSerializer: {
-          indexes: null,
+          indexes: null
         },
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     return getFileFromResponse(response);
   };
 
   getLibrary = async (): Promise<LibraryData> => {
     const response = await this.instance.get<LibraryData>(
-      `${this.v1()}/catalog/library`,
+      `${this.v1()}/catalog/library`
     );
     return response.data;
   };
 
   getElementTypes = async (): Promise<ElementFilter[]> => {
     const response = await this.instance.get<ElementFilter[]>(
-      `${this.v1()}/catalog/library/elements/types`,
+      `${this.v1()}/catalog/library/elements/types`
     );
     return response.data;
   };
 
   getElements = async (chainId: string): Promise<Element[]> => {
     const response = await this.instance.get<Element[]>(
-      `${this.v1()}/catalog/chains/${chainId}/elements`,
+      `${this.v1()}/catalog/chains/${chainId}/elements`
     );
     return response.data;
   };
 
   getElementsByType = async (
     chainId: string,
-    elementType: string,
+    elementType: string
   ): Promise<ElementWithChainName[]> => {
     const response = await this.instance.get<ElementWithChainName[]>(
-      `${this.v1()}/catalog/chains/${chainId}/elements/type/${elementType}`,
+      `${this.v1()}/catalog/chains/${chainId}/elements/type/${elementType}`
     );
     return response.data;
   };
 
   createElement = async (
     elementRequest: CreateElementRequest,
-    chainId: string,
+    chainId: string
   ): Promise<ActionDifference> => {
     const response = await this.instance.post<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/elements`,
-      elementRequest,
+      elementRequest
     );
     return response.data;
   };
@@ -661,36 +664,36 @@ export class RestApi implements Api {
   updateElement = async (
     elementRequest: PatchElementRequest,
     chainId: string,
-    elementId: string,
+    elementId: string
   ): Promise<ActionDifference> => {
     const response = await this.instance.patch<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/elements/${elementId}`,
-      elementRequest,
+      elementRequest
     );
     return response.data;
   };
 
   transferElement = async (
     transferElementRequest: TransferElementRequest,
-    chainId: string,
+    chainId: string
   ): Promise<ActionDifference> => {
     const response = await this.instance.post<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/elements/transfer`,
-      transferElementRequest,
+      transferElementRequest
     );
     return response.data;
   };
 
   deleteElements = async (
     elementIds: string[],
-    chainId: string,
+    chainId: string
   ): Promise<ActionDifference> => {
     const elementsIdsParam = elementIds.join(",");
     const response = await this.instance.delete<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/elements`,
       {
-        params: { elementsIds: elementsIdsParam },
-      },
+        params: { elementsIds: elementsIdsParam }
+      }
     );
     return response.data;
   };
@@ -698,7 +701,7 @@ export class RestApi implements Api {
   modifyHttpTriggerProperties = async (
     chainId: string,
     specificationGroupId: string,
-    httpTriggerIds: string[],
+    httpTriggerIds: string[]
   ): Promise<void> => {
     await this.instance.put(
       `${this.v1()}/catalog/chains/${chainId}/elements/properties-modification`,
@@ -706,70 +709,70 @@ export class RestApi implements Api {
       {
         params: {
           specificationGroupId: specificationGroupId,
-          httpTriggerIds: httpTriggerIds,
+          httpTriggerIds: httpTriggerIds
         },
         paramsSerializer: (params) =>
-          qs.stringify(params, { arrayFormat: "repeat" }),
-      },
+          qs.stringify(params, { arrayFormat: "repeat" })
+      }
     );
   };
 
   getConnections = async (chainId: string): Promise<Connection[]> => {
     const response = await this.instance.get<Connection[]>(
-      `${this.v1()}/catalog/chains/${chainId}/dependencies`,
+      `${this.v1()}/catalog/chains/${chainId}/dependencies`
     );
     return response.data;
   };
 
   createConnection = async (
     connectionRequest: ConnectionRequest,
-    chainId: string,
+    chainId: string
   ): Promise<ActionDifference> => {
     const response = await this.instance.post<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/dependencies`,
-      connectionRequest,
+      connectionRequest
     );
     return response.data;
   };
 
   deleteConnections = async (
     connectionIds: string[],
-    chainId: string,
+    chainId: string
   ): Promise<ActionDifference> => {
     const connectionIdsParam = connectionIds.join(",");
     const response = await this.instance.delete<ActionDifference>(
       `${this.v1()}/catalog/chains/${chainId}/dependencies`,
       {
-        params: { dependenciesIds: connectionIdsParam },
-      },
+        params: { dependenciesIds: connectionIdsParam }
+      }
     );
     return response.data;
   };
 
   createSnapshot = async (chainId: string): Promise<Snapshot> => {
     const response = await this.instance.post<Snapshot>(
-      `${this.v1()}/catalog/chains/${chainId}/snapshots`,
+      `${this.v1()}/catalog/chains/${chainId}/snapshots`
     );
     return response.data;
   };
 
   getSnapshots = async (chainId: string): Promise<Snapshot[]> => {
     const response = await this.instance.get<Snapshot[]>(
-      `${this.v1()}/catalog/chains/${chainId}/snapshots`,
+      `${this.v1()}/catalog/chains/${chainId}/snapshots`
     );
     return response.data;
   };
 
   getSnapshot = async (snapshotId: string): Promise<Snapshot> => {
     const response = await this.instance.get<Snapshot>(
-      `${this.v1()}/catalog/chains/chainId/snapshots/${snapshotId}`,
+      `${this.v1()}/catalog/chains/chainId/snapshots/${snapshotId}`
     );
     return response.data;
   };
 
   deleteSnapshot = async (snapshotId: string): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/catalog/chains/chainId/snapshots/${snapshotId}`,
+      `${this.v1()}/catalog/chains/chainId/snapshots/${snapshotId}`
     );
   };
 
@@ -779,10 +782,10 @@ export class RestApi implements Api {
 
   revertToSnapshot = async (
     chainId: string,
-    snapshotId: string,
+    snapshotId: string
   ): Promise<Snapshot> => {
     const response = await this.instance.post<Snapshot>(
-      `${this.v1()}/catalog/chains/${chainId}/snapshots/${snapshotId}/revert`,
+      `${this.v1()}/catalog/chains/${chainId}/snapshots/${snapshotId}/revert`
     );
     return response.data;
   };
@@ -790,126 +793,126 @@ export class RestApi implements Api {
   updateSnapshot = async (
     snapshotId: string,
     name: string,
-    labels: EntityLabel[],
+    labels: EntityLabel[]
   ): Promise<Snapshot> => {
     const response = await this.instance.put<Snapshot>(
       `${this.v1()}/catalog/chains/chainId/snapshots/${snapshotId}`,
       {
         name,
-        labels,
-      },
+        labels
+      }
     );
     return response.data;
   };
 
   getLibraryElementByType = async (type: string): Promise<LibraryElement> => {
     const response = await this.instance.get<LibraryElement>(
-      `${this.v1()}/catalog/library/${type}`,
+      `${this.v1()}/catalog/library/${type}`
     );
     return response.data;
   };
 
   getDeployments = async (chainId: string): Promise<Deployment[]> => {
     const response = await this.instance.get<Deployment[]>(
-      `${this.v1()}/catalog/chains/${chainId}/deployments`,
+      `${this.v1()}/catalog/chains/${chainId}/deployments`
     );
     return response.data;
   };
 
   createDeployment = async (
     chainId: string,
-    request: CreateDeploymentRequest,
+    request: CreateDeploymentRequest
   ): Promise<Deployment> => {
     const response = await this.instance.post<Deployment>(
       `${this.v1()}/catalog/chains/${chainId}/deployments`,
-      request,
+      request
     );
     return response.data;
   };
 
   deleteDeployment = async (deploymentId: string): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/catalog/chains/chainId/deployments/${deploymentId}`,
+      `${this.v1()}/catalog/chains/chainId/deployments/${deploymentId}`
     );
   };
 
   getDomains = async (): Promise<EngineDomain[]> => {
     const response = await this.instance.get<EngineDomain[]>(
-      `${this.v1()}/catalog/domains`,
+      `${this.v1()}/catalog/domains`
     );
     return response.data;
   };
 
   getLoggingSettings = async (
-    chainId: string,
+    chainId: string
   ): Promise<ChainLoggingSettings> => {
     const response = await this.instance.get<ChainLoggingSettings>(
-      `${this.v1()}/catalog/chains/${chainId}/properties/logging`,
+      `${this.v1()}/catalog/chains/${chainId}/properties/logging`
     );
     return response.data;
   };
 
   setLoggingProperties = async (
     chainId: string,
-    properties: ChainLoggingProperties,
+    properties: ChainLoggingProperties
   ): Promise<void> => {
     await this.instance.post(
       `${this.v1()}/catalog/chains/${chainId}/properties/logging`,
-      properties,
+      properties
     );
   };
 
   deleteLoggingSettings = async (chainId: string): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/catalog/chains/${chainId}/properties/logging`,
+      `${this.v1()}/catalog/chains/${chainId}/properties/logging`
     );
   };
 
   getMaskedFields = async (chainId: string): Promise<MaskedField[]> => {
     const response = await this.instance.get<MaskedFields>(
-      `${this.v1()}/catalog/chains/${chainId}/masking`,
+      `${this.v1()}/catalog/chains/${chainId}/masking`
     );
     return response.data.fields;
   };
 
   createMaskedField = async (
     chainId: string,
-    maskedField: Partial<Omit<MaskedField, "id">>,
+    maskedField: Partial<Omit<MaskedField, "id">>
   ): Promise<MaskedField> => {
     const response = await this.instance.post<MaskedField>(
       `${this.v1()}/catalog/chains/${chainId}/masking`,
-      maskedField,
+      maskedField
     );
     return response.data;
   };
 
   deleteMaskedFields = async (
     chainId: string,
-    maskedFieldIds: string[],
+    maskedFieldIds: string[]
   ): Promise<void> => {
     await this.instance.post(
       `${this.v1()}/catalog/chains/${chainId}/masking/field`,
-      maskedFieldIds,
+      maskedFieldIds
     );
   };
 
   deleteMaskedField = async (
     chainId: string,
-    maskedFieldId: string,
+    maskedFieldId: string
   ): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/catalog/chains/${chainId}/masking/field/${maskedFieldId}`,
+      `${this.v1()}/catalog/chains/${chainId}/masking/field/${maskedFieldId}`
     );
   };
 
   updateMaskedField = async (
     chainId: string,
     maskedFieldId: string,
-    changes: Partial<Omit<MaskedField, "id">>,
+    changes: Partial<Omit<MaskedField, "id">>
   ): Promise<MaskedField> => {
     const response = await this.instance.put<MaskedField>(
       `${this.v1()}/catalog/chains/${chainId}/masking/field/${maskedFieldId}`,
-      changes,
+      changes
     );
     return response.data;
   };
@@ -917,7 +920,7 @@ export class RestApi implements Api {
   getSessions = async (
     chainId: string | undefined,
     filters: SessionFilterAndSearchRequest,
-    paginationOptions: PaginationOptions,
+    paginationOptions: PaginationOptions
   ): Promise<SessionSearchResponse> => {
     const prefix = `${this.v1()}/sessions-management/sessions`;
     const url = chainId ? `${prefix}/chains/${chainId}` : prefix;
@@ -931,7 +934,7 @@ export class RestApi implements Api {
     const response = await this.instance.post<SessionSearchResponse>(
       url,
       filters,
-      { params },
+      { params }
     );
     return response.data;
   };
@@ -939,12 +942,12 @@ export class RestApi implements Api {
   deleteSessions = async (sessionIds: string[]): Promise<void> => {
     await this.instance.post(
       `${this.v1()}/sessions-management/sessions/bulk-delete`,
-      sessionIds,
+      sessionIds
     );
   };
 
   deleteSessionsByChainId = async (
-    chainId: string | undefined,
+    chainId: string | undefined
   ): Promise<void> => {
     const prefix = `${this.v1()}/sessions-management/sessions`;
     const url = chainId ? `${prefix}/chains/${chainId}` : prefix;
@@ -955,7 +958,7 @@ export class RestApi implements Api {
     const response = await this.instance.post<Blob>(
       `${this.v1()}/sessions-management/sessions/export`,
       sessionIds,
-      { responseType: "blob" },
+      { responseType: "blob" }
     );
     return getFileFromResponse(response);
   };
@@ -969,86 +972,86 @@ export class RestApi implements Api {
     const response = await this.instance.post<Session[]>(
       `${this.v1()}/sessions-management/sessions/import`,
       formData,
-      { headers },
+      { headers }
     );
     return response.data;
   };
 
   retryFromLastCheckpoint = async (
     chainId: string,
-    sessionId: string,
+    sessionId: string
   ): Promise<void> => {
     await this.instance.post(
       `${this.v1()}/engine/chains/${chainId}/sessions/${sessionId}/retry`,
-      null,
+      null
     );
   };
 
   getSession = async (sessionId: string): Promise<Session> => {
     const response = await this.instance.get<Session>(
-      `${this.v1()}/sessions-management/sessions/${sessionId}`,
+      `${this.v1()}/sessions-management/sessions/${sessionId}`
     );
     return response.data;
   };
 
   getCheckpointSessions = async (
-    sessionIds: string[],
+    sessionIds: string[]
   ): Promise<CheckpointSession[]> => {
     const response = await this.instance.get<CheckpointSession[]>(
       `${this.v1()}/engine/sessions`,
       {
         params: { ids: sessionIds },
         paramsSerializer: {
-          indexes: null,
-        },
-      },
+          indexes: null
+        }
+      }
     );
     return response.data;
   };
 
   retrySessionFromLastCheckpoint = async (
     chainId: string,
-    sessionId: string,
+    sessionId: string
   ): Promise<void> => {
     return this.instance.post(
       `${this.v1()}/engine/chains/${chainId}/sessions/${sessionId}/retry`,
-      null,
+      null
     );
   };
 
   getFolder = async (folderId: string): Promise<FolderItem> => {
     const response = await this.instance.get<FolderItem>(
-      `${this.v2()}/folders/${folderId}`,
+      `${this.v2()}/folders/${folderId}`
     );
     return response.data;
   };
 
   getRootFolders = async (
     filter: string,
-    openedFolderId: string,
+    openedFolderId: string
   ): Promise<FolderItem[]> => {
     const response = await this.instance.get<FolderItem[]>(
       `${this.v1()}/catalog/folders/`,
       {
         params: {
           filter: filter,
-          openedFolderId: openedFolderId,
-        },
-      },
+          openedFolderId: openedFolderId
+        }
+      }
     );
     return response.data;
   };
 
   getPathToFolder = async (folderId: string): Promise<FolderItem[]> => {
     const response = await this.instance.get<FolderItem[]>(
-      `${this.v2()}/folders/${folderId}/path`,
+      `${this.v2()}/folders/${folderId}/path`
     );
     return response.data;
   };
 
   getPathToFolderByName = async (folderName: string): Promise<FolderItem[]> => {
     const response = await this.instance.get<FolderItem[]>(
-      `${this.v2()}/folders/path?name=${folderName}`,
+      `${this.v2()}/folders/path?name=${folderName}`
     );
     return response.data;
   };
@@ -1056,18 +1059,18 @@ export class RestApi implements Api {
   createFolder = async (request: CreateFolderRequest): Promise<FolderItem> => {
     const response = await this.instance.post<FolderItem>(
       `${this.v2()}/folders`,
-      request,
+      request
     );
     return response.data;
   };
 
   updateFolder = async (
     folderId: string,
-    changes: UpdateFolderRequest,
+    changes: UpdateFolderRequest
   ): Promise<FolderItem> => {
     const response = await this.instance.put<FolderItem>(
       `${this.v2()}/folders/${folderId}`,
-      changes,
+      changes
     );
     return response.data;
   };
@@ -1081,62 +1084,62 @@ export class RestApi implements Api {
   };
 
   listFolder = async (
-    request: ListFolderRequest,
+    request: ListFolderRequest
   ): Promise<(FolderItem | ChainItem)[]> => {
     const response = await this.instance.post<(FolderItem | ChainItem)[]>(
       `${this.v2()}/folders/list`,
-      request,
+      request
     );
     return response.data;
   };
 
   moveFolder = async (
     folderId: string,
-    targetFolderId?: string,
+    targetFolderId?: string
   ): Promise<FolderItem> => {
     const request: MoveFolderRequest = {
       id: folderId,
-      targetId: targetFolderId,
+      targetId: targetFolderId
     };
     const response = await this.instance.post<FolderItem>(
       `${this.v2()}/folders/move`,
-      request,
+      request
     );
     return response.data;
   };
 
   getNestedChains = async (folderId: string): Promise<Chain[]> => {
     const response = await this.instance.get<Chain[]>(
-      `${this.v1()}/catalog/folders/${folderId}/chains`,
+      `${this.v1()}/catalog/folders/${folderId}/chains`
     );
     return response.data;
   };
 
   getServicesUsedByChains = async (
-    chainIds: string[],
+    chainIds: string[]
   ): Promise<UsedService[]> => {
     const response = await this.instance.get<UsedService[]>(
       `${this.v1()}/catalog/chains/used-systems`,
       {
         params: { chainIds },
         paramsSerializer: {
-          indexes: null,
-        },
-      },
+          indexes: null
+        }
+      }
     );
     return response.data;
   };
 
   getChainsUsedByService = async (systemId: string): Promise<BaseEntity[]> => {
     const response = await this.instance.get<BaseEntity[]>(
-      `${this.v1()}/catalog/chains/systems/${systemId}`,
+      `${this.v1()}/catalog/chains/systems/${systemId}`
     );
     return response.data;
   };
 
   exportServices = async (
     serviceIds: string[],
-    modelIds: string[],
+    modelIds: string[]
   ): Promise<File> => {
     const formData: FormData = new FormData();
     if (serviceIds?.length) {
@@ -1151,17 +1154,17 @@ export class RestApi implements Api {
       {
         headers: {
           "Content-Type": "multipart/form-data",
-          accept: "*/*",
+          accept: "*/*"
         },
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     return getFileFromResponse(response);
   };
 
   exportSpecifications = async (
     specificationIds: string[],
-    specificationGroupId: string[],
+    specificationGroupId: string[]
   ): Promise<File> => {
     const params: Record<string, string> = {};
     if (specificationIds?.length) {
@@ -1175,10 +1178,10 @@ export class RestApi implements Api {
       {
         params,
         headers: {
-          accept: "*/*",
+          accept: "*/*"
         },
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     return getFileFromResponse(response);
   };
@@ -1190,7 +1193,7 @@ export class RestApi implements Api {
     httpTriggerIds: string[],
     externalRoutes: boolean,
     specificationType: ApiSpecificationType,
-    format: ApiSpecificationFormat,
+    format: ApiSpecificationFormat
   ): Promise<File> => {
     const params: Record<string, string> = {};
     if (deploymentIds?.length) {
@@ -1211,10 +1214,10 @@ export class RestApi implements Api {
       {
         params: { ...params, externalRoutes, specificationType, format },
         headers: {
-          accept: "*/*",
+          accept: "*/*"
         },
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     const contentType =
       (
@@ -1231,7 +1234,7 @@ export class RestApi implements Api {
         if (e instanceof RestApiError) throw e;
         throw new RestApiError(
           "Failed to generate API specification",
-          response.status,
+          response.status
         );
       }
     }
@@ -1240,13 +1243,13 @@ export class RestApi implements Api {
 
   getServices = async (
     modelType: string,
-    withSpec: boolean,
+    withSpec: boolean
   ): Promise<IntegrationSystem[]> => {
     const response = await this.instance.get<IntegrationSystem[]>(
       `${this.v1()}/systems-catalog/systems`,
       {
-        params: { modelType, withSpec },
-      },
+        params: { modelType, withSpec }
+      }
     );
     return response.data;
   };
@@ -1254,18 +1257,18 @@ export class RestApi implements Api {
   createService = async (system: SystemRequest): Promise<IntegrationSystem> => {
     const response = await this.instance.post<IntegrationSystem>(
       `${this.v1()}/systems-catalog/systems`,
-      system,
+      system
     );
     return response.data;
   };
 
   createEnvironment = async (
     systemId: string,
-    envRequest: EnvironmentRequest,
+    envRequest: EnvironmentRequest
   ): Promise<Environment> => {
     const response = await this.instance.post<Environment>(
       `${this.v1()}/systems-catalog/systems/${systemId}/environments`,
-      envRequest,
+      envRequest
     );
     return response.data;
   };
@@ -1273,27 +1276,27 @@ export class RestApi implements Api {
   updateEnvironment = async (
     systemId: string,
     environmentId: string,
-    envRequest: EnvironmentRequest,
+    envRequest: EnvironmentRequest
   ): Promise<Environment> => {
     const response = await this.instance.put<Environment>(
       `${this.v1()}/systems-catalog/systems/${systemId}/environments/${environmentId}`,
-      envRequest,
+      envRequest
     );
     return response.data;
   };
 
   deleteEnvironment = async (
     systemId: string,
-    environmentId: string,
+    environmentId: string
   ): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/systems-catalog/systems/${systemId}/environments/${environmentId}`,
+      `${this.v1()}/systems-catalog/systems/${systemId}/environments/${environmentId}`
     );
   };
 
   deleteService = async (serviceId: string): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/systems-catalog/systems/${serviceId}`,
+      `${this.v1()}/systems-catalog/systems/${serviceId}`
     );
   };
 
@@ -1306,9 +1309,9 @@ export class RestApi implements Api {
       {
         headers: {
           "Content-Type": "multipart/form-data",
-          accept: "*/*",
-        },
-      },
+          accept: "*/*"
+        }
+      }
     );
     return response.data;
   };
@@ -1316,7 +1319,7 @@ export class RestApi implements Api {
   commitImport = async (
     file: File,
     request?: ImportRequest,
-    validateByHash?: boolean,
+    validateByHash?: boolean
   ): Promise<ImportCommitResponse> => {
     const formData: FormData = new FormData();
     formData.append("file", file, file.name);
@@ -1332,16 +1335,16 @@ export class RestApi implements Api {
       {
         headers: {
           "Content-Type": "multipart/form-data",
-          accept: "*/*",
-        },
-      },
+          accept: "*/*"
+        }
+      }
     );
     return response.data;
   };
 
   getImportStatus = async (importId: string): Promise<ImportStatusResponse> => {
     const response = await this.instance.get<ImportStatusResponse>(
-      `${this.v3()}/import/${importId}`,
+      `${this.v3()}/import/${importId}`
     );
     return response.data;
   };
@@ -1351,95 +1354,95 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/events`,
       {
         params: {
-          lastEventId: lastEventId,
-        },
-      },
+          lastEventId: lastEventId
+        }
+      }
     );
     return response.data;
   };
 
   getDeploymentsByEngine = async (
     domain: string,
-    engineHost: string,
+    engineHost: string
   ): Promise<ChainDeployment[]> => {
     const response = await this.instance.get<ChainDeployment[]>(
-      `${this.v1()}/catalog/domains/${domain}/engines/${engineHost}/deployments`,
+      `${this.v1()}/catalog/domains/${domain}/engines/${engineHost}/deployments`
     );
     return response.data;
   };
 
   getEnginesByDomain = async (domain: string): Promise<Engine[]> => {
     const response = await this.instance.get<Engine[]>(
-      `${this.v1()}/catalog/domains/${domain}/engines`,
+      `${this.v1()}/catalog/domains/${domain}/engines`
     );
     return response.data;
   };
 
   loadCatalogActionsLog = async (
-    searchRequest: ActionLogSearchRequest,
+    searchRequest: ActionLogSearchRequest
   ): Promise<ActionLogResponse> => {
     const response = await this.instance.post<ActionLogResponse>(
       `${this.v1()}/catalog/actions-log`,
-      searchRequest,
+      searchRequest
     );
     return response.data;
   };
 
   exportCatalogActionsLog = async (
-    params: LogExportRequestParams,
+    params: LogExportRequestParams
   ): Promise<Blob> => {
     const response = await this.instance.get<Blob>(
       `${this.v1()}/catalog/actions-log/export`,
       {
         responseType: "blob",
-        params,
-      },
+        params
+      }
     );
     return response.data;
   };
 
   getContextServices = async (): Promise<ContextSystem[]> => {
     const response = await this.instance.get<ContextSystem[]>(
-      `${this.v1()}/catalog/context-system`,
+      `${this.v1()}/catalog/context-system`
     );
     const result = response.data;
     response.data.map(
-      (system) => (system.type = IntegrationSystemType.CONTEXT),
+      (system) => (system.type = IntegrationSystemType.CONTEXT)
     );
     return result;
   };
 
   getContextService = async (id: string): Promise<ContextSystem> => {
     const response = await this.instance.get<ContextSystem>(
-      `${this.v1()}/catalog/context-system/${id}`,
+      `${this.v1()}/catalog/context-system/${id}`
     );
     return response.data;
   };
 
   createContextService = async (
-    system: Pick<ContextSystem, "name" | "description">,
+    system: Pick<ContextSystem, "name" | "description">
   ): Promise<ContextSystem> => {
     const response = await this.instance.post<ContextSystem>(
       `${this.v1()}/catalog/context-system`,
-      system,
+      system
     );
     return response.data;
   };
 
   updateContextService = async (
     id: string,
-    data: Partial<ContextSystem>,
+    data: Partial<ContextSystem>
   ): Promise<ContextSystem> => {
     const response = await this.instance.put<ContextSystem>(
       `${this.v1()}/catalog/context-system/${id}`,
-      data,
+      data
     );
     return response.data;
   };
 
   deleteContextService = async (serviceId: string): Promise<void> => {
     await this.instance.delete(
-      `${this.v1()}/catalog/context-system/${serviceId}`,
+      `${this.v1()}/catalog/context-system/${serviceId}`
     );
   };
 
@@ -1454,108 +1457,108 @@ export class RestApi implements Api {
       {
         headers: {
           "Content-Type": "multipart/form-data",
-          accept: "*/*",
+          accept: "*/*"
         },
-        responseType: "blob",
-      },
+        responseType: "blob"
+      }
     );
     return getFileFromResponse(response);
   };
 
   getService = async (id: string): Promise<IntegrationSystem> => {
     const response = await this.instance.get<IntegrationSystem>(
-      `${this.v1()}/systems-catalog/systems/${id}`,
+      `${this.v1()}/systems-catalog/systems/${id}`
     );
     return response.data;
   };
 
   updateService = async (
     id: string,
-    data: Partial<IntegrationSystem>,
+    data: Partial<IntegrationSystem>
   ): Promise<IntegrationSystem> => {
     const response = await this.instance.put<IntegrationSystem>(
       `${this.v1()}/systems-catalog/systems/${id}`,
-      data,
+      data
     );
     return response.data;
   };
 
   getEnvironment = async (
     systemId: string,
-    environmentId: string,
+    environmentId: string
   ): Promise<Environment> => {
     const response = await this.instance.get<Environment>(
-      `/api/v1/${getAppName()}/systems-catalog/systems/${systemId}/environments/${environmentId}`,
+      `/api/v1/${getAppName()}/systems-catalog/systems/${systemId}/environments/${environmentId}`
     );
     return response.data;
   };
 
   getEnvironments = async (systemId: string): Promise<Environment[]> => {
     const response = await this.instance.get<Environment[]>(
-      `${this.v1()}/systems-catalog/systems/${systemId}/environments`,
+      `${this.v1()}/systems-catalog/systems/${systemId}/environments`
     );
     return response.data;
   };
 
   getApiSpecifications = async (
-    systemId: string,
+    systemId: string
   ): Promise<SpecificationGroup[]> => {
     const response = await this.instance.get<SpecificationGroup[]>(
       `${this.v1()}/systems-catalog/specificationGroups`,
       {
         params: {
-          systemId: systemId,
-        },
-      },
+          systemId: systemId
+        }
+      }
     );
     return response.data;
   };
 
   getLatestApiSpecification = async (
-    systemId: string,
+    systemId: string
   ): Promise<Specification> => {
     const response = await this.instance.get<Specification>(
       `${this.v1()}/systems-catalog/models/latest`,
       {
         params: {
-          systemId: systemId,
-        },
-      },
+          systemId: systemId
+        }
+      }
     );
     return response.data;
   };
 
   updateApiSpecificationGroup = async (
     id: string,
-    data: Partial<SpecificationGroup>,
+    data: Partial<SpecificationGroup>
   ): Promise<SpecificationGroup> => {
     const response = await this.instance.patch<SpecificationGroup>(
       `${this.v1()}/systems-catalog/specificationGroups/${id}`,
-      data,
+      data
     );
     return response.data;
   };
 
   deleteSpecificationGroup = async (id: string): Promise<void> => {
     await this.instance.delete<SpecificationGroup>(
-      `${this.v1()}/systems-catalog/specificationGroups/${id}`,
+      `${this.v1()}/systems-catalog/specificationGroups/${id}`
     );
   };
 
   updateSpecificationModel = async (
     id: string,
-    data: Partial<Specification>,
+    data: Partial<Specification>
   ): Promise<Specification> => {
     const response = await this.instance.patch<Specification>(
       `${this.v1()}/systems-catalog/models/${id}`,
-      data,
+      data
     );
     return response.data;
   };
 
   getSpecificationModelSource = async (id: string): Promise<string> => {
     const response = await this.instance.get<string>(
-      `${this.v1()}/systems-catalog/models/${id}/source`,
+      `${this.v1()}/systems-catalog/models/${id}/source`
     );
     return response.data;
   };
@@ -1566,16 +1569,16 @@ export class RestApi implements Api {
 
   getSpecificationModel = async (
     systemId?: string,
-    specificationGroupId?: string,
+    specificationGroupId?: string
   ): Promise<Specification[]> => {
     const response = await this.instance.get<Specification[]>(
       `${this.v1()}/systems-catalog/models`,
       {
         params: {
           systemId: systemId,
-          specificationGroupId: specificationGroupId,
-        },
-      },
+          specificationGroupId: specificationGroupId
+        }
+      }
     );
     return response.data;
   };
@@ -1585,15 +1588,15 @@ export class RestApi implements Api {
       `${this.v1()}/systems-catalog/models/deprecated`,
       modelId,
       {
-        headers: { "Content-Type": "text/plain" },
-      },
+        headers: { "Content-Type": "text/plain" }
+      }
     );
     return response.data;
   };
 
   getOperations = async (
     modelId: string,
-    paginationOptions: PaginationOptions = {},
+    paginationOptions: PaginationOptions = {}
   ): Promise<SystemOperation[]> => {
     const params: Record<string, string> = { modelId };
 
@@ -1606,14 +1609,14 @@ export class RestApi implements Api {
 
     const response = await this.instance.get<SystemOperation[]>(
       `${this.v1()}/systems-catalog/operations`,
-      { params },
+      { params }
     );
     return response.data;
   };
 
   getOperationInfo = async (operationId: string): Promise<OperationInfo> => {
     const response = await this.instance.get<OperationInfo>(
-      `${this.v1()}/systems-catalog/operations/${encodeURIComponent(operationId)}/info`,
+      `${this.v1()}/systems-catalog/operations/${encodeURIComponent(operationId)}/info`
     );
     return response.data;
   };
@@ -1625,7 +1628,7 @@ export class RestApi implements Api {
     deployLabel?: string,
     packageName?: string,
     packageVersion?: string,
-    packagePartOf?: string,
+    packagePartOf?: string
   ): Promise<ImportSystemResult[]> => {
     const formData = new FormData();
     formData.append("file", file);
@@ -1652,29 +1655,29 @@ export class RestApi implements Api {
       {
         headers: {
           ...headers,
-          "Content-Type": "multipart/form-data",
-        },
-      },
+          "Content-Type": "multipart/form-data"
+        }
+      }
     );
     return response.data;
   };
 
   importSpecification = async (
     specificationGroupId: string,
-    files: File[],
+    files: File[]
   ): Promise<ImportSpecificationResult> => {
     const formData = new FormData();
     files.forEach((file) => formData.append("files", file));
     const params: Record<string, string> = {
-      specificationGroupId: specificationGroupId,
+      specificationGroupId: specificationGroupId
     };
     const response = await this.instance.post<ImportSpecificationResult>(
       `${this.v1()}/systems-catalog/import`,
       formData,
       {
         params,
-        headers: { "Content-Type": "multipart/form-data" },
-      },
+        headers: { "Content-Type": "multipart/form-data" }
+      }
     );
     return response.data;
   };
@@ -1683,13 +1686,13 @@ export class RestApi implements Api {
     systemId: string,
     name: string,
     files: File[],
-    protocol?: string,
+    protocol?: string
   ): Promise<ImportSpecificationResult> => {
     const formData: FormData = new FormData();
     files.forEach((file) => formData.append("files", file, file.name));
     const params: Record<string, string> = {
       systemId: systemId,
-      name: name,
+      name: name
     };
     if (protocol) params.protocol = protocol;
     const response = await this.instance.post<ImportSpecificationResult>(
@@ -1697,51 +1700,51 @@ export class RestApi implements Api {
       formData,
       {
         params,
-        headers: { "Content-Type": "multipart/form-data" },
-      },
+        headers: { "Content-Type": "multipart/form-data" }
+      }
     );
     return response.data;
   };
 
   getImportSpecificationResult = async (
-    importId: string,
+    importId: string
   ): Promise<ImportSpecificationResult> => {
     const response = await this.instance.get<ImportSpecificationResult>(
-      `${this.v1()}/systems-catalog/import/${importId}`,
+      `${this.v1()}/systems-catalog/import/${importId}`
     );
     return response.data;
   };
 
   getDetailedDesignTemplates = async (
-    includeContent: boolean,
+    includeContent: boolean
   ): Promise<DetailedDesignTemplate[]> => {
     const response = await this.instance.get<DetailedDesignTemplate[]>(
       `${this.v1()}/catalog/detailed-design/templates`,
       {
         params: {
-          includeContent,
-        },
-      },
+          includeContent
+        }
+      }
     );
     return response.data;
   };
 
   getDetailedDesignTemplate = async (
-    templateId: string,
+    templateId: string
   ): Promise<DetailedDesignTemplate> => {
     const response = await this.instance.get<DetailedDesignTemplate>(
-      `${this.v1()}/catalog/detailed-design/templates/${templateId}`,
+      `${this.v1()}/catalog/detailed-design/templates/${templateId}`
     );
     return response.data;
   };
 
   createOrUpdateDetailedDesignTemplate = async (
     name: string,
-    content: string,
+    content: string
   ): Promise<DetailedDesignTemplate> => {
     const response = await this.instance.put<DetailedDesignTemplate>(
       `${this.v1()}/catalog/detailed-design/templates`,
-      { name, content },
+      { name, content }
     );
     return response.data;
   };
@@ -1751,36 +1754,36 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/detailed-design/templates`,
       {
         params: {
-          ids,
-        },
-      },
+          ids
+        }
+      }
     );
   };
 
   getChainDetailedDesign = async (
     chainId: string,
-    templateId: string,
+    templateId: string
   ): Promise<ChainDetailedDesign> => {
     const response = await this.instance.get<ChainDetailedDesign>(
       `${this.v1()}/catalog/detailed-design/chains/${chainId}`,
       {
         params: {
-          templateId,
-        },
-      },
+          templateId
+        }
+      }
     );
     return response.data;
   };
 
   getChainSequenceDiagram = async (
     chainId: string,
-    diagramModes: DiagramMode[],
+    diagramModes: DiagramMode[]
   ): Promise<ElementsSequenceDiagrams> => {
     const response = await this.instance.post<ElementsSequenceDiagrams>(
       `${this.v1()}/catalog/design-generator/chains/${chainId}`,
       {
-        diagramModes,
-      },
+        diagramModes
+      }
     );
     return response.data;
   };
@@ -1788,13 +1791,13 @@ export class RestApi implements Api {
   getSnapshotSequenceDiagram = async (
     chainId: string,
     snapshotId: string,
-    diagramModes: DiagramMode[],
+    diagramModes: DiagramMode[]
   ): Promise<ElementsSequenceDiagrams> => {
     const response = await this.instance.post<ElementsSequenceDiagrams>(
       `${this.v1()}/catalog/design-generator/chains/${chainId}/snapshots/${snapshotId}`,
       {
-        diagramModes,
-      },
+        diagramModes
+      }
     );
     return response.data;
   };
@@ -1806,28 +1809,28 @@ export class RestApi implements Api {
   readSpecificationFileContent = (): Promise<string> => {
     return Promise.reject(
       new Error(
-        "Method readSpecificationFileContent not implemented in RestApi",
-      ),
+        "Method readSpecificationFileContent not implemented in RestApi"
+      )
     );
   };
 
   groupElements = async (
     chainId: string,
-    elementIds: string[],
+    elementIds: string[]
   ): Promise<Element> => {
     const response = await this.instance.post<Element>(
       `${this.v1()}/catalog/chains/${chainId}/elements/groups`,
-      elementIds,
+      elementIds
     );
     return response.data;
   };
 
   ungroupElements = async (
     chainId: string,
-    groupId: string,
+    groupId: string
   ): Promise<Element[]> => {
     const response = await this.instance.delete<Element[]>(
-      `${this.v1()}/catalog/chains/${chainId}/elements/groups/${groupId}`,
+      `${this.v1()}/catalog/chains/${chainId}/elements/groups/${groupId}`
     );
     return response.data;
   };
@@ -1837,9 +1840,9 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/live-exchanges`,
       {
         params: {
-          limit: limit,
-        },
-      },
+          limit: limit
+        }
+      }
     );
     return response.status === 204 ? [] : response.data;
   };
@@ -1847,10 +1850,10 @@ export class RestApi implements Api {
   terminateExchange = async (
     podIp: string,
     deploymentId: string,
-    exchangeId: string,
+    exchangeId: string
   ): Promise<void> => {
     await this.instance.delete<void>(
-      `${this.v1()}/catalog/live-exchanges/${podIp}/${deploymentId}/${exchangeId}`,
+      `${this.v1()}/catalog/live-exchanges/${podIp}/${deploymentId}/${exchangeId}`
     );
   };
 
@@ -1860,20 +1863,28 @@ export class RestApi implements Api {
 
   getValidations = async (
     filters: EntityFilterModel[],
-    searchString: string,
+    searchString: string
   ): Promise<DiagnosticValidation[]> => {
     const response = await this.instance.post<DiagnosticValidation[]>(
       `${this.v1()}/catalog/diagnostic/validations`,
-      { searchString, filters },
+      { searchString, filters }
+    );
+    return response.data;
+  };
+
+  buildCR = async (request: CustomResourceBuildRequest): Promise<string> => {
+    const response = await this.instance.post<string>(
+      `${this.v1()}/catalog/cr`,
+      request
     );
     return response.data;
   };
 
   getValidation = async (
-    validationId: string,
+    validationId: string
   ): Promise<DiagnosticValidation> => {
     const response = await this.instance.get<DiagnosticValidation>(
-      `${this.v1()}/catalog/diagnostic/validations/${validationId}`,
+      `${this.v1()}/catalog/diagnostic/validations/${validationId}`
     );
     return response.data;
   };
@@ -1883,58 +1894,93 @@ export class RestApi implements Api {
       `${this.v1()}/catalog/diagnostic/validations`,
       undefined,
       {
-        params: { validationIds: ids },
-      },
+        params: { validationIds: ids }
+      }
     );
   };
 
   bulkDeploy = async (
-    request: BulkDeploymentRequest,
+    request: BulkDeploymentRequest
   ): Promise<BulkDeploymentResult[]> => {
     const response = await this.instance.post<BulkDeploymentResult[]>(
       `${this.v1()}/catalog/chains/deployments/bulk`,
-      request,
+      request
     );
     return response.data;
   };
 
   getUsedProperties = async (chainId: string): Promise<UsedProperty[]> => {
     const response = await this.instance.get<UsedProperty[]>(
-      `${this.v1()}/catalog/chains/${chainId}/elements/properties/used`,
+      `${this.v1()}/catalog/chains/${chainId}/elements/properties/used`
     );
 
     return response.data;
   };
 
   loadHttpTriggerAccessControl = async (
-    searchRequest: AccessControlSearchRequest,
+    searchRequest: AccessControlSearchRequest
   ): Promise<AccessControlResponse> => {
     const response = await this.instance.post<AccessControlResponse>(
       `${this.v1()}/catalog/chains/roles`,
-      searchRequest,
+      searchRequest
     );
     return response.data;
   };
 
   updateHttpTriggerAccessControl = async (
-    searchRequest: AccessControlUpdateRequest[],
+    searchRequest: AccessControlUpdateRequest[]
   ): Promise<AccessControlResponse> => {
     const response = await this.instance.put<AccessControlResponse>(
       `${this.v1()}/catalog/chains/roles`,
-      searchRequest,
+      searchRequest
     );
 
     return response.data;
   };
 
   bulkDeployChainsAccessControl = async (
-    searchRequest: AccessControlBulkDeployRequest[],
+    searchRequest: AccessControlBulkDeployRequest[]
   ): Promise<AccessControlResponse> => {
     const response = await this.instance.put<AccessControlResponse>(
       `${this.v1()}/catalog/chains/roles/redeploy`,
-      searchRequest,
+      searchRequest
     );
 
     return response.data;
   };
+
+  deployToMicroDomain = async (
+    request: BulkMicroDomainDeployResult
+  ): Promise<BulkDeploymentResult[]> => {
+    const response = await this.instance.post<BulkDeploymentResult[]>(
+      `${this.v1()}/catalog/cr/deploy-chains`,
+      request
+    );
+    return response.data;
+  };
+
+  deploySnapshotsToMicroDomain = async (
+    request: MicroDomainDeployRequest
+  ): Promise<void> => {
+    const response = await this.instance.post<void>(
+      `${this.v1()}/catalog/cr/deploy`,
+      request
+    );
+    return response.data;
+  };
+
+  deleteMicroDomain = async (name: string): Promise<void> => {
+    await this.instance.delete<void>(
+      `${this.v1()}/catalog/cr/${name}`
+    );
+  };
+
+  deleteSnapshotFromMicroDomain = async (
+    name: string,
+    chainId: string
+  ): Promise<void> => {
+    await this.instance.delete<void>(
+      `${this.v1()}/catalog/cr/${name}/${chainId}`
+    );
+  };
 }
diff --git a/src/api/rest/vscodeExtensionApi.ts b/src/api/rest/vscodeExtensionApi.ts
index aea6111c..c968d41e 100644
--- a/src/api/rest/vscodeExtensionApi.ts
+++ b/src/api/rest/vscodeExtensionApi.ts
@@ -918,6 +918,10 @@ export class VSCodeExtensionApi implements Api {
     throw new Error("Method moveFolder not implemented.");
   }
 
+  buildCR(): Promise<string> {
+    throw new Error("Method buildCR not implemented.");
+  }
+
   getSpecApiFiles = async (): Promise<SpecApiFile[]> => {
     return <SpecApiFile[]>(
       (await this.sendMessageToExtension("getSpecApiFiles")).payload
@@ -1070,6 +1074,18 @@ export class VSCodeExtensionApi implements Api {
   getUsedProperties(_chainId: string): Promise<UsedProperty[]> {
     throw new Error("Method loadHttpTriggerAccessControl not implemented.");
   }
+  deployToMicroDomain(): Promise<BulkDeploymentResult[]> {
+    throw new Error("Method deployToMicroDomain not implemented.");
+  }
+  deploySnapshotsToMicroDomain(): Promise<void> {
+    throw new Error("Method deploySnapshotsToMicroDomain not implemented.");
+  }
+  deleteMicroDomain(): Promise<void> {
+    throw new Error("Method deleteMicroDomain not implemented.");
+  }
+  deleteSnapshotFromMicroDomain(): Promise<void> {
+    throw new Error("Method deleteSnapshotFromMicroDomain not implemented.");
+  }
 }
 
 interface VSCodeApi<T> {
diff --git a/src/components/SelectDomains.tsx b/src/components/SelectDomains.tsx
new file mode 100644
index 00000000..9c506d08
--- /dev/null
+++ b/src/components/SelectDomains.tsx
@@ -0,0 +1,65 @@
+import React, { useCallback } from "react";
+import { Select, Space, Tag } from "antd";
+import { useDomains } from "../hooks/useDomains.tsx";
+import { LabelInValueType } from "rc-select/lib/Select";
+import type { FlattenOptionData } from "rc-select/lib/interface";
+import { DomainType, EngineDomain } from "../api/apiTypes.ts";
+
+export type Domain = {
+  name: string;
+  type: DomainType;
+};
+
+export type SelectDomainsProperties = {
+  value?: Domain[];
+  onChange?: (value: Domain[]) => void;
+};
+
+function getDomainType(
+  domainId: string,
+  domains: EngineDomain[],
+): DomainType {
+  return (
+    domains.find((domain) => domainId === domain.id)?.type ?? DomainType.MICRO
+  );
+}
+
+export const SelectDomains: React.FC<SelectDomainsProperties> = ({
+  value,
+  onChange,
+}) => {
+  const { isLoading: isDomainsLoading, domains } = useDomains();
+
+  const renderOption = useCallback(
+    (props: LabelInValueType | FlattenOptionData<unknown>) => {
+      const domainType = getDomainType(props.value?.toString() ?? "", domains);
+      return domainType === DomainType.MICRO ? (
+        <Space size={"small"}>
+          <Tag>micro</Tag>
+          <span>{props.value}</span>
+        </Space>
+      ) : (
+        props.label
+      );
+    },
+    [domains],
+  );
+
+  return (
+    <Select
+      value={value?.map(domain => domain.name)}
+      loading={isDomainsLoading}
+      mode="tags"
+      allowClear
+      labelRender={renderOption}
+      optionRender={renderOption}
+      options={domains.map((domain) => ({
+        value: domain.id,
+        label: domain.name
+      }))}
+      onChange={(values) => {
+        onChange?.(values.map(name =>({ name, type: getDomainType(name, domains )})));
+      }}
+    ></Select>
+  );
+};
diff --git a/src/components/admin_tools/domains/DomainsTable.tsx b/src/components/admin_tools/domains/DomainsTable.tsx
index 96b9f360..80141fd6 100644
--- a/src/components/admin_tools/domains/DomainsTable.tsx
+++ b/src/components/admin_tools/domains/DomainsTable.tsx
@@ -1,10 +1,13 @@
-import React from "react";
-import { Table, Button, Typography } from "antd";
+import React, { useCallback, useEffect, useState } from "react";
+import { Table, Button, Typography, Space, Tag } from "antd";
 import type { ColumnsType } from "antd/es/table";
 import { EngineTable } from "./EngineTable";
 import { useEngines } from "./hooks/useEngines";
 import tableStyles from "./Tables.module.css";
-import { EngineDomain } from "../../../api/apiTypes.ts";
+import { DomainType, EngineDomain } from "../../../api/apiTypes.ts";
+import { OverridableIcon } from "../../../icons/IconProvider.tsx";
+import { useNotificationService } from "../../../hooks/useNotificationService.tsx";
+import { api } from "../../../api/api.ts";
 
 interface Props {
   domains: EngineDomain[];
@@ -33,11 +36,49 @@ const EnginesForDomain: React.FC<{ domain: EngineDomain }> = ({ domain }) => {
 };
 
 const DomainsTable: React.FC<Props> = ({ domains, isLoading = false }) => {
+  const notificationsService = useNotificationService();
+  const [tableData, setTableData] = useState<EngineDomain[]>([]);
+
+  useEffect(() => {
+    setTableData(domains);
+  }, [domains]);
+
+  const deleteMicroDomain = useCallback(
+    async (name: string) => {
+      try {
+        await api.deleteMicroDomain(name);
+        setTableData((items) => items.filter((domain) => domain.name !== name));
+      } catch (e) {
+        notificationsService.requestFailed(
+          `Failed to delete micro domain ${name}`,
+          e,
+        );
+      }
+    },
+    [notificationsService],
+  );
+
   const columns: ColumnsType<EngineDomain> = [
     {
       title: <span className={tableStyles.columnHeader}>Domain</span>,
       dataIndex: "name",
       key: "name",
+      render: (_: unknown, domain: EngineDomain) => {
+        return domain.type === DomainType.MICRO ? (
+          <Space size={"small"}>
+            {domain.name}
+            <Tag>micro</Tag>
+            <Button
+              size={"small"}
+              type={"text"}
+              icon={<OverridableIcon name="delete" />}
+              onClick={() => void deleteMicroDomain(domain.name)}
+            />
+          </Space>
+        ) : (
+          domain.name
+        );
+      },
     },
     {
       title: <span className={tableStyles.columnHeader}>Version</span>,
@@ -63,7 +104,7 @@ const DomainsTable: React.FC<Props> = ({ domains, isLoading = false }) => {
 
   const [expandedRowKeys, setExpandedRowKeys] = React.useState<React.Key[]>([]);
 
-  React.useEffect(() => {
+  useEffect(() => {
     if (domains.length > 0) {
       setExpandedRowKeys(domains.map((domain) => domain.id));
     }
@@ -72,7 +113,7 @@ const DomainsTable: React.FC<Props> = ({ domains, isLoading = false }) => {
   return (
     <Table
       columns={columns}
-      dataSource={domains}
+      dataSource={tableData}
       loading={isLoading}
       pagination={false}
       className={tableStyles.mainTable}
diff --git a/src/components/modal/DeployChains.tsx b/src/components/modal/DeployChains.tsx
index 30893ace..fc7b20ec 100644
--- a/src/components/modal/DeployChains.tsx
+++ b/src/components/modal/DeployChains.tsx
@@ -1,22 +1,24 @@
 import React, { useState } from "react";
-import { BulkDeploymentSnapshotAction } from "../../api/apiTypes.ts";
+import {
+  BulkDeploymentSnapshotAction,
+  DomainType,
+} from "../../api/apiTypes.ts";
 import { useModalContext } from "../../ModalContextProvider.tsx";
 import { Modal, Button, Form, Select } from "antd";
-import { useDomains } from "../../hooks/useDomains.tsx";
+import { Domain, SelectDomains } from "../SelectDomains.tsx";
 
-export type DeployOptions = {
-  domains: string[];
+export type DeployRequest = {
+  domains: Domain[];
   snapshotAction: BulkDeploymentSnapshotAction;
 };
 
 type DeployChainsProps = {
-  onSubmit?: (options: DeployOptions) => void;
+  onSubmit?: (options: DeployRequest) => void;
 };
 
 export const DeployChains: React.FC<DeployChainsProps> = ({ onSubmit }) => {
   const { closeContainingModal } = useModalContext();
   const [confirmLoading, setConfirmLoading] = useState(false);
-  const { isLoading: isDomainsLoading, domains } = useDomains();
 
   return (
     <Modal
@@ -38,13 +40,13 @@ export const DeployChains: React.FC<DeployChainsProps> = ({ onSubmit }) => {
         </Button>,
       ]}
     >
-      <Form<DeployOptions>
+      <Form<DeployRequest>
         labelWrap
         labelCol={{ flex: "150px" }}
         wrapperCol={{ flex: "auto" }}
         id="deployOptionsForm"
         initialValues={{
-          domains: ["default"],
+          domains: [{ name: "default", type: DomainType.NATIVE }],
           snapshotAction: BulkDeploymentSnapshotAction.CREATE_NEW,
         }}
         onFinish={(values) => {
@@ -62,15 +64,7 @@ export const DeployChains: React.FC<DeployChainsProps> = ({ onSubmit }) => {
           label={"Engine domains"}
           rules={[{ required: true }]}
         >
-          <Select
-            loading={isDomainsLoading}
-            mode="multiple"
-            allowClear
-            options={domains.map((domain) => ({
-              value: domain.id,
-              label: domain.name,
-            }))}
-          />
+          <SelectDomains />
         </Form.Item>
         <Form.Item name="snapshotAction" label={"Snapshot action"}>
           <Select
diff --git a/src/components/modal/DeploymentCreate.tsx b/src/components/modal/DeploymentCreate.tsx
index a9b11f0b..019deb3b 100644
--- a/src/components/modal/DeploymentCreate.tsx
+++ b/src/components/modal/DeploymentCreate.tsx
@@ -1,49 +1,45 @@
 import { Button, Form, Modal, Select, SelectProps } from "antd";
 import React, { useState } from "react";
 import { useModalContext } from "../../ModalContextProvider.tsx";
-import { useDomains } from "../../hooks/useDomains.tsx";
 import { useSnapshots } from "../../hooks/useSnapshots.tsx";
-import { CreateDeploymentRequest } from "../../api/apiTypes.ts";
+import { DomainType } from "../../api/apiTypes.ts";
+import { Domain, SelectDomains } from "../SelectDomains.tsx";
 
-type Props = {
+export type CreateDeploymentOptions = {
+  domains: Domain[];
+  snapshotId: string;
+};
+
+type CreateDeploymentProps = {
   chainId?: string;
-  onSubmit?: (request: CreateDeploymentRequest) => void | Promise<void>;
+  onSubmit?: (request: CreateDeploymentOptions) => void | Promise<void>;
 };
 
-export const DeploymentCreate: React.FC<Props> = ({ chainId, onSubmit }) => {
+export const DeploymentCreate: React.FC<CreateDeploymentProps> = ({
+  chainId,
+  onSubmit,
+}) => {
   const [form] = Form.useForm();
   const [confirmLoading, setConfirmLoading] = useState(false);
   const { closeContainingModal } = useModalContext();
-  const { isLoading: domainsLoading, domains } = useDomains();
   const { isLoading: snapshotsLoading, snapshots } = useSnapshots(chainId);
 
-  const domainOptions: SelectProps["options"] = domains
-    ?.sort((d1, d2) => d1.name.localeCompare(d2.name))
-    .map((domain) => ({
-      label: domain.name,
-      value: domain.id,
-    }));
-
   const snapshotOptions: SelectProps["options"] =
     snapshots
-      ?.sort((s1, s2) => s2.modifiedWhen - s1.modifiedWhen)
+      ?.sort((s1, s2) => (s2.modifiedWhen ?? 0) - (s1.modifiedWhen ?? 0))
       .map((snapshot) => ({
         label: snapshot.name,
         value: snapshot.id,
       })) ?? [];
 
-  const handleOk = (domain: string, snapshotId: string) => {
+  const handleOk = (domains: Domain[], snapshotId: string) => {
     if (!chainId) {
       return;
     }
     setConfirmLoading(true);
-    const request: CreateDeploymentRequest = {
-      domain,
-      snapshotId,
-      suspended: false,
-    };
+    const options: CreateDeploymentOptions = { domains, snapshotId };
     try {
-      const result = onSubmit?.(request);
+      const result = onSubmit?.(options);
       if (result instanceof Promise) {
         void result.finally(() => {
           setConfirmLoading(false);
@@ -79,27 +75,32 @@ export const DeploymentCreate: React.FC<Props> = ({ chainId, onSubmit }) => {
           form="deploymentCreateForm"
           htmlType={"submit"}
           loading={confirmLoading}
-          disabled={domainsLoading || snapshotsLoading}
+          disabled={snapshotsLoading}
         >
           Deploy
         </Button>,
       ]}
     >
-      <Form<{ domain: string; snapshot: string }>
+      <Form<{ domains: Domain[]; snapshot: string }>
         id="deploymentCreateForm"
         form={form}
-        onFinish={(values) => handleOk(values.domain, values.snapshot)}
+        initialValues={{
+          domains: [{ name: "default", type: DomainType.NATIVE }],
+        }}
+        onFinish={(values) => handleOk(values.domains, values.snapshot)}
         layout="horizontal"
         labelCol={{ span: 4 }}
         style={{ maxWidth: 600 }}
-        disabled={domainsLoading || snapshotsLoading}
+        disabled={snapshotsLoading}
       >
         <Form.Item
-          label="Domain"
-          name="domain"
-          rules={[{ required: true, message: "Please specify a domain" }]}
+          label="Domains"
+          name="domains"
+          rules={[
+            { required: true, message: "Please specify at least one domain" },
+          ]}
         >
-          <Select options={domainOptions} loading={domainsLoading} />
+          <SelectDomains />
         </Form.Item>
         <Form.Item
           label="Snapshot"
diff --git a/src/components/modal/SaveAndDeploy.tsx b/src/components/modal/SaveAndDeploy.tsx
index 6435b2da..6cd8c287 100644
--- a/src/components/modal/SaveAndDeploy.tsx
+++ b/src/components/modal/SaveAndDeploy.tsx
@@ -1,15 +1,16 @@
 import React, { useState } from "react";
-import { Button, Form, Modal, Select, SelectProps } from "antd";
+import { Button, Form, Modal } from "antd";
 import { useModalContext } from "../../ModalContextProvider.tsx";
-import { useDomains } from "../../hooks/useDomains.tsx";
+import { Domain, SelectDomains } from "../SelectDomains.tsx";
+import { DomainType } from "../../api/apiTypes.ts";
 
 export type SaveAndDeployProps = {
   chainId?: string;
-  onSubmit?: (domain: string) => void | Promise<void>;
+  onSubmit?: (domains: Domain[]) => void | Promise<void>;
 };
 
 type SaveAndDeployFormData = {
-  domain: string;
+  domains: Domain[];
 };
 
 export const SaveAndDeploy: React.FC<SaveAndDeployProps> = ({
@@ -19,14 +20,6 @@ export const SaveAndDeploy: React.FC<SaveAndDeployProps> = ({
   const [form] = Form.useForm();
   const [confirmLoading, setConfirmLoading] = useState(false);
   const { closeContainingModal } = useModalContext();
-  const { isLoading: domainsLoading, domains } = useDomains();
-
-  const domainOptions: SelectProps["options"] = domains
-    ?.sort((d1, d2) => d1.name.localeCompare(d2.name))
-    .map((domain) => ({
-      label: domain.name,
-      value: domain.id,
-    }));
 
   const handleSubmit = (data: SaveAndDeployFormData) => {
     if (!chainId) {
@@ -34,7 +27,7 @@ export const SaveAndDeploy: React.FC<SaveAndDeployProps> = ({
     }
     setConfirmLoading(true);
     try {
-      const result = onSubmit?.(data.domain);
+      const result = onSubmit?.(data.domains);
       if (result instanceof Promise) {
         void result.finally(() => {
           setConfirmLoading(false);
@@ -75,18 +68,22 @@ export const SaveAndDeploy: React.FC<SaveAndDeployProps> = ({
         id="saveAndDeployForm"
         form={form}
         layout="horizontal"
+        initialValues={{
+          domains: [{ name: "default", type: DomainType.NATIVE }],
+        }}
         labelCol={{ span: 4 }}
         style={{ maxWidth: 600 }}
-        disabled={domainsLoading}
         labelWrap
         onFinish={(values) => handleSubmit(values)}
       >
         <Form.Item
-          label="Domain"
-          name="domain"
-          rules={[{ required: true, message: "Please specify a domain" }]}
+          label="Domains"
+          name="domains"
+          rules={[
+            { required: true, message: "Please specify at least one domain" },
+          ]}
         >
-          <Select options={domainOptions} loading={domainsLoading} />
+          <SelectDomains />
         </Form.Item>
       </Form>
     </Modal>
diff --git a/src/icons/IconDefenitions.tsx b/src/icons/IconDefenitions.tsx
index aa91d49e..04dcded7 100644
--- a/src/icons/IconDefenitions.tsx
+++ b/src/icons/IconDefenitions.tsx
@@ -105,6 +105,7 @@ import {
   BulbOutlined,
   BarChartOutlined,
   ToolOutlined,
+  KubernetesOutlined,
   RightSquareOutlined,
   MenuUnfoldOutlined,
   InfoCircleOutlined,
@@ -182,6 +183,7 @@ export const commonIcons = {
   solution: SolutionOutlined,
   columnHeight: ColumnHeightOutlined,
   verticalAlignMiddle: VerticalAlignMiddleOutlined,
+  kubernetes: KubernetesOutlined,
   database: DatabaseOutlined,
   fullscreen: FullscreenOutlined,
   fullscreenExit: FullscreenExitOutlined,
diff --git a/src/pages/ChainGraph.tsx b/src/pages/ChainGraph.tsx
index b5d9883c..5704739c 100644
--- a/src/pages/ChainGraph.tsx
+++ b/src/pages/ChainGraph.tsx
@@ -40,7 +40,12 @@ import { ElkDirectionContextProvider } from "./ElkDirectionContext.tsx";
 import { useElkDirection } from "../hooks/graph/useElkDirection.tsx";
 import { PageWithRightPanel } from "./PageWithRightPanel.tsx";
 import { SaveAndDeploy } from "../components/modal/SaveAndDeploy.tsx";
-import { CreateDeploymentRequest, Element } from "../api/apiTypes.ts";
+import {
+  CreateDeploymentRequest,
+  DeployMode,
+  DomainType,
+  Element,
+} from "../api/apiTypes.ts";
 import { api } from "../api/api.ts";
 import { useNotificationService } from "../hooks/useNotificationService.tsx";
 import { SequenceDiagram } from "../components/modal/SequenceDiagram.tsx";
@@ -62,6 +67,7 @@ import {
 import { downloadFile, mergeZipArchives } from "../misc/download-utils.ts";
 import { exportAdditionsForChains } from "../misc/export-additions.ts";
 import { generateSequenceDiagrams } from "../diagrams/main.ts";
+import { Domain } from "../components/SelectDomains.tsx";
 
 const readTheme = () => {
   if (typeof document === "undefined") return "light";
@@ -239,23 +245,35 @@ const ChainGraphInner: React.FC = () => {
     ],
   );
 
-  const saveAndDeploy = async (domain: string) => {
-    if (!chainId) return;
+  const saveAndDeploy = async (domains: Domain[]) => {
+    if (!chainId || domains.length === 0) return;
     try {
       await api.createSnapshot(chainId).then(async (snapshot) => {
         notificationService.info(
           "Created snapshot",
           `Created snapshot ${snapshot.name}`,
         );
-        const request: CreateDeploymentRequest = {
-          domain,
-          snapshotId: snapshot.id,
-          suspended: false,
-        };
-        await api.createDeployment(chainId, request);
-        notificationService.info(
-          "Deployed snapshot",
-          `Deployed snapshot ${snapshot.name}`,
+        await Promise.all(
+          domains.map(async (domain) => {
+            if (domain.type === DomainType.MICRO) {
+              await api.deploySnapshotsToMicroDomain({
+                name: domain.name,
+                snapshotIds: [snapshot.id],
+                mode: DeployMode.APPEND,
+              });
+            } else {
+              const request: CreateDeploymentRequest = {
+                domain: domain.name,
+                snapshotId: snapshot.id,
+                suspended: false,
+              };
+              await api.createDeployment(chainId, request);
+            }
+            notificationService.info(
+              "Deployed snapshot",
+              `Deployed snapshot ${snapshot.name}`,
+            );
+          }),
         );
       });
     } catch (error) {
diff --git a/src/pages/Chains.tsx b/src/pages/Chains.tsx
index 851bf05f..b40c064c 100644
--- a/src/pages/Chains.tsx
+++ b/src/pages/Chains.tsx
@@ -16,6 +16,7 @@ import {
   CatalogItemType,
   ChainCreationRequest,
   ChainItem,
+  DeployMode,
   FolderItem,
   ListFolderRequest,
   UpdateFolderRequest,
@@ -51,8 +52,9 @@ import styles from "./Chains.module.css";
 import { OverridableIcon } from "../icons/IconProvider.tsx";
 import {
   DeployChains,
-  DeployOptions,
+  DeployRequest,
 } from "../components/modal/DeployChains.tsx";
+import { Domain } from "../components/SelectDomains.tsx";
 
 type ChainTableItem = (FolderItem | ChainItem) & {
   children?: ChainTableItem[];
@@ -368,7 +370,7 @@ const Chains = () => {
 
   const deployChains = async (
     chainIds: string[],
-    domains: string[],
+    domains: Domain[],
     snapshotAction: BulkDeploymentSnapshotAction,
   ) => {
     if (chainIds.length === 0) {
@@ -376,7 +378,12 @@ const Chains = () => {
     }
     setIsLoading(true);
     try {
-      await api.bulkDeploy({ chainIds, domains, snapshotAction });
+      await api.deployToMicroDomain({
+        domains: domains.map((domain) => domain.name),
+        chainIds,
+        snapshotAction,
+        mode: DeployMode.APPEND,
+      });
     } catch (error) {
       notificationService.requestFailed("Failed to deploy chains", error);
     } finally {
@@ -607,8 +614,8 @@ const Chains = () => {
       showModal({
         component: (
           <DeployChains
-            onSubmit={(options: DeployOptions) =>
-              void deploySelectedChains(options)
+            onSubmit={(request: DeployRequest) =>
+              void deploySelectedChains(request)
             }
           />
         ),
@@ -659,7 +666,7 @@ const Chains = () => {
     await deleteChains(chainIds);
   };
 
-  const deploySelectedChains = async (options: DeployOptions) => {
+  const deploySelectedChains = async (request: DeployRequest) => {
     const chainIds = folderItems
       .filter(
         (i) =>
@@ -667,7 +674,7 @@ const Chains = () => {
           i.itemType === CatalogItemType.CHAIN,
       )
       .map((i) => i.id);
-    await deployChains(chainIds, options.domains, options.snapshotAction);
+    await deployChains(chainIds, request.domains, request.snapshotAction);
   };
 
   const onContextMenuItemClick = async (item: FolderItem, key: React.Key) => {
diff --git a/src/pages/Deployments.tsx b/src/pages/Deployments.tsx
index ab9c45e0..9f378209 100644
--- a/src/pages/Deployments.tsx
+++ b/src/pages/Deployments.tsx
@@ -1,14 +1,23 @@
 import React from "react";
-import { FloatButton, Table, Tooltip } from "antd";
+import { FloatButton, Space, Table, Tag, Tooltip } from "antd";
 import { useDeployments } from "../hooks/useDeployments.tsx";
 import { useParams } from "react-router";
 import { TableProps } from "antd/lib/table";
-import { CreateDeploymentRequest, Deployment } from "../api/apiTypes.ts";
+import {
+  CreateDeploymentRequest,
+  Deployment,
+  DeployMode,
+  DomainType,
+  MicroDomainDeployRequest,
+} from "../api/apiTypes.ts";
 import { DeploymentRuntimeStates } from "../components/deployment_runtime_states/DeploymentRuntimeStates.tsx";
 import { useSnapshots } from "../hooks/useSnapshots.tsx";
-import { formatTimestamp } from "../misc/format-utils.ts";
+import { formatOptional, formatTimestamp } from "../misc/format-utils.ts";
 import { useModalsContext } from "../Modals.tsx";
-import { DeploymentCreate } from "../components/modal/DeploymentCreate.tsx";
+import {
+  CreateDeploymentOptions,
+  DeploymentCreate,
+} from "../components/modal/DeploymentCreate.tsx";
 import { api } from "../api/api.ts";
 import { LongActionButton } from "../components/LongActionButton.tsx";
 import { useNotificationService } from "../hooks/useNotificationService.tsx";
@@ -34,7 +43,20 @@ export const Deployments: React.FC = () => {
         </>
       ),
     },
-    { title: "Domain", dataIndex: "domain", key: "domain" },
+    {
+      title: "Domain",
+      dataIndex: "domain",
+      key: "domain",
+      render: (_, deployment) =>
+        deployment.domainType === DomainType.MICRO ? (
+          <Space size={"small"}>
+            {deployment.domain}
+            <Tag>micro</Tag>
+          </Space>
+        ) : (
+          deployment.domain
+        ),
+    },
     {
       title: "Status",
       dataIndex: "runtime",
@@ -51,7 +73,9 @@ export const Deployments: React.FC = () => {
       title: "Created By",
       dataIndex: "createdBy",
       key: "createdBy",
-      render: (_, deployment) => <>{deployment.createdBy.username}</>,
+      render: (_, deployment) => (
+        <>{formatOptional(deployment.createdBy?.username)}</>
+      ),
     },
     {
       title: "Created At",
@@ -83,18 +107,43 @@ export const Deployments: React.FC = () => {
 
   const deleteDeployment = async (deployment: Deployment) => {
     try {
-      await api.deleteDeployment(deployment.id);
+      if (deployment.domainType === DomainType.MICRO) {
+        await api.deleteSnapshotFromMicroDomain(
+          deployment.domain,
+          deployment.snapshotId,
+        );
+      } else {
+        await api.deleteDeployment(deployment.id);
+      }
       removeDeployment(deployment);
     } catch (error) {
       notificationService.requestFailed("Failed to delete deployment", error);
     }
   };
 
-  const createDeployment = async (request: CreateDeploymentRequest) => {
+  const createDeployment = async (options: CreateDeploymentOptions) => {
     if (!chainId) return;
     try {
-      const deployment = await api.createDeployment(chainId, request);
-      onDeploymentCreated(deployment);
+      await Promise.all(
+        options.domains.map(async (domain) => {
+          if (domain.type === DomainType.MICRO) {
+            const request: MicroDomainDeployRequest = {
+              name: domain.name,
+              snapshotIds: [options.snapshotId],
+              mode: DeployMode.APPEND,
+            };
+            await api.deploySnapshotsToMicroDomain(request);
+          } else {
+            const request: CreateDeploymentRequest = {
+              domain: domain.name,
+              snapshotId: options.snapshotId,
+              suspended: false,
+            };
+            const deployment = await api.createDeployment(chainId, request);
+            onDeploymentCreated(deployment);
+          }
+        }),
+      );
     } catch (error) {
       notificationService.requestFailed("Failed to create deployment", error);
     }