diff --git a/resources/instructions/createSObjectLwcQuickActions.html b/resources/instructions/createSObjectLwcQuickActions.html
index cd091d50..2580cc2c 100644
--- a/resources/instructions/createSObjectLwcQuickActions.html
+++ b/resources/instructions/createSObjectLwcQuickActions.html
@@ -55,6 +55,10 @@ <h1>Create sObject LWC Quick Actions</h1>
             </tbody>
         </table>
 
+        <div id="errorDiv" style="color: crimson">
+            <!-- placeholder for any error messages -->
+        </div>
+
         <label
             style="display: block; margin-top: 10px; margin-bottom: 8px"
             for="generateLwcQuickActionsButton"
@@ -81,6 +85,8 @@ <h1>Create sObject LWC Quick Actions</h1>
                 'quickActionStatusTable'
             );
 
+            const errorDiv = document.getElementById('errorDiv');
+
             generateQuickActionsButtonElement.addEventListener('click', () => {
                 webviewMessaging.sendMessageRequest(
                     'generateLwcQuickActions',
@@ -105,6 +111,13 @@ <h1>Create sObject LWC Quick Actions</h1>
             });
 
             function handleQuickActionStatusResponse(response) {
+                // check for an error
+                errorDiv.innerHTML = '';
+                if (response.error != undefined) {
+                    errorDiv.innerHTML = 'An error occurred: ' + response.error;
+                    return;
+                }
+
                 var tbody =
                     quickActionStatusTable.getElementsByTagName('tbody')[0];
 
diff --git a/src/commands/wizard/lwcGenerationCommand.ts b/src/commands/wizard/lwcGenerationCommand.ts
index 819fe2d0..2033f683 100644
--- a/src/commands/wizard/lwcGenerationCommand.ts
+++ b/src/commands/wizard/lwcGenerationCommand.ts
@@ -23,14 +23,12 @@ export type QuickActionStatus = {
 };
 
 export type SObjectQuickActionStatus = {
-    error?: string;
     sobjects: {
         [name: string]: QuickActionStatus;
     };
 };
 
 export type GetSObjectsStatus = {
-    error?: string;
     sobjects: string[];
 };
 
@@ -54,17 +52,29 @@ export class LwcGenerationCommand {
                         type: 'generateLwcQuickActions',
                         action: async (_panel, _data, callback) => {
                             const quickActionStatus =
-                                await LwcGenerationCommand.checkForExistingQuickActions();
+                                await LwcGenerationCommand.checkForExistingQuickActions().catch(
+                                    (error) => {
+                                        if (callback) {
+                                            callback({ error: error });
+                                        }
+                                        return;
+                                    }
+                                );
 
                             const newLwcQuickActionStatus =
                                 await LwcGenerationCommand.generateMissingLwcsAndQuickActions(
                                     extensionUri,
-                                    quickActionStatus
-                                );
+                                    quickActionStatus!
+                                ).catch((error) => {
+                                    if (callback) {
+                                        callback({ error: error });
+                                    }
+                                    return;
+                                });
 
                             // send back updates so UI can be refreshed
                             if (callback) {
-                                callback(newLwcQuickActionStatus);
+                                callback(newLwcQuickActionStatus!);
                             }
                         }
                     },
@@ -73,8 +83,13 @@ export class LwcGenerationCommand {
                         action: async (_panel, _data, callback) => {
                             if (callback) {
                                 const quickActionStatus =
-                                    await LwcGenerationCommand.checkForExistingQuickActions();
-                                callback(quickActionStatus);
+                                    await LwcGenerationCommand.checkForExistingQuickActions().catch(
+                                        (error) => {
+                                            callback({ error: error });
+                                            return;
+                                        }
+                                    );
+                                callback(quickActionStatus!);
                             }
                         }
                     }
@@ -84,7 +99,7 @@ export class LwcGenerationCommand {
     }
 
     static async getSObjectsFromLandingPage(): Promise<GetSObjectsStatus> {
-        return new Promise<GetSObjectsStatus>(async (resolve) => {
+        return new Promise<GetSObjectsStatus>(async (resolve, reject) => {
             const staticResourcesPath =
                 await WorkspaceUtils.getStaticResourcesDir();
             const landingPageJson = 'landing_page.json';
@@ -101,107 +116,117 @@ export class LwcGenerationCommand {
                 await access(landingPagePath);
                 const uem = CommonUtils.loadJsonFromFile(landingPagePath);
                 getSObjectsStatus.sobjects = UEMParser.findSObjects(uem);
+                resolve(getSObjectsStatus);
             } catch (err) {
                 console.warn(
                     `File '${landingPageJson}' does not exist at '${staticResourcesPath}'.`
                 );
-                getSObjectsStatus.error = (err as Error).message;
+                reject((err as Error).message);
             }
-
-            resolve(getSObjectsStatus);
         });
     }
 
     static async checkForExistingQuickActions(): Promise<SObjectQuickActionStatus> {
-        return new Promise<SObjectQuickActionStatus>(async (resolve) => {
-            const results: SObjectQuickActionStatus = { sobjects: {} };
+        return new Promise<SObjectQuickActionStatus>(
+            async (resolve, reject) => {
+                const results: SObjectQuickActionStatus = { sobjects: {} };
+
+                const sObjectsStatus =
+                    await this.getSObjectsFromLandingPage().catch((error) => {
+                        return reject(error);
+                    });
+
+                sObjectsStatus!.sobjects.forEach((sobject) => {
+                    const quickActionStatus: QuickActionStatus = {
+                        view: false,
+                        edit: false,
+                        create: false
+                    };
+                    quickActionStatus.view =
+                        LwcGenerationCommand.checkForExistingQuickAction(
+                            sobject,
+                            'view'
+                        );
+                    quickActionStatus.edit =
+                        LwcGenerationCommand.checkForExistingQuickAction(
+                            sobject,
+                            'edit'
+                        );
+                    quickActionStatus.create =
+                        LwcGenerationCommand.checkForExistingQuickAction(
+                            sobject,
+                            'create'
+                        );
+
+                    results.sobjects[sobject] = quickActionStatus;
+                });
 
-            const sObjectsStatus = await this.getSObjectsFromLandingPage();
-            if (sObjectsStatus.error) {
-                results.error = sObjectsStatus.error;
                 return resolve(results);
             }
-
-            sObjectsStatus.sobjects.forEach((sobject) => {
-                const quickActionStatus: QuickActionStatus = {
-                    view: false,
-                    edit: false,
-                    create: false
-                };
-                quickActionStatus.view =
-                    LwcGenerationCommand.checkForExistingQuickAction(
-                        sobject,
-                        'view'
-                    );
-                quickActionStatus.edit =
-                    LwcGenerationCommand.checkForExistingQuickAction(
-                        sobject,
-                        'edit'
-                    );
-                quickActionStatus.create =
-                    LwcGenerationCommand.checkForExistingQuickAction(
-                        sobject,
-                        'create'
-                    );
-
-                results.sobjects[sobject] = quickActionStatus;
-            });
-
-            return resolve(results);
-        });
+        );
     }
 
     static async generateMissingLwcsAndQuickActions(
         extensionUri: Uri,
         quickActionStatus: SObjectQuickActionStatus
     ): Promise<SObjectQuickActionStatus> {
-        return new Promise<SObjectQuickActionStatus>(async (resolve) => {
-            for (const sobject in quickActionStatus.sobjects) {
-                try {
-                    const quickActions = quickActionStatus.sobjects[sobject];
-
-                    if (
-                        !quickActions.create ||
-                        !quickActions.edit ||
-                        !quickActions.view
-                    ) {
-                        // at least 1 needs to be created
-                        const compactLayoutFields =
-                            await OrgUtils.getCompactLayoutFieldsForSObject(
-                                sobject
+        return new Promise<SObjectQuickActionStatus>(
+            async (resolve, reject) => {
+                for (const sobject in quickActionStatus.sobjects) {
+                    try {
+                        const quickActions =
+                            quickActionStatus.sobjects[sobject];
+
+                        if (
+                            !quickActions.create ||
+                            !quickActions.edit ||
+                            !quickActions.view
+                        ) {
+                            // at least 1 needs to be created
+                            const compactLayoutFields =
+                                await OrgUtils.getCompactLayoutFieldsForSObject(
+                                    sobject
+                                ).catch((err) => {
+                                    reject(
+                                        `An error occurred while obtaining layout for ${sobject} : ${
+                                            (err as Error).message
+                                        }`
+                                    );
+                                    return;
+                                });
+
+                            const codeBuilder = new CodeBuilder(
+                                extensionUri,
+                                sobject,
+                                compactLayoutFields!
                             );
 
-                        const codeBuilder = new CodeBuilder(
-                            extensionUri,
-                            sobject,
-                            compactLayoutFields
-                        );
-
-                        if (!quickActions.view) {
-                            await codeBuilder.generateView();
-                        }
+                            if (!quickActions.view) {
+                                await codeBuilder.generateView();
+                            }
 
-                        if (!quickActions.edit) {
-                            await codeBuilder.generateEdit();
-                        }
+                            if (!quickActions.edit) {
+                                await codeBuilder.generateEdit();
+                            }
 
-                        if (!quickActions.create) {
-                            await codeBuilder.generateCreate();
+                            if (!quickActions.create) {
+                                await codeBuilder.generateCreate();
+                            }
                         }
+                    } catch (err) {
+                        console.error(
+                            `Could not generate quick actions for sobject ${sobject}, so skipping`,
+                            err
+                        );
                     }
-                } catch (err) {
-                    console.error(
-                        `Could not generate quick actions for sobject ${sobject}, so skipping`,
-                        err
-                    );
                 }
-            }
 
-            // Just double check now that things have been created.
-            const newStatus =
-                await LwcGenerationCommand.checkForExistingQuickActions();
-            resolve(newStatus);
-        });
+                // Just double check now that things have been created.
+                const newStatus =
+                    await LwcGenerationCommand.checkForExistingQuickActions();
+                resolve(newStatus);
+            }
+        );
     }
 
     private static checkForExistingQuickAction(
diff --git a/src/test/suite/commands/wizard/lwcGenerationCommand.test.ts b/src/test/suite/commands/wizard/lwcGenerationCommand.test.ts
index 136232c8..a49658af 100644
--- a/src/test/suite/commands/wizard/lwcGenerationCommand.test.ts
+++ b/src/test/suite/commands/wizard/lwcGenerationCommand.test.ts
@@ -16,18 +16,26 @@ import {
 } from '../../../../commands/wizard/lwcGenerationCommand';
 import { WorkspaceUtils } from '../../../../utils/workspaceUtils';
 import { TempProjectDirManager } from '../../../TestHelper';
+import { Uri } from 'vscode';
+import { CompactLayoutField, OrgUtils } from '../../../../utils/orgUtils';
+import { CodeBuilder } from '../../../../utils/codeBuilder';
+import { create } from 'domain';
 
 suite('LWC Generation Command Test Suite', () => {
-    beforeEach(function () {});
+    let sandbox: sinon.SinonSandbox;
+
+    beforeEach(function () {
+        sandbox = sinon.createSandbox();
+    });
 
     afterEach(function () {
-        sinon.restore();
+        sandbox.restore();
     });
 
     test('Quick Action directories check', async () => {
         const baseDir = 'force-app/main/default/quickActions';
-        const statSyncStub = sinon.stub(fs, 'statSync');
-        const statsStub = sinon.createStubInstance(fs.Stats);
+        const statSyncStub = sandbox.stub(fs, 'statSync');
+        const statsStub = sandbox.createStubInstance(fs.Stats);
         statsStub.isFile.returns(true);
 
         // stub the file system responses - any return value is a positive hit, an exception is a negative hit
@@ -51,7 +59,7 @@ suite('LWC Generation Command Test Suite', () => {
             .withArgs(`${baseDir}/sobject2.create.quickAction-meta.xml`)
             .throws('error');
 
-        const getSObjectsStub = sinon.stub(
+        const getSObjectsStub = sandbox.stub(
             LwcGenerationCommand,
             'getSObjectsFromLandingPage'
         );
@@ -97,7 +105,7 @@ suite('LWC Generation Command Test Suite', () => {
 
     test('Should return error status for landing page with invalid json', async () => {
         const dirManager = await TempProjectDirManager.createTempProjectDir();
-        const getWorkspaceDirStub = sinon.stub(
+        const getWorkspaceDirStub = sandbox.stub(
             WorkspaceUtils,
             'getStaticResourcesDir'
         );
@@ -112,9 +120,16 @@ suite('LWC Generation Command Test Suite', () => {
             );
 
             const status =
-                await LwcGenerationCommand.getSObjectsFromLandingPage();
-
-            assert.ok(status.error && status.error.length > 0);
+                await LwcGenerationCommand.getSObjectsFromLandingPage()
+                    .then((results) => {
+                        // an error should have occurred
+                        assert.fail(
+                            'Invalid JSON should have caused a rejection of the promise.'
+                        );
+                    })
+                    .catch((error) => {
+                        assert.ok(error && error.length > 0);
+                    });
         } finally {
             getWorkspaceDirStub.restore();
             await dirManager.removeDir();
@@ -123,7 +138,7 @@ suite('LWC Generation Command Test Suite', () => {
 
     test('Should return 2 sObjects', async () => {
         const dirManager = await TempProjectDirManager.createTempProjectDir();
-        const getWorkspaceDirStub = sinon.stub(
+        const getWorkspaceDirStub = sandbox.stub(
             WorkspaceUtils,
             'getStaticResourcesDir'
         );
@@ -149,4 +164,51 @@ suite('LWC Generation Command Test Suite', () => {
             await dirManager.removeDir();
         }
     });
+
+    test('Should generate view, create, and edit quick actions', async () => {
+        const extensionUri = Uri.file('whateva');
+        const quickActionStatus: SObjectQuickActionStatus = {
+            sobjects: {
+                account: {
+                    view: false,
+                    edit: false,
+                    create: false
+                }
+            }
+        };
+
+        // stubs for OrgUtils.getCompactLayoutFieldsForSObject()
+        const compactLayoutFields: CompactLayoutField[] = [
+            {
+                editableForNew: true,
+                editableForUpdate: true,
+                label: 'label',
+                layoutComponents: [
+                    {
+                        value: 'field1'
+                    }
+                ]
+            }
+        ];
+        const compactLayoutFieldsStub = sandbox
+            .stub(OrgUtils, 'getCompactLayoutFieldsForSObject')
+            .resolves(compactLayoutFields);
+        const quickActionStatusStub = sandbox.stub(
+            LwcGenerationCommand,
+            'checkForExistingQuickActions'
+        );
+        quickActionStatusStub.resolves(quickActionStatus);
+        const codeBuilderStub = sandbox.stub(CodeBuilder.prototype);
+
+        // act
+        const abc =
+            await LwcGenerationCommand.generateMissingLwcsAndQuickActions(
+                extensionUri,
+                quickActionStatus
+            );
+
+        sandbox.assert.calledOnce(codeBuilderStub.generateCreate);
+        sandbox.assert.calledOnce(codeBuilderStub.generateEdit);
+        sandbox.assert.calledOnce(codeBuilderStub.generateView);
+    });
 });