diff --git a/src/extensions/extension-discovery.ts b/src/extensions/extension-discovery.ts
index dbaeb0142d..202c059e6b 100644
--- a/src/extensions/extension-discovery.ts
+++ b/src/extensions/extension-discovery.ts
@@ -328,6 +328,8 @@ export class ExtensionDiscovery extends Singleton {
 
     const extensions = await this.ensureExtensions();
 
+    console.log(`STARTUP ${new Date()} ensure extensions ready`);
+
     this.isLoaded = true;
 
     return extensions;
@@ -387,14 +389,20 @@ export class ExtensionDiscovery extends Singleton {
   async ensureExtensions(): Promise<Map<LensExtensionId, InstalledExtension>> {
     const bundledExtensions = await this.loadBundledExtensions();
 
+    console.log(`STARTUP  ${new Date()} const bundledExtensions = await this.loadBundledExtensions() ready`);
+
     await this.installBundledPackages(this.packageJsonPath, bundledExtensions);
+    console.log(`STARTUP  ${new Date()} await this.installBundledPackages(this.packageJsonPath, bundledExtensions);ready`);
 
     const userExtensions = await this.loadFromFolder(this.localFolderPath, bundledExtensions.map((extension) => extension.manifest.name));
 
+    console.log(`STARTUP  ${new Date()} await userExtensions = await this.loadFromFolder ready ${new Date()}`);
+
     for (const extension of userExtensions) {
       if ((await fse.pathExists(extension.manifestPath)) === false) {
         try {
           await this.installPackage(extension.absolutePath);
+          console.log(`STARTUP  ${new Date()} install this.installPackage(${extension.absolutePath}); ready`);
         } catch (error) {
           const message = error.message || error || "unknown error";
           const { name, version } = extension.manifest;
@@ -403,6 +411,7 @@ export class ExtensionDiscovery extends Singleton {
         }
       }
     }
+    console.log(`STARTUP  ${new Date()} install ALL user extensions ready ${new Date()}`);
 
     const extensions = bundledExtensions.concat(userExtensions);
 
diff --git a/src/extensions/extension-loader.ts b/src/extensions/extension-loader.ts
index 8d249355c3..b67fe38d2f 100644
--- a/src/extensions/extension-loader.ts
+++ b/src/extensions/extension-loader.ts
@@ -62,7 +62,7 @@ export class ExtensionLoader extends Singleton {
   protected instancesByName = observable.map<string, LensExtension>();
 
   // IPC channel to broadcast changes to extensions from main
-  protected static readonly extensionsMainChannel = "extensions:main";
+  public static readonly extensionsMainChannel = "extensions:main";
 
   // IPC channel to broadcast changes to extensions from renderer
   protected static readonly extensionsRendererChannel = "extensions:renderer";
@@ -73,7 +73,11 @@ export class ExtensionLoader extends Singleton {
   @observable isLoaded = false;
 
   get whenLoaded() {
-    return when(() => this.isLoaded);
+    return when(() => {
+      console.log(`STARTUP ExtensionLoader whenLoaded() when()`);
+
+      return this.isLoaded;
+    });
   }
 
   constructor() {
@@ -146,7 +150,7 @@ export class ExtensionLoader extends Singleton {
     }
 
     await Promise.all([this.whenLoaded]);
-
+    console.log(`STARTUP await Promise.all([this.whenLoaded]);`);
     // broadcasting extensions between main/renderer processes
     reaction(() => this.toJSON(), () => this.broadcastExtensions(), {
       fireImmediately: true,
@@ -328,7 +332,7 @@ export class ExtensionLoader extends Singleton {
   }
 
   protected autoInitExtensions(register: (ext: LensExtension) => Promise<Disposer[]>) {
-    return reaction(() => this.toJSON(), installedExtensions => {
+    return reaction(() => this.toJSON(), async installedExtensions => {
       for (const [extId, extension] of installedExtensions) {
         const alreadyInit = this.instances.has(extId) || this.nonInstancesByName.has(extension.manifest.name);
 
@@ -343,7 +347,8 @@ export class ExtensionLoader extends Singleton {
 
             const instance = new LensExtensionClass(extension);
 
-            instance.enable(register);
+            await instance.enable(register);
+            console.log("STARTUP await instance.enable(register) returned");
             this.instances.set(extId, instance);
           } catch (err) {
             logger.error(`${logModule}: activation extension error`, { ext: extension, err });
diff --git a/src/extensions/lens-extension.ts b/src/extensions/lens-extension.ts
index 5d562953ca..93296e65d5 100644
--- a/src/extensions/lens-extension.ts
+++ b/src/extensions/lens-extension.ts
@@ -88,11 +88,13 @@ export class LensExtension {
     }
 
     try {
+      logger.info(`STARTUP LENS Extension enable ${new Date()}`);
       await this.onActivate();
       this.isEnabled = true;
 
       this[Disposers].push(...await register(this));
       logger.info(`[EXTENSION]: enabled ${this.name}@${this.version}`);
+      logger.info(`STARTUP LENS Extension enabled ${new Date()}`);
     } catch (error) {
       logger.error(`[EXTENSION]: failed to activate ${this.name}@${this.version}: ${error}`);
     }
diff --git a/src/main/index.ts b/src/main/index.ts
index 1c5b80042c..ce91df04f9 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -42,7 +42,7 @@ import type { LensExtensionId } from "../extensions/lens-extension";
 import { installDeveloperTools } from "./developer-tools";
 import { LensProtocolRouterMain } from "./protocol-handler";
 import { disposer, getAppVersion, getAppVersionFromProxyServer, storedKubeConfigFolder } from "../common/utils";
-import { bindBroadcastHandlers, ipcMainOn } from "../common/ipc";
+import { bindBroadcastHandlers, broadcastMessage, ipcMainOn } from "../common/ipc";
 import { startUpdateChecking } from "./app-updater";
 import { IpcRendererNavigationEvents } from "../renderer/navigation/events";
 import { pushCatalogToRenderer } from "./catalog-pusher";
@@ -248,39 +248,51 @@ app.on("ready", async () => {
     windowManager.ensureMainWindow();
   }
 
+  const initExtensions = async () => {
+    logger.info("🧩 Initializing extensions");
+
+    // call after windowManager to see splash earlier
+    try {
+      const extensions = await extensionDiscovery.load();
+
+      logger.info(`STARTUP ${new Date()} await extensionDiscovery.load() `);
+
+      // Start watching after bundled extensions are loaded
+      await extensionDiscovery.watchExtensions();
+      logger.info(`STARTUP ${new Date()} extensionDiscovery.watchExtensions()`);
+
+
+      // Subscribe to extensions that are copied or deleted to/from the extensions folder
+      extensionDiscovery.events
+        .on("add", (extension: InstalledExtension) => {
+          ExtensionLoader.getInstance().addExtension(extension);
+        })
+        .on("remove", (lensExtensionId: LensExtensionId) => {
+          ExtensionLoader.getInstance().removeExtension(lensExtensionId);
+        });
+
+      ExtensionLoader.getInstance().initExtensions(extensions);
+      logger.info(`STARTUP ${new Date()} 🧩 Initializing extensions done  ExtensionLoader.getInstance().initExtensions(extensions)`);
+    } catch (error) {
+      dialog.showErrorBox("Lens Error", `Could not load extensions${error?.message ? `: ${error.message}` : ""}`);
+      console.error(error);
+      console.trace();
+    }
+  };
+
   ipcMainOn(IpcRendererNavigationEvents.LOADED, async () => {
     onCloseCleanup.push(pushCatalogToRenderer(catalogEntityRegistry));
     await ensureDir(storedKubeConfigFolder());
     KubeconfigSyncManager.getInstance().startSync();
+    logger.info(`STARTUP LENS Init extensions start ${new Date()}`);
+    await initExtensions();
+    logger.info(`STARTUP LENS Init extensions end ${new Date()}`);
     startUpdateChecking();
     LensProtocolRouterMain.getInstance().rendererLoaded = true;
+    console.log(`STARTUP LENS EXTENSIONS:LOADED ${new Date()}`);
+    broadcastMessage("EXTENSIONS:LOADED");
   });
 
-  logger.info("🧩 Initializing extensions");
-
-  // call after windowManager to see splash earlier
-  try {
-    const extensions = await extensionDiscovery.load();
-
-    // Start watching after bundled extensions are loaded
-    extensionDiscovery.watchExtensions();
-
-    // Subscribe to extensions that are copied or deleted to/from the extensions folder
-    extensionDiscovery.events
-      .on("add", (extension: InstalledExtension) => {
-        ExtensionLoader.getInstance().addExtension(extension);
-      })
-      .on("remove", (lensExtensionId: LensExtensionId) => {
-        ExtensionLoader.getInstance().removeExtension(lensExtensionId);
-      });
-
-    ExtensionLoader.getInstance().initExtensions(extensions);
-  } catch (error) {
-    dialog.showErrorBox("Lens Error", `Could not load extensions${error?.message ? `: ${error.message}` : ""}`);
-    console.error(error);
-    console.trace();
-  }
-
   setTimeout(() => {
     appEventBus.emit({ name: "service", action: "start" });
   }, 1000);
diff --git a/src/main/window-manager.ts b/src/main/window-manager.ts
index 70713b22e8..2813766438 100644
--- a/src/main/window-manager.ts
+++ b/src/main/window-manager.ts
@@ -176,7 +176,10 @@ export class WindowManager extends Singleton {
 
     if (!this.mainWindow) {
       viewHasLoaded = new Promise<void>(resolve => {
-        ipcMain.once(IpcRendererNavigationEvents.LOADED, () => resolve());
+        ipcMain.once("EXTENSIONS:LOADED", () => {
+          logger.info(`STARTUP LENS EXTENSIONS:LOADED: ${showSplash} ${new Date()}`);
+          resolve();
+        } );
       });
       await this.initMainWindow(showSplash);
     }
@@ -185,8 +188,9 @@ export class WindowManager extends Singleton {
       await viewHasLoaded;
       await delay(50); // wait just a bit longer to let the first round of rendering happen
       logger.info("[WINDOW-MANAGER]: Main window has reported that it has loaded");
-
+      logger.info(`STARTUP LENS view has loaded let's show mainWindow ${new Date()}`);
       this.mainWindow.show();
+      logger.info(`STARTUP LENS let's close the splashWindow ${new Date()}`);
       this.splashWindow?.close();
       this.splashWindow = undefined;
       setTimeout(() => {