diff --git a/src/configManagerOps/FrConfigAccessConfigOps.ts b/src/configManagerOps/FrConfigAccessConfigOps.ts
index 5dbcb81ed..1448da158 100644
--- a/src/configManagerOps/FrConfigAccessConfigOps.ts
+++ b/src/configManagerOps/FrConfigAccessConfigOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAccessConfig(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting access config'
+    );
     const exportData = (
       await exportConfigEntity('access', {
         envReplaceParams: options.envReplaceParams,
@@ -29,9 +39,17 @@ export async function configManagerExportAccessConfig(
       getFilePath('access-config/access.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported access config');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity access`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting access config',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting access configuration`);
   }
   return false;
 }
@@ -50,7 +68,7 @@ export async function configManagerImportAccessConfig(): Promise<boolean> {
     await importConfigEntities(accessConfigImportData);
     return true;
   } catch (error) {
-    printError(error, `Error importing config entity access`);
+    printError(error, `Error importing access configuration`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigAuditOps.ts b/src/configManagerOps/FrConfigAuditOps.ts
index 3d794f007..9e08977ce 100644
--- a/src/configManagerOps/FrConfigAuditOps.ts
+++ b/src/configManagerOps/FrConfigAuditOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAudit(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting audit'
+    );
     const exportData = (
       await exportConfigEntity('audit', {
         envReplaceParams: options.envReplaceParams,
@@ -25,9 +35,13 @@ export async function configManagerExportAudit(
     ).idm['audit'];
 
     saveJsonToFile(exportData, getFilePath('audit/audit.json', true), false);
+    stopProgressIndicator(indicatorId, 'Exported audit');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity audit`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting audit', 'fail');
+    }
+    printError(error, `Error exporting audit configuration`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigAuthenticationOps.ts b/src/configManagerOps/FrConfigAuthenticationOps.ts
index 10733613b..d86eb21ac 100644
--- a/src/configManagerOps/FrConfigAuthenticationOps.ts
+++ b/src/configManagerOps/FrConfigAuthenticationOps.ts
@@ -2,7 +2,12 @@ import { frodo, state } from '@rockcarver/frodo-lib';
 import { AuthenticationSettingsExportInterface } from '@rockcarver/frodo-lib/types/ops/AuthenticationSettingsOps';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { realmList } from '../utils/FrConfig';
 
 const {
@@ -19,7 +24,13 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAuthentication(
   realm?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting authentication settings'
+    );
     if (realm && realm !== '__default__realm__') {
       const exportData = await _readAuthenticationSettings(false);
       const fileName = `realms/${state.getRealm()}/realm-config/authentication.json`;
@@ -34,6 +45,10 @@ export async function configManagerExportAuthentication(
           continue;
 
         state.setRealm(realmName);
+        updateProgressIndicator(
+          indicatorId,
+          `Exporting authentication settings (${realmName})`
+        );
         const exportData = await _readAuthenticationSettings(false);
         const fileName = `realms/${realmName}/realm-config/authentication.json`;
         saveJsonToFile(
@@ -45,9 +60,17 @@ export async function configManagerExportAuthentication(
       }
     }
 
+    stopProgressIndicator(indicatorId, 'Exported authentication settings');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity ui-configuration`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting authentication settings',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting authentication settings`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigAuthzPoliciesOps.ts b/src/configManagerOps/FrConfigAuthzPoliciesOps.ts
index d0793c4c9..1059c5047 100644
--- a/src/configManagerOps/FrConfigAuthzPoliciesOps.ts
+++ b/src/configManagerOps/FrConfigAuthzPoliciesOps.ts
@@ -4,7 +4,13 @@ import { PolicySetSkeleton } from '@rockcarver/frodo-lib/types/api/PolicySetApi'
 import { ResourceTypeSkeleton } from '@rockcarver/frodo-lib/types/api/ResourceTypesApi';
 import { readFile } from 'fs/promises';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { policySet, policy, resourceType } = frodo.authz;
@@ -74,7 +80,13 @@ export async function configManagerExportAuthzPolicySet(
   criteria: ByName | BySkeleton,
   configFile: string = null
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting authorization policies'
+    );
     // policySet.readPolicySet() will fail if the provided policy-set doesn't exist in the current-state realm
     const ps: PolicySetSkeleton =
       'ps' in criteria
@@ -128,6 +140,7 @@ export async function configManagerExportAuthzPolicySet(
       await policy.readPoliciesByPolicySet(ps.name);
     if (allPoliciesOfThis.length !== 0) {
       for (const p of allPoliciesOfThis) {
+        updateProgressIndicator(indicatorId, `Exporting policy ${p.name}`);
         await exportPolicy(p);
       }
     } else {
@@ -136,8 +149,16 @@ export async function configManagerExportAuthzPolicySet(
       );
     }
 
+    stopProgressIndicator(indicatorId, 'Exported authorization policies');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting authorization policies',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigConnectorDefinitionsOps.ts b/src/configManagerOps/FrConfigConnectorDefinitionsOps.ts
index fa45e73f3..d44e0a205 100644
--- a/src/configManagerOps/FrConfigConnectorDefinitionsOps.ts
+++ b/src/configManagerOps/FrConfigConnectorDefinitionsOps.ts
@@ -2,7 +2,12 @@ import { frodo } from '@rockcarver/frodo-lib';
 import { ConnectorSkeleton } from '@rockcarver/frodo-lib/types/ops/ConnectorOps';
 import fs from 'fs';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { connector } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -64,15 +69,29 @@ export async function configManagerExportConnectorDefinition(
  * @returns
  */
 export async function configManagerExportConnectorDefinitionsAll(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting connector definitions'
+    );
     const cs: ConnectorSkeleton[] = await connector.readConnectors();
     for (const c of cs) {
       if (c._id.includes('provisioner.openicf/')) {
         configManagerExportConnectorDefinition({ c: c });
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported connector definitions');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting connector definitions',
+        'fail'
+      );
+    }
     printError(error);
   }
 }
@@ -113,7 +132,7 @@ export async function configManagerImportConnectors(
 
     return true;
   } catch (error) {
-    printError(error, `Error exporting mappings to files`);
+    printError(error, `Error importing connectors `);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigConnectorMappingOps.ts b/src/configManagerOps/FrConfigConnectorMappingOps.ts
index cf7031358..fff37141c 100644
--- a/src/configManagerOps/FrConfigConnectorMappingOps.ts
+++ b/src/configManagerOps/FrConfigConnectorMappingOps.ts
@@ -1,7 +1,12 @@
 import { frodo } from '@rockcarver/frodo-lib';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readConfigEntity } = frodo.idm.config;
@@ -46,15 +51,34 @@ function processMappings(mapping, targetDir, name) {
  * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function configManagerExportMappings(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const exportData = await readConfigEntity('sync');
     const fileDir = `sync/mappings`;
-    for (const mapping of Object.values(exportData.mappings)) {
+    const mappings = Object.values(exportData.mappings);
+    indicatorId = createProgressIndicator(
+      'determinate',
+      mappings.length,
+      'Exporting connector mappings'
+    );
+    for (const mapping of mappings) {
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting connector mapping ${mapping.name}`
+      );
       processMappings(mapping, `${fileDir}/${mapping.name}`, mapping.name);
     }
+    stopProgressIndicator(indicatorId, `Exported ${mappings.length} mappings`);
     return true;
   } catch (error) {
-    printError(error, `Error exporting mappings to files`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting connector mappings',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting connector mappings`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigCookieDomainsOps.ts b/src/configManagerOps/FrConfigCookieDomainsOps.ts
index d23582a39..97d352d05 100644
--- a/src/configManagerOps/FrConfigCookieDomainsOps.ts
+++ b/src/configManagerOps/FrConfigCookieDomainsOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readCookieDomains, updateCookieDomains } = frodo.cloud.env;
@@ -11,16 +15,30 @@ const { readCookieDomains, updateCookieDomains } = frodo.cloud.env;
  * @return {Promise<boolean>} a promise that resolves to true if successful, false otherwise
  */
 export async function configManagerExportCookieDomains(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting cookie domains'
+    );
     const exportData = await readCookieDomains();
     saveJsonToFile(
       exportData,
       getFilePath('cookie-domains/cookie-domains.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported cookie domains');
     return true;
   } catch (error) {
-    printError(error, `Error exporting custom domains`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting cookie domains',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting cookie domains`);
   }
   return false;
 }
@@ -37,7 +55,7 @@ export async function configManagerImportCookieDomains(): Promise<boolean> {
     await updateCookieDomains(importData);
     return true;
   } catch (error) {
-    printError(error, `Error importing custom domains`);
+    printError(error, `Error importing cookie domains`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigCorsOps.ts b/src/configManagerOps/FrConfigCorsOps.ts
index 74f332c0b..f86f54e5c 100644
--- a/src/configManagerOps/FrConfigCorsOps.ts
+++ b/src/configManagerOps/FrConfigCorsOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import { IdObjectSkeletonInterface } from '@rockcarver/frodo-lib/types/api/ApiTypes';
 import { FullService } from '@rockcarver/frodo-lib/types/api/ServiceApi';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { config } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -14,7 +18,9 @@ type CorsObject = { idmCorsConfig; corsServices; corsServiceGlobal };
  * @returns True if file was successfully saved
  */
 export async function configManagerExportCors(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator('indeterminate', 0, 'Exporting cors');
     const cors: IdObjectSkeletonInterface =
       await config.readConfigEntity('servletfilter/cors');
     const services: FullService[] = await frodo.service.getFullServices(true);
@@ -35,8 +41,12 @@ export async function configManagerExportCors(): Promise<boolean> {
       false,
       true
     );
+    stopProgressIndicator(indicatorId, 'Exported cors');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting cors', 'fail');
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigCspOps.ts b/src/configManagerOps/FrConfigCspOps.ts
index 90186afc9..ccfa904e6 100644
--- a/src/configManagerOps/FrConfigCspOps.ts
+++ b/src/configManagerOps/FrConfigCspOps.ts
@@ -3,7 +3,11 @@ import { ContentSecurityPolicy } from '@rockcarver/frodo-lib/types/api/cloud/Env
 import { applyDiff } from 'deep-diff';
 import { readFile } from 'fs/promises';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { env } = frodo.cloud;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,7 +19,13 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportCsp(
   file: string = null
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting content security policies'
+    );
     const cspEnforced: ContentSecurityPolicy =
       await env.readEnforcedContentSecurityPolicy();
     const cspReport: ContentSecurityPolicy =
@@ -34,8 +44,16 @@ export async function configManagerExportCsp(
     }
 
     saveJsonToFile(csp, getFilePath('csp/csp.json', true), false, true);
+    stopProgressIndicator(indicatorId, 'Exported content security policies');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting content security policies',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigCustomNodesOps.ts b/src/configManagerOps/FrConfigCustomNodesOps.ts
index 91db0016c..166a6f538 100644
--- a/src/configManagerOps/FrConfigCustomNodesOps.ts
+++ b/src/configManagerOps/FrConfigCustomNodesOps.ts
@@ -1,6 +1,10 @@
 import { frodo } from '@rockcarver/frodo-lib';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { saveJsonToFile, getFilePath, saveTextToFile } = frodo.utils;
 const { readCustomNode, readCustomNodes } = frodo.authn.node;
@@ -15,7 +19,13 @@ const { readCustomNode, readCustomNodes } = frodo.authn.node;
 export async function configManagerExportCustomNodes(
   name?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting custom nodes'
+    );
     let customNodes;
     if (name) {
       const customNode = await readCustomNode(undefined, name);
@@ -39,8 +49,16 @@ export async function configManagerExportCustomNodes(
       saveJsonToFile(node, filePath, false);
     }
 
+    stopProgressIndicator(indicatorId, 'Exported custom nodes');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting custom nodes',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigEmailProviderOps.ts b/src/configManagerOps/FrConfigEmailProviderOps.ts
index a555bb947..1ce8d39b3 100644
--- a/src/configManagerOps/FrConfigEmailProviderOps.ts
+++ b/src/configManagerOps/FrConfigEmailProviderOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import { IdObjectSkeletonInterface } from '@rockcarver/frodo-lib/types/api/ApiTypes';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { config } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -12,7 +16,13 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
  * @returns True if file was successfully saved
  */
 export async function configManagerExportEmailProviderConfiguration(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting email provider configuration'
+    );
     const emailProvider: IdObjectSkeletonInterface =
       await config.readConfigEntity('external.email');
 
@@ -22,8 +32,16 @@ export async function configManagerExportEmailProviderConfiguration(): Promise<b
       false,
       true
     );
+    stopProgressIndicator(indicatorId, 'Exported email provider configuration');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting email provider configuration',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigEmailTemplatesOps.ts b/src/configManagerOps/FrConfigEmailTemplatesOps.ts
index ffa8d9847..bc5b5a379 100644
--- a/src/configManagerOps/FrConfigEmailTemplatesOps.ts
+++ b/src/configManagerOps/FrConfigEmailTemplatesOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readEmailTemplates, readEmailTemplate, importEmailTemplates } =
@@ -14,7 +18,13 @@ const { readEmailTemplates, readEmailTemplate, importEmailTemplates } =
 export async function configManagerExportEmailTemplates(
   name?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting email templates'
+    );
     if (name) {
       const exportData = await readEmailTemplate(name);
       processEmailTemplate(exportData, `email-templates`);
@@ -24,9 +34,17 @@ export async function configManagerExportEmailTemplates(
         processEmailTemplate(template, `email-templates`);
       });
     }
+    stopProgressIndicator(indicatorId, 'Exported email templates');
     return true;
   } catch (error) {
-    printError(error, `Error exporting email templates to files`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting email templates',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting email templates`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigEndpointsOps.ts b/src/configManagerOps/FrConfigEndpointsOps.ts
index 04d390c3e..fcd4daf6a 100644
--- a/src/configManagerOps/FrConfigEndpointsOps.ts
+++ b/src/configManagerOps/FrConfigEndpointsOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { readConfigEntitiesByType, importConfigEntities } = frodo.idm.config;
 const { saveJsonToFile, getFilePath } = frodo.utils;
@@ -15,12 +19,22 @@ const { saveJsonToFile, getFilePath } = frodo.utils;
 export async function configManagerExportEndpoints(
   endpointName?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting endpoints'
+    );
     const exportData = await readConfigEntitiesByType('endpoint');
     processEndpoints(exportData, 'endpoints', endpointName);
+    stopProgressIndicator(indicatorId, 'Exported endpoints');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity endpoints`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting endpoints', 'fail');
+    }
+    printError(error, `Error exporting endpoints`);
   }
   return false;
 }
@@ -90,7 +104,7 @@ export async function configManagerImportEndpoints(
     await importConfigEntities(importEndpointData);
     return true;
   } catch (error) {
-    printError(error, `Error importing config entity endpoints`);
+    printError(error, `Error importing endpoints`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigEntityOps.ts b/src/configManagerOps/FrConfigEntityOps.ts
index e74a22960..0f49f7cef 100644
--- a/src/configManagerOps/FrConfigEntityOps.ts
+++ b/src/configManagerOps/FrConfigEntityOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -14,8 +18,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportConfigEntity(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting config entity'
+    );
     const exportData = (
       await exportConfigEntity('ui/configuration', {
         envReplaceParams: options.envReplaceParams,
@@ -28,9 +38,17 @@ export async function configManagerExportConfigEntity(
       getFilePath('ui-configuration.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported config entity');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity ui-configuration`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting config entity',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting config entities`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigInternalRolesOps.ts b/src/configManagerOps/FrConfigInternalRolesOps.ts
index a68c93518..62bebe492 100644
--- a/src/configManagerOps/FrConfigInternalRolesOps.ts
+++ b/src/configManagerOps/FrConfigInternalRolesOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readInternalRoles, importInternalRoles } = frodo.role;
@@ -12,7 +16,13 @@ const { readInternalRoles, importInternalRoles } = frodo.role;
 export async function configManagerExportInternalRoles(
   name?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting internal roles'
+    );
     const exportData = await readInternalRoles();
     for (const role of Object.values(exportData)) {
       if (name && name !== role.name) {
@@ -23,9 +33,17 @@ export async function configManagerExportInternalRoles(
         saveJsonToFile(role, getFilePath(fileName, true), false, true);
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported internal roles');
     return true;
   } catch (error) {
-    printError(error, `Error exporting internal roles to files`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting internal roles',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting internal roles`);
   }
   return false;
 }
@@ -49,7 +67,7 @@ export async function configManagerImportInternalRoles(
     await importInternalRoles(importData);
     return true;
   } catch (error) {
-    printError(error, `Error importing internal roles to files`);
+    printError(error, `Error importing internal roles`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigJourneysOps.ts b/src/configManagerOps/FrConfigJourneysOps.ts
index ba06b1ba0..d8e823056 100644
--- a/src/configManagerOps/FrConfigJourneysOps.ts
+++ b/src/configManagerOps/FrConfigJourneysOps.ts
@@ -53,7 +53,7 @@ export async function configManagerExportJourneys(
     }
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity endpoints`);
+    printError(error, `Error exporting journeys`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigKbaOps.ts b/src/configManagerOps/FrConfigKbaOps.ts
index 79d8e7daa..8ce78bb45 100644
--- a/src/configManagerOps/FrConfigKbaOps.ts
+++ b/src/configManagerOps/FrConfigKbaOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,10 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportKbaConfig(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator('indeterminate', 0, 'Exporting kba');
     const exportData = (
       await exportConfigEntity('selfservice.kba', {
         envReplaceParams: options.envReplaceParams,
@@ -29,9 +35,13 @@ export async function configManagerExportKbaConfig(
       getFilePath('kba/selfservice.kba.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported kba');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity selfservice.kba`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting kba', 'fail');
+    }
+    printError(error, `Error exporting kba configuration`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigLocalesOps.ts b/src/configManagerOps/FrConfigLocalesOps.ts
index 288676380..3809aa230 100644
--- a/src/configManagerOps/FrConfigLocalesOps.ts
+++ b/src/configManagerOps/FrConfigLocalesOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { readConfigEntitiesByType, importConfigEntities } = frodo.idm.config;
 const { saveJsonToFile, getFilePath } = frodo.utils;
@@ -14,12 +18,22 @@ const { saveJsonToFile, getFilePath } = frodo.utils;
 export async function configManagerExportLocales(
   localeName?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting locales'
+    );
     const exportData = await readConfigEntitiesByType('uilocale');
     processLocales(exportData, 'locales', localeName);
+    stopProgressIndicator(indicatorId, 'Exported locales');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity locales`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting locales', 'fail');
+    }
+    printError(error, `Error exporting locales`);
   }
   return false;
 }
@@ -65,7 +79,7 @@ export async function configManagerImportLocales(
     await importConfigEntities(importLocaleData);
     return true;
   } catch (error) {
-    printError(error, `Error importing config entity locales`);
+    printError(error, `Error importing locales`);
     return false;
   }
 }
diff --git a/src/configManagerOps/FrConfigManagedObjectsOps.ts b/src/configManagerOps/FrConfigManagedObjectsOps.ts
index 97d8fef88..a405994cc 100644
--- a/src/configManagerOps/FrConfigManagedObjectsOps.ts
+++ b/src/configManagerOps/FrConfigManagedObjectsOps.ts
@@ -4,7 +4,11 @@ import fs from 'fs';
 import path from 'path';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { readConfigEntity, importConfigEntities, importSubConfigEntity } =
   frodo.idm.config;
@@ -28,12 +32,26 @@ const SCRIPT_HOOKS = ['onStore', 'onRetrieve', 'onValidate'];
 export async function configManagerExportManagedObjects(
   objectName?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting managed objects'
+    );
     const exportData = (await readConfigEntity('managed')) as ManagedSkeleton;
     processManagedObjects(exportData.objects, 'managed-objects', objectName);
+    stopProgressIndicator(indicatorId, 'Exported managed objects');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity endpoints`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting managed objects',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting managed objects`);
   }
   return false;
 }
@@ -180,7 +198,7 @@ export async function configManagerImportManagedObjects(
     }
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity endpoints`);
+    printError(error, `Error importing managed objects`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigOauth2AgentOps.ts b/src/configManagerOps/FrConfigOauth2AgentOps.ts
index b053e66bb..700ca3fc1 100644
--- a/src/configManagerOps/FrConfigOauth2AgentOps.ts
+++ b/src/configManagerOps/FrConfigOauth2AgentOps.ts
@@ -2,7 +2,13 @@ import { frodo, state } from '@rockcarver/frodo-lib';
 import { AgentSkeleton } from '@rockcarver/frodo-lib/types/api/AgentApi';
 import { readFile } from 'fs/promises';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readRealms } = frodo.realm;
@@ -122,19 +128,34 @@ export async function configManagerExportAgent(
 export async function configManagerExportConfigAgents(
   configFile: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting oauth2 agents'
+    );
     verboseMessage(`Reading the config file "${configFile}"`);
     const configFileData = JSON.parse(
       await readFile(configFile, { encoding: 'utf8' })
     );
     for (const realm of Object.keys(configFileData)) {
       state.setRealm(realm);
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting oauth2 agents (${realm})`
+      );
       const agents: idAndOverrids[] = getAgents(configFileData, realm);
       if (agents.length !== 0) {
         for (const agent of agents) {
           if (
             !(await configManagerExportAgent(agent.id, null, agent.overrides))
           ) {
+            stopProgressIndicator(
+              indicatorId,
+              'Error exporting oauth2 agents',
+              'fail'
+            );
             return false;
           }
         }
@@ -144,8 +165,16 @@ export async function configManagerExportConfigAgents(
         );
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported oauth2 agents');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting oauth2 agents',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigOrgPrivilegesOps.ts b/src/configManagerOps/FrConfigOrgPrivilegesOps.ts
index 7b50a5a38..2bdd52263 100644
--- a/src/configManagerOps/FrConfigOrgPrivilegesOps.ts
+++ b/src/configManagerOps/FrConfigOrgPrivilegesOps.ts
@@ -2,7 +2,12 @@ import { frodo, state } from '@rockcarver/frodo-lib';
 import { IdObjectSkeletonInterface } from '@rockcarver/frodo-lib/types/api/ApiTypes';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 
 const { config } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -59,7 +64,13 @@ export async function configManagerExportOrgPrivileges(): Promise<boolean> {
  * @returns True if configuration files were successfully saved
  */
 export async function configManagerExportOrgPrivilegesAllRealms(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting organization privileges'
+    );
     configManagerExportOrgPrivileges();
     for (const realm of await readRealms()) {
       if (
@@ -70,12 +81,29 @@ export async function configManagerExportOrgPrivilegesAllRealms(): Promise<boole
         continue;
 
       state.setRealm(realm.name);
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting organization privileges (${realm.name})`
+      );
       if (!(await configManagerExportOrgPrivilegesRealm(realm.name))) {
+        stopProgressIndicator(
+          indicatorId,
+          'Error exporting organization privileges',
+          'fail'
+        );
         return false;
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported organization privileges');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting organization privileges',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigPasswordPolicyOps.ts b/src/configManagerOps/FrConfigPasswordPolicyOps.ts
index 1f3520cce..5f9b8a54c 100644
--- a/src/configManagerOps/FrConfigPasswordPolicyOps.ts
+++ b/src/configManagerOps/FrConfigPasswordPolicyOps.ts
@@ -2,7 +2,12 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { realmList } from '../utils/FrConfig';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -17,8 +22,14 @@ export async function configManagerExportPasswordPolicy(
   realm?: string,
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting password policy'
+    );
     if (realm && realm !== '__default__realm__') {
       const realmData = (
         await exportConfigEntity(`fieldPolicy/${realm}_user`, {
@@ -32,6 +43,10 @@ export async function configManagerExportPasswordPolicy(
       for (const realmName of await realmList()) {
         // fr-config-manager doesn't support root themes
         if (realmName === '/') continue;
+        updateProgressIndicator(
+          indicatorId,
+          `Exporting password policy (${realmName})`
+        );
         const realmData = (
           await exportConfigEntity(`fieldPolicy/${realmName}_user`, {
             envReplaceParams: options.envReplaceParams,
@@ -42,9 +57,17 @@ export async function configManagerExportPasswordPolicy(
         saveJsonToFile(realmData, getFilePath(fileName, true), false, true);
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported password policy');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity ui-configuration`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting password policy',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting password policy`);
   }
   return false;
 }
@@ -74,7 +97,7 @@ export async function configManagerImportPasswordPolicy(
     }
     return true;
   } catch (error) {
-    printError(error, `Error importing config entity ui-configuration`);
+    printError(error, `Error importing password policy`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigRawOps.ts b/src/configManagerOps/FrConfigRawOps.ts
index 934cce819..1db122664 100644
--- a/src/configManagerOps/FrConfigRawOps.ts
+++ b/src/configManagerOps/FrConfigRawOps.ts
@@ -2,7 +2,13 @@ import { frodo } from '@rockcarver/frodo-lib';
 import { IdObjectSkeletonInterface } from '@rockcarver/frodo-lib/types/api/ApiTypes';
 import { readFile } from 'fs/promises';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { exportRawConfig } = frodo.rawConfig;
@@ -12,11 +18,21 @@ const { exportRawConfig } = frodo.rawConfig;
  * @returns True if each file was successfully exported
  */
 export async function configManagerExportRaw(file: string): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting raw config'
+    );
     const jsonData = JSON.parse(await readFile(file, { encoding: 'utf8' }));
 
     // Create export json file for every item in the provided json file
     for (const config of jsonData) {
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting raw config ${config.path ?? ''}`.trim()
+      );
       const response: IdObjectSkeletonInterface = await exportRawConfig(config);
       verboseMessage(`Saving ${response._id} at ${config.path}.json.`);
       saveJsonToFile(
@@ -27,8 +43,12 @@ export async function configManagerExportRaw(file: string): Promise<boolean> {
       );
     }
 
+    stopProgressIndicator(indicatorId, 'Exported raw config');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting raw config', 'fail');
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigRemoteServersOps.ts b/src/configManagerOps/FrConfigRemoteServersOps.ts
index 3068b7d78..4616ff185 100644
--- a/src/configManagerOps/FrConfigRemoteServersOps.ts
+++ b/src/configManagerOps/FrConfigRemoteServersOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -14,8 +18,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportRemoteServers(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting remote servers'
+    );
     const exportData = (
       await exportConfigEntity('provisioner.openicf.connectorinfoprovider', {
         envReplaceParams: options.envReplaceParams,
@@ -31,8 +41,16 @@ export async function configManagerExportRemoteServers(
       ),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported remote servers');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting remote servers',
+        'fail'
+      );
+    }
     printError(
       error,
       `Error exporting config entity RCS: provisioner.openicf.connectorinfoprovider`
diff --git a/src/configManagerOps/FrConfigSamlOps.ts b/src/configManagerOps/FrConfigSamlOps.ts
index 312311f73..b50ad03cf 100644
--- a/src/configManagerOps/FrConfigSamlOps.ts
+++ b/src/configManagerOps/FrConfigSamlOps.ts
@@ -1,7 +1,12 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import {
   escapePlaceholders,
   replaceAllInJson,
@@ -17,10 +22,13 @@ const { exportCircleOfTrust } = frodo.saml2.circlesOfTrust;
  * @return {Promise<boolean>} a promise that resolves to true if successful, false otherwise
  */
 export async function configManagerExportSaml(file): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator('indeterminate', 0, 'Exporting saml');
     const objects = JSON.parse(fs.readFileSync(file, 'utf8'));
     for (const realm of Object.keys(objects)) {
       state.setRealm(realm);
+      updateProgressIndicator(indicatorId, `Exporting saml (${realm})`);
       for (const samlProvider of objects[realm].samlProviders) {
         const result = await exportSaml2Provider(samlProvider.entityId, {
           deps: false,
@@ -92,8 +100,12 @@ export async function configManagerExportSaml(file): Promise<boolean> {
         );
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported saml');
     return true;
   } catch (err) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting saml', 'fail');
+    }
     printError(err, `Error exporting SAML`);
   }
   return false;
diff --git a/src/configManagerOps/FrConfigSchedulesOps.ts b/src/configManagerOps/FrConfigSchedulesOps.ts
index cc21e78f7..73dd53df2 100644
--- a/src/configManagerOps/FrConfigSchedulesOps.ts
+++ b/src/configManagerOps/FrConfigSchedulesOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { readConfigEntitiesByType, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -13,12 +17,22 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportSchedules(
   name?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting schedules'
+    );
     const exportData = await readConfigEntitiesByType('schedule');
     processSchedules(exportData, 'schedules', name);
+    stopProgressIndicator(indicatorId, 'Exported schedules');
     return true;
   } catch (error) {
-    printError(error, `Error exporting internal schedules to files`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting schedules', 'fail');
+    }
+    printError(error, `Error exporting internal schedules`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigScriptOps.ts b/src/configManagerOps/FrConfigScriptOps.ts
index c68a6a852..05106889f 100644
--- a/src/configManagerOps/FrConfigScriptOps.ts
+++ b/src/configManagerOps/FrConfigScriptOps.ts
@@ -1,7 +1,13 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 import { ScriptSkeleton } from '@rockcarver/frodo-lib/types/api/ScriptApi';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 import { realmList, safeFileName } from '../utils/FrConfig';
 
 const { getFilePath, saveJsonToFile, decodeBase64, saveTextToFile } =
@@ -190,7 +196,13 @@ export async function configManagerExportScriptsAll(
   scriptType: string = null,
   language: string = 'JAVASCRIPT'
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting scripts'
+    );
     for (const realm of await realmList()) {
       if (
         realm === '/' &&
@@ -200,6 +212,10 @@ export async function configManagerExportScriptsAll(
         continue;
 
       state.setRealm(realm);
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting scripts (${state.getRealm()})`
+      );
       verboseMessage(`\n${state.getRealm()} realm:`);
       if (
         !(await configManagerExportScriptsRealms(
@@ -210,11 +226,16 @@ export async function configManagerExportScriptsAll(
           language
         ))
       ) {
+        stopProgressIndicator(indicatorId, 'Error exporting scripts', 'fail');
         return false;
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported scripts');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting scripts', 'fail');
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigSecretMappingsOps.ts b/src/configManagerOps/FrConfigSecretMappingsOps.ts
index 0aaf29f90..59eca044b 100644
--- a/src/configManagerOps/FrConfigSecretMappingsOps.ts
+++ b/src/configManagerOps/FrConfigSecretMappingsOps.ts
@@ -1,6 +1,11 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { realmList } from '../utils/FrConfig';
 
 const { saveJsonToFile, getFilePath } = frodo.utils;
@@ -10,17 +15,31 @@ export async function configManagerExportSecretMappings(
   name?,
   realm?
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting secret mappings'
+    );
     if (realm && realm !== '__default__realm__') {
       const readData = await readSecretStoreMappings(
         'ESV',
         'GoogleSecretManagerSecretStoreProvider',
         false
       );
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting secret mappings (${realm})`
+      );
       processSecretMappings(readData, `realms/${realm}/secret-mappings`, name);
     } else {
       for (const realm of await realmList()) {
         state.setRealm(realm);
+        updateProgressIndicator(
+          indicatorId,
+          `Exporting secret mappings (${realm})`
+        );
         const readData = await readSecretStoreMappings(
           'ESV',
           'GoogleSecretManagerSecretStoreProvider',
@@ -33,9 +52,17 @@ export async function configManagerExportSecretMappings(
         );
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported secret mappings');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity endpoints`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting secret mappings',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting secret mappings`);
   }
   return false;
 }
diff --git a/src/configManagerOps/FrConfigServiceObjectsOps.ts b/src/configManagerOps/FrConfigServiceObjectsOps.ts
index 440583444..1e500c692 100644
--- a/src/configManagerOps/FrConfigServiceObjectsOps.ts
+++ b/src/configManagerOps/FrConfigServiceObjectsOps.ts
@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { queryManagedObjects, updateManagedObject } = frodo.idm.managed;
@@ -13,7 +17,13 @@ const { queryManagedObjects, updateManagedObject } = frodo.idm.managed;
 export async function configManagerExportServiceObjectsFromFile(
   file
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting service objects'
+    );
     const objects = JSON.parse(fs.readFileSync(file, 'utf8'));
     for (const objectType of Object.keys(objects)) {
       for (const object of objects[objectType]) {
@@ -28,12 +38,22 @@ export async function configManagerExportServiceObjectsFromFile(
             `Unexpected result from search: ${queryResult.length} entries found for ${objectType} - ${object.searchValue}`
           );
           printError(error);
+          stopProgressIndicator(
+            indicatorId,
+            'Error exporting service objects',
+            'fail'
+          );
           return false;
         } else if (queryResult.length == 0) {
           const error = new Error(
             `No result from search: ${queryResult.length} entries found for ${objectType} - ${object.searchValue}`
           );
           printError(error);
+          stopProgressIndicator(
+            indicatorId,
+            'Error exporting service objects',
+            'fail'
+          );
           return false;
         } else {
           const result = queryResult[0];
@@ -63,8 +83,16 @@ export async function configManagerExportServiceObjectsFromFile(
         }
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported service objects');
     return true;
   } catch (err) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting service objects',
+        'fail'
+      );
+    }
     printError(err, `Error exporting service-objects`);
   }
   return false;
diff --git a/src/configManagerOps/FrConfigServiceOps.ts b/src/configManagerOps/FrConfigServiceOps.ts
index a10bd4958..efbc6472a 100644
--- a/src/configManagerOps/FrConfigServiceOps.ts
+++ b/src/configManagerOps/FrConfigServiceOps.ts
@@ -1,6 +1,11 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { realmList } from '../utils/FrConfig';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -14,19 +19,30 @@ export async function configManagerExportServices(
   realm?,
   name?
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting services'
+    );
     if (realm && realm !== '__default__realm__') {
       const services = await getFullServices(false);
       processServices(services, realm, name);
     } else {
       for (const realm of await realmList()) {
         state.setRealm(realm);
+        updateProgressIndicator(indicatorId, `Exporting services (${realm})`);
         const services = await getFullServices(false);
         processServices(services, realm, name);
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported services');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting services', 'fail');
+    }
     printError(error);
   }
   return false;
diff --git a/src/configManagerOps/FrConfigTermsAndConditionsOps.ts b/src/configManagerOps/FrConfigTermsAndConditionsOps.ts
index 1079738c2..c981cb14c 100644
--- a/src/configManagerOps/FrConfigTermsAndConditionsOps.ts
+++ b/src/configManagerOps/FrConfigTermsAndConditionsOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { saveJsonToFile, getFilePath } = frodo.utils;
 const { readConfigEntity, importConfigEntities } = frodo.idm.config;
@@ -12,7 +16,13 @@ const { readConfigEntity, importConfigEntities } = frodo.idm.config;
  * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function configManagerExportTermsAndConditions(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting terms and conditions'
+    );
     const exportData = (await readConfigEntity('selfservice.terms')) as any;
     for (const version of exportData.versions) {
       for (const [language, text] of Object.entries(
@@ -32,8 +42,16 @@ export async function configManagerExportTermsAndConditions(): Promise<boolean>
       getFilePath('terms-conditions/terms-conditions.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported terms and conditions');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting terms and conditions',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigThemeOps.ts b/src/configManagerOps/FrConfigThemeOps.ts
index cfadc1f52..0757968d1 100644
--- a/src/configManagerOps/FrConfigThemeOps.ts
+++ b/src/configManagerOps/FrConfigThemeOps.ts
@@ -2,7 +2,13 @@ import { frodo, state } from '@rockcarver/frodo-lib';
 import { ThemeSkeleton } from '@rockcarver/frodo-lib/types/ops/ThemeOps';
 import fs from 'fs';
 
-import { printError, printMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  printMessage,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { decodeOrNot } from '../utils/FrConfig';
 
 const { saveJsonToFile, getFilePath } = frodo.utils;
@@ -63,11 +69,18 @@ function extractHtmlFields(theme: ThemeSkeleton, themePath: string): void {
 }
 
 export async function configManagerExportThemes(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting themes'
+    );
     const realms = await readRealms();
     for (const realm of realms) {
       // fr-config-manager doesn't support root themes
       if (realm.name === '/') continue;
+      updateProgressIndicator(indicatorId, `Exporting themes (${realm.name})`);
       state.setRealm(realm.name);
       const themes = await readThemes();
       const exportDir = getFilePath(`realms/${realm.name}/themes`, true);
@@ -79,8 +92,12 @@ export async function configManagerExportThemes(): Promise<boolean> {
         saveJsonToFile(theme, `${themeDir}/${theme.name}.json`, false);
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported themes');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting themes', 'fail');
+    }
     printError(error);
     return false;
   }
diff --git a/src/configManagerOps/FrConfigUiConfigOps.ts b/src/configManagerOps/FrConfigUiConfigOps.ts
index c2aecb87f..619bc86a8 100644
--- a/src/configManagerOps/FrConfigUiConfigOps.ts
+++ b/src/configManagerOps/FrConfigUiConfigOps.ts
@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportUiConfig(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting ui configuration'
+    );
     const exportData = (
       await exportConfigEntity('ui/configuration', {
         envReplaceParams: options.envReplaceParams,
@@ -29,9 +39,17 @@ export async function configManagerExportUiConfig(
       getFilePath('ui/ui-configuration.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported ui configuration');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity ui-configuration`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting ui configuration',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting ui-configuration`);
   }
   return false;
 }