diff --git a/src/commands/createContainerApp/ContainerAppCreateStep.ts b/src/commands/createContainerApp/ContainerAppCreateStep.ts
index a0375580b..4f63fe8e4 100644
--- a/src/commands/createContainerApp/ContainerAppCreateStep.ts
+++ b/src/commands/createContainerApp/ContainerAppCreateStep.ts
@@ -5,19 +5,21 @@
 
 import { ContainerAppsAPIClient, Ingress, KnownActiveRevisionsMode } from "@azure/arm-appcontainers";
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
-import { Progress } from "vscode";
-import { containerAppsWebProvider } from "../../constants";
+import { GenericTreeItem, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
+import type { Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, containerAppsWebProvider } from "../../constants";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createContainerAppsAPIClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
 import { getContainerNameForImage } from "../deployImage/imageSource/containerRegistry/getContainerNameForImage";
-import { ICreateContainerAppContext } from "./ICreateContainerAppContext";
+import type { ICreateContainerAppContext } from "./ICreateContainerAppContext";
 
-export class ContainerAppCreateStep extends AzureWizardExecuteStep<ICreateContainerAppContext> {
+export class ContainerAppCreateStep extends ExecuteActivityOutputStepBase<ICreateContainerAppContext> {
     public priority: number = 750;
 
-    public async execute(context: ICreateContainerAppContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: ICreateContainerAppContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const appClient: ContainerAppsAPIClient = await createContainerAppsAPIClient(context);
 
         const resourceGroupName: string = nonNullValueAndProp(context.resourceGroup, 'name');
@@ -63,4 +65,26 @@ export class ContainerAppCreateStep extends AzureWizardExecuteStep<ICreateContai
     public shouldExecute(context: ICreateContainerAppContext): boolean {
         return !context.containerApp;
     }
+
+    protected createSuccessOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppCreateStep', activitySuccessContext]),
+                label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('createContainerAppSuccess', 'Created container app "{0}".', context.newContainerAppName)
+        };
+    }
+
+    protected createFailOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppCreateStep', activityFailContext]),
+                label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
+                iconPath: activityFailIcon
+            }),
+            message: localize('createContainerAppFail', 'Failed to create container app "{0}".', context.newContainerAppName)
+        };
+    }
 }
diff --git a/src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts b/src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts
index f1b7728a0..7528f0169 100644
--- a/src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts
+++ b/src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts
@@ -5,14 +5,14 @@
 
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
 import { GenericTreeItem } from "@microsoft/vscode-azext-utils";
-import { Progress } from "vscode";
+import type { Progress } from "vscode";
 import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../constants";
 import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
 import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createOperationalInsightsManagementClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
 import { nonNullProp } from "../../utils/nonNull";
-import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
+import type { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 
 export class LogAnalyticsCreateStep extends ExecuteActivityOutputStepBase<IManagedEnvironmentContext> {
     public priority: number = 220;
diff --git a/src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts b/src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts
index ab1bb4dd5..f9a9f01fa 100644
--- a/src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts
+++ b/src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts
@@ -5,56 +5,79 @@
 
 import { ContainerAppsAPIClient } from "@azure/arm-appcontainers";
 import { getResourceGroupFromId, LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem } from "@microsoft/vscode-azext-utils";
 import { Progress } from "vscode";
-import { managedEnvironmentsAppProvider } from "../../constants";
-import { ext } from "../../extensionVariables";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, managedEnvironmentsAppProvider } from "../../constants";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
 import { createContainerAppsAPIClient, createOperationalInsightsManagementClient } from '../../utils/azureClients';
 import { localize } from "../../utils/localize";
 import { nonNullProp, nonNullValueAndProp } from "../../utils/nonNull";
 import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 
-export class ManagedEnvironmentCreateStep extends AzureWizardExecuteStep<IManagedEnvironmentContext> {
+export class ManagedEnvironmentCreateStep extends ExecuteActivityOutputStepBase<IManagedEnvironmentContext> {
     public priority: number = 250;
 
-    public async execute(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const client: ContainerAppsAPIClient = await createContainerAppsAPIClient(context);
         const opClient = await createOperationalInsightsManagementClient(context);
-        const rgName = nonNullValueAndProp(context.resourceGroup, 'name');
+
+        const resourceGroupName = nonNullValueAndProp(context.resourceGroup, 'name');
+        const managedEnvironmentName = nonNullProp(context, 'newManagedEnvironmentName');
         const logAnalyticsWorkspace = nonNullProp(context, 'logAnalyticsWorkspace');
 
-        const creatingKuEnv: string = localize('creatingManagedEnvironment', 'Creating new Container Apps environment "{0}"...', context.newManagedEnvironmentName);
-        progress.report({ message: creatingKuEnv });
-        ext.outputChannel.appendLog(creatingKuEnv);
+        const creating: string = localize('creatingManagedEnvironment', 'Creating environment...');
+        progress.report({ message: creating });
 
         const sharedKeys = await opClient.sharedKeysOperations.getSharedKeys(
             getResourceGroupFromId(nonNullProp(logAnalyticsWorkspace, 'id')),
             nonNullProp(logAnalyticsWorkspace, 'name'));
 
-        context.managedEnvironment = await client.managedEnvironments.beginCreateOrUpdateAndWait(rgName, nonNullProp(context, 'newManagedEnvironmentName'),
+        context.managedEnvironment = await client.managedEnvironments.beginCreateOrUpdateAndWait(resourceGroupName, managedEnvironmentName,
             {
                 location: (await LocationListStep.getLocation(context)).name,
                 appLogsConfiguration: {
                     "destination": "log-analytics",
                     "logAnalyticsConfiguration": {
-                        "customerId": nonNullProp(context, 'logAnalyticsWorkspace').customerId,
+                        "customerId": logAnalyticsWorkspace.customerId,
                         "sharedKey": sharedKeys.primarySharedKey
                     }
                 }
             }
         );
 
-        context.activityResult = {
-            id: nonNullProp(context.managedEnvironment, 'id'),
-            name: nonNullProp(context, 'newManagedEnvironmentName'),
-            type: managedEnvironmentsAppProvider
+        if (!context.activityChildren) {
+            context.activityResult = {
+                id: nonNullProp(context.managedEnvironment, 'id'),
+                name: managedEnvironmentName,
+                type: managedEnvironmentsAppProvider
+            };
         }
-
-        const createdKuEnv: string = localize('createKuEnv', 'Successfully created new Container Apps environment "{0}".', context.newManagedEnvironmentName);
-        ext.outputChannel.appendLog(createdKuEnv);
     }
 
     public shouldExecute(context: IManagedEnvironmentContext): boolean {
         return !context.managedEnvironment;
     }
+
+    protected createSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activitySuccessContext]),
+                label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('createdManagedEnvironmentSuccess', 'Created container apps environment "{0}".', context.newManagedEnvironmentName)
+        };
+    }
+
+    protected createFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activityFailContext]),
+                label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
+                iconPath: activityFailIcon
+            }),
+            message: localize('createdManagedEnvironmentFail', 'Failed to create container apps environment "{0}".', context.newManagedEnvironmentName)
+        };
+    }
 }
diff --git a/src/commands/deployImage/ContainerAppUpdateStep.ts b/src/commands/deployImage/ContainerAppUpdateStep.ts
index f35ac06f5..8d87c468f 100644
--- a/src/commands/deployImage/ContainerAppUpdateStep.ts
+++ b/src/commands/deployImage/ContainerAppUpdateStep.ts
@@ -3,19 +3,22 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep, nonNullProp } from "@microsoft/vscode-azext-utils";
-import type { Progress } from "vscode";
+import { GenericTreeItem, nonNullProp } from "@microsoft/vscode-azext-utils";
+import { type Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../constants";
 import { ext } from "../../extensionVariables";
 import { ContainerAppModel, getContainerEnvelopeWithSecrets } from "../../tree/ContainerAppItem";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { updateContainerApp } from "../../utils/updateContainerApp";
 import type { IDeployImageContext } from "./deployImage";
 import { getContainerNameForImage } from "./imageSource/containerRegistry/getContainerNameForImage";
 
-export class ContainerAppUpdateStep extends AzureWizardExecuteStep<IDeployImageContext> {
+export class ContainerAppUpdateStep extends ExecuteActivityOutputStepBase<IDeployImageContext> {
     public priority: number = 480;
 
-    public async execute(context: IDeployImageContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IDeployImageContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const containerApp: ContainerAppModel = nonNullProp(context, 'containerApp');
         const containerAppEnvelope = await getContainerEnvelopeWithSecrets(context, context.subscription, containerApp);
 
@@ -44,4 +47,26 @@ export class ContainerAppUpdateStep extends AzureWizardExecuteStep<IDeployImageC
     public shouldExecute(context: IDeployImageContext): boolean {
         return !!context.containerApp;
     }
+
+    protected createSuccessOutput(context: IDeployImageContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppUpdateStep', activitySuccessContext]),
+                label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('updateContainerAppSuccess', 'Updated container app "{0}".', context.containerApp?.name)
+        };
+    }
+
+    protected createFailOutput(context: IDeployImageContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppUpdateStep', activityFailContext]),
+                label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
+                iconPath: activityFailIcon
+            }),
+            message: localize('updateContainerAppFail', 'Failed to update container app "{0}".', context.containerApp?.name)
+        };
+    }
 }
diff --git a/src/commands/deployImage/deployImage.ts b/src/commands/deployImage/deployImage.ts
index ae406ef5f..b83593af2 100644
--- a/src/commands/deployImage/deployImage.ts
+++ b/src/commands/deployImage/deployImage.ts
@@ -3,9 +3,10 @@
 *  Licensed under the MIT License. See License.md in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import { VerifyProvidersStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, ITreeItemPickerContext, createSubscriptionContext } from "@microsoft/vscode-azext-utils";
+import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, ExecuteActivityContext, ITreeItemPickerContext, createSubscriptionContext } from "@microsoft/vscode-azext-utils";
 import { webProvider } from "../../constants";
 import type { ContainerAppItem } from "../../tree/ContainerAppItem";
+import { createActivityContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { pickContainerApp } from "../../utils/pickItem/pickContainerApp";
 import { ContainerAppOverwriteConfirmStep } from "./ContainerAppOverwriteConfirmStep";
@@ -13,7 +14,7 @@ import { ContainerAppUpdateStep } from "./ContainerAppUpdateStep";
 import type { ImageSourceBaseContext } from "./imageSource/ImageSourceBaseContext";
 import { ImageSourceListStep } from "./imageSource/ImageSourceListStep";
 
-export type IDeployImageContext = ImageSourceBaseContext;
+export type IDeployImageContext = ImageSourceBaseContext & ExecuteActivityContext;
 
 export async function deployImage(context: ITreeItemPickerContext & Partial<IDeployImageContext>, node?: ContainerAppItem): Promise<void> {
     if (!node) {
@@ -26,6 +27,7 @@ export async function deployImage(context: ITreeItemPickerContext & Partial<IDep
     const wizardContext: IDeployImageContext = {
         ...context,
         ...createSubscriptionContext(subscription),
+        ...await createActivityContext(),
         subscription,
         containerApp
     };
diff --git a/src/commands/deployImage/imageSource/EnvironmentVariablesListStep.ts b/src/commands/deployImage/imageSource/EnvironmentVariablesListStep.ts
index 246120eba..93bb71add 100644
--- a/src/commands/deployImage/imageSource/EnvironmentVariablesListStep.ts
+++ b/src/commands/deployImage/imageSource/EnvironmentVariablesListStep.ts
@@ -3,11 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzExtFsExtra, AzureWizardPromptStep } from "@microsoft/vscode-azext-utils";
+import { AzExtFsExtra, AzureWizardPromptStep, GenericTreeItem } from "@microsoft/vscode-azext-utils";
 import { DotenvParseOutput, parse } from "dotenv";
 import { Uri, workspace } from "vscode";
-import { ImageSource } from "../../../constants";
+import { ImageSource, activitySuccessContext, activitySuccessIcon } from "../../../constants";
 import { ext } from "../../../extensionVariables";
+import { createActivityChildContext } from "../../../utils/activity/activityUtils";
 import { localize } from "../../../utils/localize";
 import { selectWorkspaceFile } from "../../../utils/workspaceUtils";
 import type { ImageSourceBaseContext } from "./ImageSourceBaseContext";
@@ -61,18 +62,18 @@ export class EnvironmentVariablesListStep extends AzureWizardPromptStep<ImageSou
     }
 
     // Todo: It might be nice to add a direct command to update just the environment variables rather than having to suggest to re-run the entire command again
-    private outputLogs(_context: ImageSourceBaseContext, setEnvironmentVariableOption: SetEnvironmentVariableOption): void {
+    private outputLogs(context: ImageSourceBaseContext, setEnvironmentVariableOption: SetEnvironmentVariableOption): void {
         if (setEnvironmentVariableOption !== SetEnvironmentVariableOption.ProvideFile) {
-            // context.activityChildren?.push(
-            //     new GenericTreeItem(undefined, {
-            //         contextValue: createActivityChildContext(['environmentVariablesListStep', setEnvironmentVariableOption, activitySuccessContext]),
-            //         label: localize('skipEnvVarsLabel',
-            //             'Skip environment variable configuration' +
-            //             (setEnvironmentVariableOption === SetEnvironmentVariableOption.NoDotEnv ? ' (no .env files found)' : '')
-            //         ),
-            //         iconPath: activitySuccessIcon
-            //     })
-            // );
+            context.activityChildren?.push(
+                new GenericTreeItem(undefined, {
+                    contextValue: createActivityChildContext(['environmentVariablesListStep', setEnvironmentVariableOption, activitySuccessContext]),
+                    label: localize('skipEnvVarsLabel',
+                        'Skip environment variable configuration' +
+                        (setEnvironmentVariableOption === SetEnvironmentVariableOption.NoDotEnv ? ' (no .env files found)' : '')
+                    ),
+                    iconPath: activitySuccessIcon
+                })
+            );
 
             const logMessage: string = localize('skippedEnvVarsMessage',
                 'Skipped environment variable configuration for the container app' +
@@ -81,16 +82,15 @@ export class EnvironmentVariablesListStep extends AzureWizardPromptStep<ImageSou
             );
             ext.outputChannel.appendLog(logMessage);
         } else {
-            // context.activityChildren?.push(
-            //     new GenericTreeItem(undefined, {
-            //         contextValue: createActivityChildContext(['environmentVariablesListStep', setEnvironmentVariableOption, activitySuccessContext]),
-            //         label: localize('saveEnvVarsLabel', 'Save environment variable configuration for the container app'),
-            //         iconPath: activitySuccessIcon
-            //     })
-            // );
+            context.activityChildren?.push(
+                new GenericTreeItem(undefined, {
+                    contextValue: createActivityChildContext(['environmentVariablesListStep', setEnvironmentVariableOption, activitySuccessContext]),
+                    label: localize('saveEnvVarsLabel', 'Save environment variable configuration'),
+                    iconPath: activitySuccessIcon
+                })
+            );
 
-            ext.outputChannel.appendLog(localize('savedEnvVarsMessage', 'Saved environment variable configuration for the container app.'));
+            ext.outputChannel.appendLog(localize('savedEnvVarsMessage', 'Saved environment variable configuration.'));
         }
     }
-
 }
diff --git a/src/commands/deployImage/imageSource/ImageSourceBaseContext.ts b/src/commands/deployImage/imageSource/ImageSourceBaseContext.ts
index b5781ade1..2bf03d219 100644
--- a/src/commands/deployImage/imageSource/ImageSourceBaseContext.ts
+++ b/src/commands/deployImage/imageSource/ImageSourceBaseContext.ts
@@ -4,10 +4,11 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type { EnvironmentVar, RegistryCredentials, Secret } from "@azure/arm-appcontainers";
+import type { ExecuteActivityContext } from "@microsoft/vscode-azext-utils";
 import type { ImageSource, ImageSourceValues } from "../../../constants";
 import type { IContainerAppContext } from "../../IContainerAppContext";
 
-export interface ImageSourceBaseContext extends IContainerAppContext {
+export interface ImageSourceBaseContext extends IContainerAppContext, ExecuteActivityContext {
     // ImageSourceListStep
     imageSource?: ImageSourceValues;
     buildType?: ImageSource.LocalDockerBuild | ImageSource.RemoteAcrBuild;
@@ -15,7 +16,8 @@ export interface ImageSourceBaseContext extends IContainerAppContext {
 
     // Base image attributes used as a precursor for either creating or updating a container app
     image?: string;
-    environmentVariables?: EnvironmentVar[];
     registries?: RegistryCredentials[];
     secrets?: Secret[];
+
+    environmentVariables?: EnvironmentVar[];
 }
diff --git a/src/commands/deployImage/imageSource/buildImageInAzure/BuildImageStep.ts b/src/commands/deployImage/imageSource/buildImageInAzure/BuildImageStep.ts
index 60cd15185..7f2285ce0 100644
--- a/src/commands/deployImage/imageSource/buildImageInAzure/BuildImageStep.ts
+++ b/src/commands/deployImage/imageSource/buildImageInAzure/BuildImageStep.ts
@@ -4,17 +4,19 @@
 *--------------------------------------------------------------------------------------------*/
 
 import { sendRequestWithTimeout } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep, nonNullProp, nonNullValue, openReadOnlyContent } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem, nonNullProp, nonNullValue, openReadOnlyContent } from "@microsoft/vscode-azext-utils";
 import { MessageItem, window } from "vscode";
-import { acrDomain } from "../../../../constants";
+import { acrDomain, activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../../../utils/activity/activityUtils";
 import { localize } from "../../../../utils/localize";
 import type { IBuildImageInAzureContext } from "./IBuildImageInAzureContext";
 import { buildImageInAzure } from "./buildImageInAzure";
 
-export class BuildImageStep extends AzureWizardExecuteStep<IBuildImageInAzureContext> {
+export class BuildImageStep extends ExecuteActivityOutputStepBase<IBuildImageInAzureContext> {
     public priority: number = 450;
 
-    public async execute(context: IBuildImageInAzureContext): Promise<void> {
+    protected async executeCore(context: IBuildImageInAzureContext): Promise<void> {
         context.registryDomain = acrDomain;
 
         const run = await buildImageInAzure(context);
@@ -40,10 +42,36 @@ export class BuildImageStep extends AzureWizardExecuteStep<IBuildImageInAzureCon
             context.errorHandling.suppressDisplay = true;
             throw new Error(errorMessage);
         }
+
+        // Need to place this outside of 'initSuccessOutput' so we can use the image after it has had a chance to become defined
+        (this.success.message as string[])?.push(localize('useImage', 'Using image "{0}".', context.image));
     }
 
     public shouldExecute(context: IBuildImageInAzureContext): boolean {
         return !context.image;
     }
-}
 
+    protected createSuccessOutput(context: IBuildImageInAzureContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['buildImageStep', activitySuccessContext]),
+                label: localize('buildImageLabel', 'Build image "{0}" in registry "{1}"', context.imageName, context.registryName),
+                iconPath: activitySuccessIcon
+            }),
+            message: [
+                localize('buildImageSuccess', 'Finished building image "{0}" in registry "{1}".', context.imageName, context.registryName),
+            ]
+        };
+    }
+
+    protected createFailOutput(context: IBuildImageInAzureContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['buildImageStep', activityFailContext]),
+                label: localize('buildImageLabel', 'Build image "{0}" in registry "{1}"', context.imageName, context.registryName),
+                iconPath: activityFailIcon
+            }),
+            message: localize('buildImageFail', 'Failed to build image "{0}" in registry "{1}".', context.imageName, context.registryName)
+        };
+    }
+}
diff --git a/src/commands/deployImage/imageSource/buildImageInAzure/RunStep.ts b/src/commands/deployImage/imageSource/buildImageInAzure/RunStep.ts
index f7fa02184..f294a8d3c 100644
--- a/src/commands/deployImage/imageSource/buildImageInAzure/RunStep.ts
+++ b/src/commands/deployImage/imageSource/buildImageInAzure/RunStep.ts
@@ -4,16 +4,20 @@
 *--------------------------------------------------------------------------------------------*/
 
 import type { DockerBuildRequest as AcrDockerBuildRequest } from "@azure/arm-containerregistry";
-import { AzExtFsExtra, AzureWizardExecuteStep } from "@microsoft/vscode-azext-utils";
+import { AzExtFsExtra, GenericTreeItem } from "@microsoft/vscode-azext-utils";
 import * as path from 'path';
-import type { Progress } from "vscode";
+import { type Progress } from "vscode";
+import { activityFailContext, activityFailIcon } from "../../../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../../../utils/activity/activityUtils";
 import { localize } from "../../../../utils/localize";
 import type { IBuildImageInAzureContext } from "./IBuildImageInAzureContext";
 
-export class RunStep extends AzureWizardExecuteStep<IBuildImageInAzureContext> {
+export class RunStep extends ExecuteActivityOutputStepBase<IBuildImageInAzureContext> {
     public priority: number = 440;
 
-    public async execute(context: IBuildImageInAzureContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IBuildImageInAzureContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+        // Need to keep the additional try wrapper here to execute finally, then we can catch any error that percolates up and display its output
         try {
             const rootUri = context.rootFolder.uri;
 
@@ -26,7 +30,7 @@ export class RunStep extends AzureWizardExecuteStep<IBuildImageInAzureContext> {
                 dockerFilePath: path.relative(rootUri.path, context.dockerfilePath)
             };
 
-            const building: string = localize('buildingImage', 'Building image "{0}" in registry "{1}"...', context.imageName, context.registryName);
+            const building: string = localize('buildingImage', 'Building image...');
             progress.report({ message: building });
 
             context.run = await context.client.registries.beginScheduleRunAndWait(context.resourceGroupName, context.registryName, runRequest);
@@ -38,6 +42,22 @@ export class RunStep extends AzureWizardExecuteStep<IBuildImageInAzureContext> {
     }
 
     public shouldExecute(context: IBuildImageInAzureContext): boolean {
-        return !context.run
+        return !context.run;
+    }
+
+    protected createSuccessOutput(): ExecuteActivityOutput {
+        // Skip here, success will be output by the build image step
+        return {};
+    }
+
+    protected createFailOutput(context: IBuildImageInAzureContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['runStep', activityFailContext]),
+                label: localize('runLabel', 'Build image "{0}" in registry "{1}"', context.imageName, context.registryName),
+                iconPath: activityFailIcon
+            }),
+            message: localize('runFail', 'Failed to build image "{0}" in registry "{1}".', context.imageName, context.registryName)
+        };
     }
 }
diff --git a/src/commands/deployImage/imageSource/buildImageInAzure/UploadSourceCodeStep.ts b/src/commands/deployImage/imageSource/buildImageInAzure/UploadSourceCodeStep.ts
index 28fd75c92..b6a474aa8 100644
--- a/src/commands/deployImage/imageSource/buildImageInAzure/UploadSourceCodeStep.ts
+++ b/src/commands/deployImage/imageSource/buildImageInAzure/UploadSourceCodeStep.ts
@@ -3,27 +3,35 @@
 *  Licensed under the MIT License. See License.md in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import { getResourceGroupFromId } from '@microsoft/vscode-azext-azureutils';
-import { AzExtFsExtra, AzureWizardExecuteStep, nonNullValue } from '@microsoft/vscode-azext-utils';
+import { AzExtFsExtra, GenericTreeItem, nonNullValue } from '@microsoft/vscode-azext-utils';
+import type { Progress } from 'vscode';
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from '../../../../constants';
 import { fse } from '../../../../node/fs-extra';
 import { tar } from '../../../../node/tar';
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from '../../../../utils/activity/ExecuteActivityOutputStepBase';
+import { createActivityChildContext } from '../../../../utils/activity/activityUtils';
 import { createContainerRegistryManagementClient } from '../../../../utils/azureClients';
+import { localize } from '../../../../utils/localize';
 import type { IBuildImageInAzureContext } from './IBuildImageInAzureContext';
 
 const vcsIgnoreList = ['.git', '.gitignore', '.bzr', 'bzrignore', '.hg', '.hgignore', '.svn'];
 
-export class UploadSourceCodeStep extends AzureWizardExecuteStep<IBuildImageInAzureContext> {
+export class UploadSourceCodeStep extends ExecuteActivityOutputStepBase<IBuildImageInAzureContext> {
     public priority: number = 430;
 
-    public async execute(context: IBuildImageInAzureContext): Promise<void> {
+    protected async executeCore(context: IBuildImageInAzureContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         context.registryName = nonNullValue(context.registry?.name);
         context.resourceGroupName = getResourceGroupFromId(nonNullValue(context.registry?.id));
         context.client = await createContainerRegistryManagementClient(context);
 
+        const uploading: string = localize('uploadingSourceCode', 'Uploading source code...');
+        progress.report({ message: uploading });
+
         const source: string = context.rootFolder.uri.fsPath;
         let items = await AzExtFsExtra.readDirectory(source);
         items = items.filter(i => {
             return !vcsIgnoreList.includes(i.name)
-        })
+        });
 
         tar.c({ cwd: source }, items.map(i => i.name)).pipe(fse.createWriteStream(context.tarFilePath));
 
@@ -39,6 +47,28 @@ export class UploadSourceCodeStep extends AzureWizardExecuteStep<IBuildImageInAz
     }
 
     public shouldExecute(context: IBuildImageInAzureContext): boolean {
-        return !context.uploadedSourceLocation
+        return !context.uploadedSourceLocation;
+    }
+
+    protected createSuccessOutput(context: IBuildImageInAzureContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['uploadSourceCodeStep', activitySuccessContext]),
+                label: localize('uploadSourceCodeLabel', 'Upload source code to registry "{0}"', context.registry?.name),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('uploadedSourceCodeSuccess', 'Uploaded source code to registry "{0}" for remote build.', context.registry?.name)
+        };
+    }
+
+    protected createFailOutput(context: IBuildImageInAzureContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['uploadSourceCodeStep', activityFailContext]),
+                label: localize('uploadSourceCodeLabel', 'Upload source code to registry "{0}"', context.registry?.name),
+                iconPath: activityFailIcon
+            }),
+            message: localize('uploadedSourceCodeFail', 'Failed to upload source code to registry "{0}" for remote build.', context.registry?.name)
+        };
     }
 }
diff --git a/src/commands/deployImage/imageSource/containerRegistry/acr/createAcr/RegistryCreateStep.ts b/src/commands/deployImage/imageSource/containerRegistry/acr/createAcr/RegistryCreateStep.ts
index b8d3f3179..c84c81396 100644
--- a/src/commands/deployImage/imageSource/containerRegistry/acr/createAcr/RegistryCreateStep.ts
+++ b/src/commands/deployImage/imageSource/containerRegistry/acr/createAcr/RegistryCreateStep.ts
@@ -3,18 +3,21 @@
 *  Licensed under the MIT License. See License.md in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 
-import { ContainerRegistryManagementClient } from "@azure/arm-containerregistry";
+import type { ContainerRegistryManagementClient } from "@azure/arm-containerregistry";
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
 import type { Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../../../../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../../../../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../../../../../utils/activity/activityUtils";
 import { createContainerRegistryManagementClient } from "../../../../../../utils/azureClients";
 import { localize } from "../../../../../../utils/localize";
 import type { CreateAcrContext } from "./CreateAcrContext";
 
-export class RegistryCreateStep extends AzureWizardExecuteStep<CreateAcrContext> {
+export class RegistryCreateStep extends ExecuteActivityOutputStepBase<CreateAcrContext> {
     public priority: number = 350;
 
-    public async execute(context: CreateAcrContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: CreateAcrContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         progress.report({ message: localize('creatingRegistry', 'Creating registry...') });
 
         const client: ContainerRegistryManagementClient = await createContainerRegistryManagementClient(context);
@@ -30,6 +33,28 @@ export class RegistryCreateStep extends AzureWizardExecuteStep<CreateAcrContext>
     }
 
     public shouldExecute(context: CreateAcrContext): boolean {
-        return !!context.newRegistryName && !!context.newRegistrySku;
+        return !context.registry;
+    }
+
+    protected createSuccessOutput(context: CreateAcrContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['registryCreateStep', activitySuccessContext]),
+                label: localize('createRegistryLabel', 'Create container registry "{0}"', context.newRegistryName),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('createRegistrySuccess', 'Created container registry "{0}".', context.newRegistryName)
+        };
+    }
+
+    protected createFailOutput(context: CreateAcrContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['registryCreateStep', activityFailContext]),
+                label: localize('createRegistryLabel', 'Create container registry "{0}"', context.newRegistryName),
+                iconPath: activityFailIcon
+            }),
+            message: localize('createRegistryFail', 'Failed to create container registry "{0}".', context.newRegistryName)
+        };
     }
 }
diff --git a/src/commands/deployWorkspaceProject/DeployWorkspaceProjectSaveSettingsStep.ts b/src/commands/deployWorkspaceProject/DeployWorkspaceProjectSaveSettingsStep.ts
index 31edadd05..a57d992da 100644
--- a/src/commands/deployWorkspaceProject/DeployWorkspaceProjectSaveSettingsStep.ts
+++ b/src/commands/deployWorkspaceProject/DeployWorkspaceProjectSaveSettingsStep.ts
@@ -3,16 +3,25 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
 import { type Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, relativeSettingsFilePath } from "../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
-import { DeployWorkspaceProjectContext } from "./DeployWorkspaceProjectContext";
+import type { DeployWorkspaceProjectContext } from "./DeployWorkspaceProjectContext";
 import { DeployWorkspaceProjectSettings, setDeployWorkspaceProjectSettings } from "./deployWorkspaceProjectSettings";
 
-export class DeployWorkspaceProjectSaveSettingsStep extends AzureWizardExecuteStep<DeployWorkspaceProjectContext> {
+const saveSettingsLabel: string = localize('saveSettingsLabel', 'Save deployment settings to workspace "{0}"', relativeSettingsFilePath);
+
+export class DeployWorkspaceProjectSaveSettingsStep extends ExecuteActivityOutputStepBase<DeployWorkspaceProjectContext> {
     public priority: number = 1480;
 
-    public async execute(context: DeployWorkspaceProjectContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: DeployWorkspaceProjectContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+        // Even if this step fails, there's no need to show the whole activity as failed.
+        // Swallow the error and just show the activity failed item and output log message instead.
+        this.options.shouldSwallowError = true;
+
         progress.report({ message: localize('saving', 'Saving configuration...') });
 
         const settings: DeployWorkspaceProjectSettings = {
@@ -27,4 +36,26 @@ export class DeployWorkspaceProjectSaveSettingsStep extends AzureWizardExecuteSt
     public shouldExecute(context: DeployWorkspaceProjectContext): boolean {
         return !!context.shouldSaveDeploySettings;
     }
+
+    protected createSuccessOutput(): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['deployWorkspaceProjectSaveSettingsStep', activitySuccessContext]),
+                label: saveSettingsLabel,
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('savedSettingsSuccess', 'Saved deployment settings to workspace "{0}".', relativeSettingsFilePath)
+        };
+    }
+
+    protected createFailOutput(): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['deployWorkspaceProjectSaveSettingsStep', activityFailContext]),
+                label: saveSettingsLabel,
+                iconPath: activityFailIcon
+            }),
+            message: localize('savedSettingsFail', 'Failed to save deployment settings to workspace "{0}".', relativeSettingsFilePath)
+        };
+    }
 }
diff --git a/src/commands/deployWorkspaceProject/deployWorkspaceProject.ts b/src/commands/deployWorkspaceProject/deployWorkspaceProject.ts
index 50bbe5352..867c38f22 100644
--- a/src/commands/deployWorkspaceProject/deployWorkspaceProject.ts
+++ b/src/commands/deployWorkspaceProject/deployWorkspaceProject.ts
@@ -4,13 +4,13 @@
 *--------------------------------------------------------------------------------------------*/
 
 import { LocationListStep, ResourceGroupCreateStep, VerifyProvidersStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, IActionContext, ISubscriptionContext, createSubscriptionContext, nonNullProp, nonNullValueAndProp, subscriptionExperience } from "@microsoft/vscode-azext-utils";
+import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, GenericTreeItem, IActionContext, ISubscriptionContext, createSubscriptionContext, nonNullProp, nonNullValueAndProp, subscriptionExperience } from "@microsoft/vscode-azext-utils";
 import type { AzureSubscription } from "@microsoft/vscode-azureresources-api";
 import { ProgressLocation, window } from "vscode";
-import { appProvider, managedEnvironmentsId, operationalInsightsProvider, webProvider } from "../../constants";
+import { activityInfoIcon, activitySuccessContext, appProvider, managedEnvironmentsId, operationalInsightsProvider, webProvider } from "../../constants";
 import { ext } from "../../extensionVariables";
 import { ContainerAppModel, isIngressEnabled } from "../../tree/ContainerAppItem";
-import { createActivityContext } from "../../utils/activity/activityUtils";
+import { createActivityChildContext, createActivityContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { browseContainerApp } from "../browseContainerApp";
 import { ContainerAppCreateStep } from "../createContainerApp/ContainerAppCreateStep";
@@ -67,13 +67,13 @@ export async function deployWorkspaceProject(context: IActionContext): Promise<v
     if (wizardContext.resourceGroup) {
         const resourceGroupName: string = nonNullValueAndProp(wizardContext.resourceGroup, 'name');
 
-        // wizardContext.activityChildren?.push(
-        //     new GenericTreeItem(undefined, {
-        //         contextValue: createActivityChildContext(['useExistingResourceGroup', activitySuccessContext]),
-        //         label: localize('useResourceGroup', 'Use resource group "{0}"', resourceGroupName),
-        //         iconPath: activitySuccessIcon
-        //     })
-        // );
+        wizardContext.activityChildren?.push(
+            new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['useExistingResourceGroup', activitySuccessContext]),
+                label: localize('useResourceGroup', 'Using resource group "{0}"', resourceGroupName),
+                iconPath: activityInfoIcon
+            })
+        );
 
         await LocationListStep.setLocation(wizardContext, wizardContext.resourceGroup.location);
         ext.outputChannel.appendLog(localize('usingResourceGroup', 'Using resource group "{0}".', resourceGroupName));
@@ -85,13 +85,13 @@ export async function deployWorkspaceProject(context: IActionContext): Promise<v
     if (wizardContext.managedEnvironment) {
         const managedEnvironmentName: string = nonNullValueAndProp(wizardContext.managedEnvironment, 'name');
 
-        // wizardContext.activityChildren?.push(
-        //     new GenericTreeItem(undefined, {
-        //         contextValue: createActivityChildContext(['useExistingManagedEnvironment', activitySuccessContext]),
-        //         label: localize('useManagedEnvironment', 'Use container app environment "{0}"', managedEnvironmentName),
-        //         iconPath: activitySuccessIcon
-        //     })
-        // );
+        wizardContext.activityChildren?.push(
+            new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['useExistingManagedEnvironment', activitySuccessContext]),
+                label: localize('useManagedEnvironment', 'Using container app environment "{0}"', managedEnvironmentName),
+                iconPath: activityInfoIcon
+            })
+        );
 
         await LocationListStep.setLocation(wizardContext, wizardContext.managedEnvironment.location);
 
@@ -114,32 +114,35 @@ export async function deployWorkspaceProject(context: IActionContext): Promise<v
 
     // Azure Container Registry
     if (wizardContext.registry) {
-        // wizardContext.activityChildren?.push(
-        //     new GenericTreeItem(undefined, {
-        //         contextValue: createActivityChildContext(['useExistingAcr', activitySuccessContext]),
-        //         label: localize('useAcr', 'Use container registry "{0}"', wizardContext.registry.name),
-        //         iconPath: activitySuccessIcon
-        //     })
-        // );
-
-        ext.outputChannel.appendLog(localize('usingAcr', 'Using Azure Container Registry "{0}".', wizardContext.registry.name));
+        const registryName: string = nonNullValueAndProp(wizardContext.registry, 'name');
+
+        wizardContext.activityChildren?.push(
+            new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['useExistingAcr', activitySuccessContext]),
+                label: localize('useAcr', 'Using container registry "{0}"', registryName),
+                iconPath: activityInfoIcon
+            })
+        );
+
+        ext.outputChannel.appendLog(localize('usingAcr', 'Using Azure Container Registry "{0}".', registryName));
     } else {
-        // ImageSourceListStep handles this creation logic
+        // ImageSourceListStep can already handle this creation logic
     }
 
     // Container app
     if (wizardContext.containerApp) {
+        const containerAppName: string = nonNullValueAndProp(wizardContext.containerApp, 'name');
+
         promptSteps.unshift(new ContainerAppOverwriteConfirmStep());
         executeSteps.push(new ContainerAppUpdateStep());
 
-        const containerAppName: string = nonNullValueAndProp(wizardContext.containerApp, 'name');
-        // wizardContext.activityChildren?.push(
-        //     new GenericTreeItem(undefined, {
-        //         contextValue: createActivityChildContext(['useExistingContainerApp', activitySuccessContext]),
-        //         label: localize('useContainerApp', 'Use container app "{0}"', containerAppName),
-        //         iconPath: activitySuccessIcon
-        //     })
-        // );
+        wizardContext.activityChildren?.push(
+            new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['useExistingContainerApp', activitySuccessContext]),
+                label: localize('useContainerApp', 'Using container app "{0}"', containerAppName),
+                iconPath: activityInfoIcon
+            })
+        );
 
         ext.outputChannel.appendLog(localize('usingContainerApp', 'Using container app "{0}".', containerAppName));
     } else {
diff --git a/src/commands/ingress/IngressPromptStep.ts b/src/commands/ingress/IngressPromptStep.ts
index 589695117..b40084731 100644
--- a/src/commands/ingress/IngressPromptStep.ts
+++ b/src/commands/ingress/IngressPromptStep.ts
@@ -3,8 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep, AzureWizardPromptStep, IWizardOptions } from "@microsoft/vscode-azext-utils";
+import { AzureWizardExecuteStep, AzureWizardPromptStep, GenericTreeItem, IWizardOptions } from "@microsoft/vscode-azext-utils";
+import { activitySuccessContext, activitySuccessIcon } from "../../constants";
 import { ext } from "../../extensionVariables";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import type { IngressContext } from "./IngressContext";
 import { DisableIngressStep } from "./disableIngress/DisableIngressStep";
@@ -66,17 +68,17 @@ export async function tryConfigureIngressUsingDockerfile(context: IngressContext
     }
 
     // If a container app already exists, activity children will be added automatically in later execute steps
-    // if (!context.containerApp) {
-    //     context.activityChildren?.push(
-    //         new GenericTreeItem(undefined, {
-    //             contextValue: createActivityChildContext(['ingressPromptStep', activitySuccessContext]),
-    //             label: context.enableIngress ?
-    //                 localize('ingressEnableLabel', 'Enable ingress on port {0} (found Dockerfile configuration)', context.targetPort) :
-    //                 localize('ingressDisableLabel', 'Disable ingress (found Dockerfile configuration)'),
-    //             iconPath: activitySuccessIcon
-    //         })
-    //     );
-    // }
+    if (!context.containerApp) {
+        context.activityChildren?.push(
+            new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['ingressPromptStep', activitySuccessContext]),
+                label: context.enableIngress ?
+                    localize('ingressEnableLabel', 'Enable ingress on port {0} (from Dockerfile configuration)', context.targetPort) :
+                    localize('ingressDisableLabel', 'Disable ingress (from Dockerfile configuration)'),
+                iconPath: activitySuccessIcon
+            })
+        );
+    }
 
     ext.outputChannel.appendLog(context.enableIngress ?
         localize('ingressEnabledLabel', 'Detected ingress on port {0} using Dockerfile configuration.', context.targetPort) :
diff --git a/src/commands/ingress/enableIngress/EnableIngressStep.ts b/src/commands/ingress/enableIngress/EnableIngressStep.ts
index 800db63dc..ac2764009 100644
--- a/src/commands/ingress/enableIngress/EnableIngressStep.ts
+++ b/src/commands/ingress/enableIngress/EnableIngressStep.ts
@@ -4,16 +4,21 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type { Ingress } from "@azure/arm-appcontainers";
-import { nonNullProp } from "@microsoft/vscode-azext-utils";
-import type { Progress } from "vscode";
+import { GenericTreeItem, nonNullProp } from "@microsoft/vscode-azext-utils";
+import { type Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../../utils/activity/activityUtils";
 import { localize } from "../../../utils/localize";
+import { updateContainerApp } from "../../../utils/updateContainerApp";
 import type { IngressContext } from "../IngressContext";
-import { IngressUpdateStepBase } from "../IngressUpdateStepBase";
 
-export class EnableIngressStep extends IngressUpdateStepBase<IngressContext> {
+export class EnableIngressStep extends ExecuteActivityOutputStepBase<IngressContext> {
     public priority: number = 650;
 
-    public async execute(context: IngressContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IngressContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+        progress.report({ message: localize('enablingIngress', 'Enabling ingress...') });
+
         const containerApp = nonNullProp(context, 'containerApp');
         const ingress: Ingress = {
             targetPort: context.targetPort,
@@ -28,13 +33,33 @@ export class EnableIngressStep extends IngressUpdateStepBase<IngressContext> {
             ],
         }
 
-        const working: string = localize('enablingIngress', 'Enabling ingress...');
-        const workCompleted: string = localize('enableCompleted', 'Enabled ingress on port {0} for container app "{1}"', context.targetPort, containerApp.name)
-
-        await this.updateIngressSettings(context, progress, { ingress, working, workCompleted });
+        await updateContainerApp(context, context.subscription, containerApp, { configuration: { ingress: ingress as Ingress | undefined } });
     }
 
+
     public shouldExecute(context: IngressContext): boolean {
-        return context.enableIngress === true;
+        return context.enableIngress === true && context.targetPort !== context.containerApp?.configuration?.ingress?.targetPort;
+    }
+
+    protected createSuccessOutput(context: IngressContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['enableIngressStep', activitySuccessContext]),
+                label: localize('enableIngressLabel', 'Enable ingress on port {0} for container app "{1}"', context.targetPort, context.containerApp?.name),
+                iconPath: activitySuccessIcon
+            }),
+            message: localize('enableCompleted', 'Enabled ingress on port {0} for container app "{1}".', context.targetPort, context.containerApp?.name)
+        };
+    }
+
+    protected createFailOutput(context: IngressContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['enableIngressStep', activityFailContext]),
+                label: localize('enableIngressLabel', 'Enable ingress on port {0} for container app "{1}"', context.targetPort, context.containerApp?.name),
+                iconPath: activityFailIcon
+            }),
+            message: localize('enableIngressFailed', 'Failed to enable ingress on port {0} for container app "{1}".', context.targetPort, context.containerApp?.name)
+        };
     }
 }
diff --git a/src/constants.ts b/src/constants.ts
index 517755455..9495e94ec 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -86,6 +86,7 @@ export const relativeSettingsFilePath: string = `${vscodeFolder}/${settingsFile}
 // Originally from the Docker extension: https://github.com/microsoft/vscode-docker/blob/main/src/constants.ts
 export const DOCKERFILE_GLOB_PATTERN = '**/{*.[dD][oO][cC][kK][eE][rR][fF][iI][lL][eE],[dD][oO][cC][kK][eE][rR][fF][iI][lL][eE],[dD][oO][cC][kK][eE][rR][fF][iI][lL][eE].*}';
 
+export const activityInfoIcon: ThemeIcon = new ThemeIcon('info', new ThemeColor('charts.blue'));
 export const activitySuccessIcon: ThemeIcon = new ThemeIcon('pass', new ThemeColor('testing.iconPassed'));
 export const activityFailIcon: ThemeIcon = new ThemeIcon('error', new ThemeColor('testing.iconFailed'));