diff --git a/shell/components/EmptyProductPage.vue b/shell/components/EmptyProductPage.vue
new file mode 100644
index 00000000000..8724e10d860
--- /dev/null
+++ b/shell/components/EmptyProductPage.vue
@@ -0,0 +1,70 @@
+<script>
+export default {
+  name: 'EmptyProductPage',
+
+  layout: 'plain',  
+
+  data() {
+    const err = this.$route.meta?.pageError;
+
+    let msg;
+
+    switch (err) {
+      case 'no-nav':
+        msg = [
+          'When a component is not provided for a product, the layout with side navigation is used',
+          'No child items were specified, so this "Default" empty view has been added',
+          'Please add child items to this product'
+        ];
+        break;
+      default:
+        msg = ['No component defined for this product'];
+    }
+
+    return {
+      img: require('~shell/assets/images/generic-plugin.svg'),
+      msg,
+    };
+  },
+};
+</script>
+
+<template>
+  <div class="empty-product-page">
+    <img :src="img" alt="Extension Product Error" />
+    <div class="err-messages">
+      <p v-for="(m, index) in msg" :key="index">{{ m }}</p>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.empty-product-page {
+  align-items: center;
+  display: flex;
+  justify-content: center;
+  opacity: 0.75;
+
+  > img {
+    width: 128px;
+    margin-bottom: 20px;
+  }
+
+  .err-messages {
+    display: flex;
+    align-items: center;
+    text-align: center;
+    flex-direction: column;
+
+    > * {
+      margin-bottom: 8px;
+      font-size: 16px;
+
+      &:last-child {
+        font-weight: bold;
+        color: var(--error);
+      }
+    }
+  }
+}
+</style>
diff --git a/shell/components/nav/Group.vue b/shell/components/nav/Group.vue
index 610a8a33205..346b3b9e78d 100644
--- a/shell/components/nav/Group.vue
+++ b/shell/components/nav/Group.vue
@@ -196,7 +196,10 @@ export default {
           const matchesNavLevel = navLevels.filter((param) => !this.$route.params[param] || this.$route.params[param] !== item.route.params[param]).length === 0;
           const withoutHash = this.$route.hash ? this.$route.fullPath.slice(0, this.$route.fullPath.indexOf(this.$route.hash)) : this.$route.fullPath;
           const withoutQuery = withoutHash.split('?')[0];
-          const itemFullPath = this.$router.resolve(item.route).fullPath;
+
+          let itemFullPath;
+
+          try { itemFullPath = this.$router.resolve(item.route).fullPath; } catch (e) { console.error(e); }
 
           if (matchesNavLevel || itemFullPath === withoutQuery) {
             return true;
diff --git a/shell/components/nav/Header.vue b/shell/components/nav/Header.vue
index 780cce468e2..1d262eddf48 100644
--- a/shell/components/nav/Header.vue
+++ b/shell/components/nav/Header.vue
@@ -239,6 +239,26 @@ export default {
     isHarvester() {
       return this.$store.getters['currentProduct'].inStore === HARVESTER;
     },
+
+    productLabel() {
+      // Old-style product will just show the branding logo
+      // version 2 products will show the product label if set
+      if (!this.currentProduct?.version === 2) {
+        return false;
+      }
+
+      if (this.currentProduct?.label) {
+        return this.currentProduct.label;
+      }
+
+      if (this.currentProduct?.labelKey) {
+        return this.$store.getters['i18n/t'](this.currentProduct.labelKey);
+      }
+
+      const name = this.currentProduct.name;
+
+      return this.$store.getters['i18n/withFallback'](`product."${ name }"`, null, ucFirst(name));;
+    }
   },
 
   watch: {
@@ -518,7 +538,7 @@ export default {
           :alt="t('branding.logos.label')"
         >
         <div class="product-name">
-          {{ prod }}
+          {{ productLabel || prod }}
         </div>
       </div>
     </div>
@@ -534,6 +554,13 @@ export default {
         {{ t(isSingleProduct.productNameKey) }}
       </div>
 
+      <div
+        v-if="productLabel"
+        class="product-name"
+      >
+        {{ productLabel }}
+      </div>
+
       <div
         v-else
         class="side-menu-logo"
diff --git a/shell/components/nav/TopLevelMenu.vue b/shell/components/nav/TopLevelMenu.vue
index 00587e0e838..a12a21f8bc9 100644
--- a/shell/components/nav/TopLevelMenu.vue
+++ b/shell/components/nav/TopLevelMenu.vue
@@ -182,8 +182,23 @@ export default {
           to.params.product = p.name;
         }
 
+        let label;
+
+        // Allow product to specify its label if it is a version 2 product, rather than use convention and a fallback
+        if (p.version === 2) {
+          if (p.labelKey) {
+            label = this.$store.getters['i18n/t'](p.labelKey);
+          } else if (p.label) {
+            label = p.label;
+          }
+        }
+
+        if (!label) {
+          label = this.$store.getters['i18n/withFallback'](`product.${ p.name }`, null, ucFirst(p.name));
+        }
+        
         return {
-          label:             this.$store.getters['i18n/withFallback'](`product."${ p.name }"`, null, ucFirst(p.name)),
+          label,           
           icon:              `icon-${ p.icon || 'copy' }`,
           svg:               p.svg,
           value:             p.name,
diff --git a/shell/core/extension-manager-impl.js b/shell/core/extension-manager-impl.js
index 589ca320023..e5f7451275d 100644
--- a/shell/core/extension-manager-impl.js
+++ b/shell/core/extension-manager-impl.js
@@ -407,6 +407,11 @@ const createExtensionManager = (context) => {
       }
     },
 
+    // Internal use only
+    _add(id, plugin) {
+      plugins[id] = plugin;
+    },
+
     // For debugging
     getAll() {
       return dynamic;
@@ -510,6 +515,26 @@ const createExtensionManager = (context) => {
             }
           });
         }
+
+        // Load products and product extensions using the simpler API
+        if (plugin.productConfigs?.length) {
+          // Add new products first
+          plugin.productConfigs.filter(p => p.newProduct).forEach((productConfig) => {
+            productConfig.apply(plugin, store, app.router, pluginRoutes);
+          });
+
+          // Extend existing products after new products are added 
+          plugin.productConfigs.filter(p => !p.newProduct).forEach((productConfig) => {
+            productConfig.apply(plugin, store, app.router, pluginRoutes);
+          });
+        }
+        
+        // Apply all type configurations
+        if (plugin.resourceTypeConfigs?.length) {
+          plugin.resourceTypeConfigs.forEach((resourceTypeConfig) => {
+            resourceTypeConfig.apply(plugin, store, app.router, pluginRoutes);
+          });
+        }
       });
     },
   };
diff --git a/shell/core/plugin-products.ts b/shell/core/plugin-products.ts
new file mode 100644
index 00000000000..ab069d42d0a
--- /dev/null
+++ b/shell/core/plugin-products.ts
@@ -0,0 +1,254 @@
+import { IPlugin, ProductChild, ProductChildGroup, ProductMetadata, ProductChildMetadata, ProductChildPage, ProductSinglePage, ProductChildResource } from '@shell/core/types';
+import { RouteRecordRaw, Router } from 'vue-router';
+import EmptyProductPage from '@shell/components/EmptyProductPage.vue';
+
+function routeForChild(parentName: string, pageChild: ProductChildPage) {
+  if (pageChild.path) {
+    let name = pageChild.path.replaceAll(':', '').replaceAll('/', '-');
+
+    if (name.startsWith('-')) {
+      name = name.substring(1);
+    }
+  
+    return {
+      name,
+      path: pageChild.path,
+    }
+  }
+
+  return {
+    name: `c-cluster-${ parentName }-${ pageChild.name }`,
+    path: `/c/:cluster/${ parentName.replace('-', '/') }/${ pageChild.name }`,
+  };
+}
+
+export class PluginProduct {
+  private name: string;
+
+  private product?: ProductMetadata;
+
+  public newProduct: boolean = false;
+
+  private singlePage = false;
+
+  constructor(private plugin: IPlugin, product: string | ProductMetadata | ProductSinglePage, private config: ProductChild[]) {
+    // console.error(`Adding product ${ product } with config`, config);
+    // console.log(product);
+
+    if (typeof product === 'string') {
+      this.name = product;
+      this.newProduct = false;
+      this.addRoutes(this.name, config);
+    } else if (typeof product === 'object' && product.name) {
+      this.name = product.name;
+      this.product = product;
+      this.newProduct = true;
+
+      // If the product has a `component` field, then this is a single page product
+      if ((product as any).component) {
+        const singlePageProduct = product as ProductSinglePage;
+
+        // console.error('Product Single Page');
+
+        this.singlePage = true;
+
+        //this.addDefaultRoute();
+        const r = {
+          name: `${ this.name }`,
+          path: `/${ this.name }`,
+          component: singlePageProduct.component,
+          meta: { product: this.name }, // Needed to ensure the correct product is loaded, since 'product' is not a route param
+        };
+
+        plugin.addRoute('plain', r);        
+      }
+
+      this.addRoutes(this.name, config);
+    } else {
+      throw new Error('Invalid product');
+    }
+  };
+
+  private addRoutes(parentName: string, item: ProductChild[]) {
+    // Add routes for any items that need them
+    item.forEach((child: any) => {
+      // Just create routes for pages
+      if ((child as any).component) {
+        const pageChild = child as ProductChildPage;
+
+        // TODO: Support non-explorer (where parent is not c-cluster) routes
+
+        // Check if the route has a path override
+
+        // TODO: Check it has a name
+        const r = {
+          ...routeForChild(parentName, pageChild),
+          component: pageChild.component,
+          meta: { product: this.name },
+          // params: { cluster: '_' } // Not sure about this
+        };
+
+        this.plugin.addRoute(r);
+
+        // Check child routes
+        if (pageChild.extraRoutes) {
+          pageChild.extraRoutes.forEach((cr) => {
+            const name = `${ r.name }-${ cr.name }`;
+            const path = `${ r.path }/${ cr.name }`;
+            const childRoute = {
+              name,
+              path,
+              component: cr.component,
+              meta: { product: this.name },
+            };
+
+            this.plugin.addRoute(childRoute);
+            // console.error('Adding child route', childRoute);
+          });
+        }
+      } else if ((child as any).children) {
+        // TODO: Route for top-level?
+        this.addRoutes(`${ parentName }-${ child.name }`, (child as any).children);
+      }
+    });
+  }
+
+  apply(plugin: IPlugin, store: any, router: Router, pluginRoutes: any): void {
+    const { basicType, configureType, labelGroup, setGroupDefaultType, virtualType, weightGroup, weightType, product } = plugin.DSL(store, this.name);
+
+    // If this is a new product, intialise it
+    if (this.product) {
+      const names = this.getNames(this.name, this.config);
+
+      const defaultResource = names[0] || '';
+
+      let defaultRoute;
+
+      if (defaultResource) {
+        defaultRoute = {
+          name: `c-cluster-${ defaultResource }`,
+          params: {
+            // product: this.name,
+            cluster: '_',
+          }
+        };
+     
+
+        // defaultRoute = {
+        //   name: 'c-cluster-product-resource',
+        //   params: {
+        //     product: this.name,
+        //     cluster: '_',
+        //     resource: defaultResource
+        //   }
+        // };
+      } else {
+        defaultRoute = {
+          name: `${ this.name }`,
+          params: {
+            cluster: '_',
+          }
+        };
+      }
+
+      product({
+        ...this.product,
+        name: this.name,
+        icon: this.product.icon || 'extension',
+        inStore: 'management',
+        showClusterSwitcher: false,
+        category: 'global',
+        version: 2,
+        to: defaultRoute
+        // to: {
+        //   name: this.name,
+        //   params: {
+        //     cluster: 'local',
+        //     product: this.name
+        //   }
+        // }
+      });
+    }
+
+    function configureItem(parentName: string, item: ProductChild, order?: number) {
+      if ((item as any).component) {
+        const pageChild = item as ProductChildPage;
+
+        const route = routeForChild(parentName, pageChild);
+
+        // Page with a component specified maps to a virtual type
+        virtualType({
+          label: pageChild.label,
+          // labelKey:   'catalog.charts.header',
+          namespaced: false,
+          name:       `${ parentName }-${ pageChild.name }`,
+          route:      { name: route.name },
+          weight:     pageChild.weight || order,
+        });
+      } else if (typeof item === 'string') {
+        if (order) {
+          weightType(item as string, order, true);
+        }
+      } else if ((item as any).type) {
+        const typeItem = item as ProductChildResource;
+        const itemOrder = typeItem.weight || order;
+      
+        if (itemOrder) {
+          weightType(typeItem.type, itemOrder, true);
+        }
+      }
+    }
+
+    const names = this.getNames(this.name, this.config);
+
+    // Add the first-level child navigation items
+    basicType(names);
+
+    this.config.forEach((item) => {
+      configureItem(this.name, item);
+
+      // Add the second-level child navigation items
+      if (typeof item === 'object' && (item as any).name && (item as any).children) {
+        const itemGroup = item as ProductChildGroup;
+
+        if (Array.isArray(itemGroup.children)) {
+          const navNames = this.getNames(`${ this.name }-${ itemGroup.name }`, itemGroup.children);
+
+          basicType(navNames, itemGroup.name);
+
+          // Items are ordered from highest number to lowest
+          // We add weights to child items, so that they show up in the order they are defined in, we pick a high number of 500 to start
+          let order = 500;
+
+          // Generate the virtual type (if needed) and configure weight etc for each child item
+          itemGroup.children.forEach((subItem: any) => configureItem(`${ this.name }-${ itemGroup.name }`, subItem, order--));
+
+          if (itemGroup.default) {
+            setGroupDefaultType(itemGroup.name, itemGroup.default);
+          }
+
+          if (item.weight) {
+            weightGroup(itemGroup.name, item.weight, true);
+          }
+
+          if (itemGroup.label || itemGroup.labelKey) {
+            labelGroup(itemGroup.name, itemGroup.label, itemGroup.labelKey);
+          }
+        }
+      }
+    });
+  }
+
+  private getNames(parent: string, data: any): string[] {
+    return data.map((item:any) => {
+      if (typeof item === 'string') {
+        return item;
+      } else if (item.name) {
+        return `${ parent }-${ item.name }` as string;
+      } else if (item.type) {
+        return item.type;
+      }
+      return '';
+    }).filter((name: string) => !!name);
+  }
+}
diff --git a/shell/core/plugin-resource-type.ts b/shell/core/plugin-resource-type.ts
new file mode 100644
index 00000000000..f05c9211519
--- /dev/null
+++ b/shell/core/plugin-resource-type.ts
@@ -0,0 +1,44 @@
+import { IPlugin, ProductChild, ProductChildGroup, ProductMetadata, ProductChildMetadata, ProductChildPage, ProductSinglePage, ProductChildResource, ResourceTypeConfig } from '@shell/core/types';
+import { RouteMeta, RouteRecordRaw, Router } from 'vue-router';
+import EmptyProductPage from '@shell/components/EmptyProductPage.vue';
+import { DSL, PRODUCT_ALL } from '@shell/store/type-map';
+
+export class PluginResourceType {
+  constructor(private type: string, private config: ResourceTypeConfig) {
+  };
+
+  apply(plugin: IPlugin, store: any): void {
+    // Note: Resource Types are not global and not per-product, so we use a fake product name here as its not used
+    //const { basicType, configureType, headers, labelGroup, setGroupDefaultType, virtualType, weightGroup, weightType, product } = plugin.DSL(store, PRODUCT_ALL);
+
+    const {
+      product,
+      basicType,
+      weightType,
+      configureType,
+      componentForType,
+      headers,
+      mapType,
+      spoofedType,
+      virtualType,
+    } = DSL(store, PRODUCT_ALL);    
+
+      console.error('Hello');
+      console.error(PRODUCT_ALL);
+
+      console.error(this);
+
+      if (this.config.options) {
+        configureType(this.type, this.config.options);
+      }
+      
+      if (this.config.listHeaders) {
+        console.error('Applying headers for type:', this.type);
+
+        headers(this.type,
+          this.config.listHeaders.legacy || [],
+          this.config.listHeaders.paginated || []
+        );
+    };
+  }
+};
diff --git a/shell/core/plugin.ts b/shell/core/plugin.ts
index 832eda8e79c..4804017f94d 100644
--- a/shell/core/plugin.ts
+++ b/shell/core/plugin.ts
@@ -18,12 +18,20 @@ import {
   NavHooks, OnNavToPackage, OnNavAwayFromPackage, OnLogIn, OnLogOut,
   PaginationTableColumn,
   ExtensionEnvironment,
-  ServerSidePaginationExtensionConfig
+  ServerSidePaginationExtensionConfig,
+  ProductMetadata,
+  ProductOptions,
+  ProductSinglePage,
+  ProductChild,
+  StandardProductName,
+  ResourceTypeConfig,
 } from './types';
 import coreStore, { coreStoreModule, coreStoreState } from '@shell/plugins/dashboard-store';
 import { defineAsyncComponent, markRaw, Component } from 'vue';
 import { getVersionData, CURRENT_RANCHER_VERSION } from '@shell/config/version';
 import { ExtensionManagerTypes } from '@shell/types/extension-manager';
+import { PluginProduct } from './plugin-products';
+import { PluginResourceType } from '@shell/core/plugin-resource-type';
 
 /** Registration IDs used for different extension points in the extensions catalog */
 export const EXT_IDS = {
@@ -53,6 +61,8 @@ export class Plugin implements IPlugin {
   public onLeave: OnNavAwayFromPackage = () => Promise.resolve();
   public _onLogOut: OnLogOut = () => Promise.resolve();
   public onLogIn: OnLogIn = () => Promise.resolve();
+  public productConfigs: PluginProduct[] = [];
+  public resourceTypeConfigs: PluginResourceType[] = [];
 
   public uiConfig: { [key: string]: any } = {};
 
@@ -110,6 +120,7 @@ export class Plugin implements IPlugin {
   }
 
   // Track which products the plugin creates
+  // Legacy DSL method
   DSL(store: any, productName: string) {
     const storeDSL = STORE_DSL(store, productName);
 
@@ -118,8 +129,34 @@ export class Plugin implements IPlugin {
     return storeDSL;
   }
 
-  addProduct(product: ProductFunction): void {
-    this.products.push(product);
+  addProduct(product: ProductFunction | ProductMetadata | ProductSinglePage, config?: ProductChild[], options?: ProductOptions): void {
+    if (product?.name) {
+      if (!config) {
+        const p = product as ProductSinglePage;
+
+        this.productConfigs.push(new PluginProduct(this, p, []));
+      } else {
+        const p = product as ProductMetadata;
+
+        this.productConfigs.push(new PluginProduct(this, p, config));
+      }
+    } else {
+      this.products.push(product as ProductFunction);
+    }
+  }
+
+  extendProduct(product: StandardProductName | string, config: ProductChild[] | ProductChild): void {
+    const arrayConfig = Array.isArray(config) ? config : [config];
+
+    this.productConfigs.push(new PluginProduct(this, product, arrayConfig));
+  }
+
+  configureResourceType(type: string, config: ResourceTypeConfig): void {
+    this.resourceTypeConfigs.push(new PluginResourceType(type, config));
+  }
+
+  resourceNameFor(apiGroup: string, type: string): string {
+    return `${ apiGroup }.${ type }`.trim().toLowerCase();
   }
 
   addLocale(locale: string, label: string): void {
@@ -382,7 +419,7 @@ export class Plugin implements IPlugin {
     const allowPaths = ['models', 'image'];
     const nparts = name.split('/');
 
-    // Support components in a sub-folder - component_name/index.vue (and ignore other componnets in that folder)
+    // Support components in a sub-folder - component_name/index.vue (and ignore other components in that folder)
     // Allow store-scoped models via sub-folder - pkgname/models/storename/type will be registered as storename/type to avoid overwriting shell/models/type
     if (nparts.length === 2 && !allowPaths.includes(type)) {
       if (nparts[1] !== 'index') {
diff --git a/shell/core/types.ts b/shell/core/types.ts
index 98eebfa6f03..4ef74980f19 100644
--- a/shell/core/types.ts
+++ b/shell/core/types.ts
@@ -1,5 +1,5 @@
 import { ProductFunction } from './plugin';
-import { RouteRecordRaw } from 'vue-router';
+import { RouteComponent, RouteRecordRaw } from 'vue-router';
 import type { ExtensionManager } from '@shell/types/extension-manager';
 import { PaginationSettingsStores } from '@shell/types/resources/settings';
 
@@ -168,6 +168,115 @@ export type LocationConfig = {
   context?: { [key: string]: string},
 };
 
+export enum StandardProductName {
+  EXPLORER = 'explorer',
+  MANAGER = 'manager',
+  SETTINGS = 'settings',
+};
+
+export type ProductConfig = {
+  product: string;
+  config: ProductChild[];
+}[];
+
+/**
+ * Represents a product child in the navigation
+ * This can be a type, a group, or a route.
+ */
+export type ProductChild = ProductChildType | ProductChildResource | ProductChildGroup | ProductChildRoute | ProductChildPage;
+
+type Lazy<T> = () => Promise<T>;
+
+/**
+ * A product child that shows the given Kubernetes (or other) resource type in the navigation
+ */
+export type ProductChildType = string;
+
+/**
+ * Represents a navigation group in a product
+ */
+export type ProductChildResource = {
+  type: string;
+  weight?: number;
+};
+
+export type ProductChildMetadata = {
+  name: string;
+  label?: string;
+  labelKey?: string;
+  weight?: number;
+};
+
+/**
+ * Represents a navigation group in a product
+ */
+export type ProductChildGroup = ProductChildMetadata & {
+  children: ProductChild[];
+  default?: string;
+};
+
+export type ProductChildPageChildRoute = {
+  name: string;
+  component: RouteComponent | Lazy<RouteComponent>;
+}
+
+/**
+ * Represents a custom page
+ */
+export type ProductChildPage = ProductChildMetadata & {
+  path?: string; // Optional route path override
+  component: RouteComponent | Lazy<RouteComponent>;
+  extraRoutes?: ProductChildPageChildRoute[]; // Optional extra routes to create
+};
+
+/**
+ * Represents a custom page
+ */
+export type ProductChildRoute = ProductChildMetadata & {
+  route: RouteRecordRaw;
+};
+
+export interface ProductMetadata {
+  /**
+   * Product name
+   */
+  name: string;
+
+  /**
+   * The icon that should be displayed beside this item in the navigation.
+   */
+  icon?: string,  
+
+  /**
+   * Alternative to the icon property. Use require to reference an SVG file
+   */
+  svg?: Function;
+
+  /**
+   * The category this product belongs under. i.e. 'config', default is 'global'
+   */
+  category?: string; 
+  
+  weight?: number;
+
+  label: string;
+}
+
+export type ProductSinglePage = ProductMetadata & {
+  component: RouteComponent | Lazy<RouteComponent>;
+};
+
+export type ResourceTypeConfig = {
+  options?: {
+    isCreatable?: boolean;
+    isEditable?: boolean;
+  },
+  listHeaders?: {
+    legacy?: HeaderOptions[];
+    paginated?: PaginationHeaderOptions[];
+  }
+};
+
 /**
  * Environment metadata that extensions can access
  */
@@ -269,6 +378,18 @@ export interface ProductOptions {
    */
   name?: string;
 
+  /**
+   * 
+   */
+  label?: string;
+  
+  labelKey?: string;
+
+  iconHeader?: string;
+
+  // Do not use - internal use only
+  version?: number;
+
   /**
    * Leaving these here for completeness but I don't think these should be advertised as useable to plugin creators.
    */
@@ -466,6 +587,8 @@ export interface ConfigureVirtualTypeOptions extends ConfigureTypeOptions {
    * The route that this type should correspond to {@link PluginRouteRecordRaw} {@link RouteRecordRaw}
    */
   route: PluginRouteRecordRaw | RouteRecordRaw | Object;
+
+  weight?: number;
 }
 
 export interface DSLReturnType {
@@ -475,7 +598,7 @@ export interface DSLReturnType {
    * @param group Conditionally a group you want to places all the types in
    * @returns {@link void}
    */
-  basicType: (types: string[], group?: string) => void;
+  basicType: (types: string[] | string, group?: string) => void;
 
   /**
    * Configure a myriad of options for the specified type
@@ -546,6 +669,10 @@ export interface DSLReturnType {
   // moveType: (match, group)
   // setGroupDefaultType: (input, defaultType)
   // spoofedType: (obj)
+
+  labelGroup: (group: string, label: string | undefined, labelKey?: string) => void;
+
+  setGroupDefaultType: (group: string, defaultType: string) => void;
 }
 
 /**
@@ -584,15 +711,50 @@ export type ModelExtensionContext = {
 export type ModelExtensionConstructor = (context: ModelExtensionContext) => Object;
 
 /**
- * Interface for a Dashboard plugin
+ * Interface for a UI Extension
  */
-export interface IPlugin {
+export interface IExtension {
   /**
    * Add a product
+   * @param name 
+   * @param config 
+   * @param options 
+   */
+  addProduct(product: ProductMetadata, config: ProductChild[], options?: ProductOptions): void;
+
+  /**
+   * Add a product
+   * @param product
+   */
+  addProduct(product: ProductSinglePage): void;
+
+  /**
+   * Add a product
+   * @deprecated Use other `addProduct` signatures instead
    * @param importFn Function that will import the module containing a product definition
    */
   addProduct(importFn: ProductFunction): void;
 
+  /**
+   * Extend an existing product
+   *
+   * @param product Product to be extended
+   * @param config Product extension configuration
+   */
+  extendProduct(product: StandardProductName | string, config: ProductChild[] | ProductChild): void;
+
+  /**
+   * Configure a resource type
+   * @param type Name of resource type to configure
+   * @param config Resource type configuration
+   */
+  configureResourceType(type: string, config: ResourceTypeConfig): void;
+
+  /*
+    Get the type name for a given API group and type
+  */
+  resourceNameFor(apiGroup: string, type: string): string;
+
   /**
    * Add a locale to the i18n store
    * @param locale Locale id (e.g. en-us)
@@ -731,6 +893,9 @@ export interface IPlugin {
   get environment(): ExtensionEnvironment;
 }
 
+// Legacy compatibility
+export type IPlugin = IExtension; 
+
 // Internal interface
 // Built-in extensions may use this, but external extensions should not, as this is subject to change
 // Defined as any for now
diff --git a/shell/pages/c/_cluster/_product/index.vue b/shell/pages/c/_cluster/_product/index.vue
index e4a26cfa8f0..1f2c242e4cd 100644
--- a/shell/pages/c/_cluster/_product/index.vue
+++ b/shell/pages/c/_cluster/_product/index.vue
@@ -1,5 +1,25 @@
 <script>
 export default {
+  data() {
+    // Set ready to false initially, so we don't render anything until after we have checked for a redirect
+    return { ready: false };
+  },
+
+  beforeCreate() {
+    // Lookup the product to see if it has a default page or resource
+    const product = this.$store.getters['currentProduct']
+
+    if (product?.to) {
+      const destination = this.$router.resolve(product.to);
+
+      if (destination?.fullPath !== this.$route.fullPath) {
+        return this.$router.replace(product.to);
+      }
+    }
+
+    this.ready = true;
+  },
+
   computed: {
     product() {
       return this.$route.params.product;
@@ -9,7 +29,7 @@ export default {
 </script>
 
 <template>
-  <div>
-    Default dashboard for {{ product }}
+  <div v-if="ready">
+    Default view for {{ product }}
   </div>
 </template>
diff --git a/shell/plugins/plugin.js b/shell/plugins/plugin.js
index 06aa9b3ff43..33d7c02b783 100644
--- a/shell/plugins/plugin.js
+++ b/shell/plugins/plugin.js
@@ -3,6 +3,8 @@ import { allHashSettled } from '@shell/utils/promise';
 import { shouldNotLoadPlugin, UI_PLUGIN_BASE_URL } from '@shell/config/uiplugins';
 import { getKubeVersionData, getVersionData } from '@shell/config/version';
 import versions from '@shell/utils/versions';
+import { listProducts, loadProduct } from '@shell/utils/dynamic-importer';
+import { Plugin as UIPlugin } from '@shell/core/plugin';
 
 export default async function(context) {
   if (process.env.excludeOperatorPkg === 'true') {
@@ -43,6 +45,20 @@ export default async function(context) {
   try {
     const res = await allHashSettled(fetches);
 
+    // Allow legacy products to be loaded as extensions (if migrated to use $init)
+    for (const product of listProducts()) {
+      const impl = await loadProduct(product);
+
+      if (impl?.$init) {
+        const p = new UIPlugin(product);
+
+        impl.$init(p);
+
+        context.$plugin._add(product, p);
+        context.$plugin.applyPlugin(p);
+      }
+    }
+
     // Initialize the built-in extensions now - this is now done here so that built-in extensions get the same, correct environment data (version etc)
     context.$extension.loadBuiltinExtensions();
 
diff --git a/shell/store/type-map.js b/shell/store/type-map.js
index 19c5b9a7c15..c4f0d1e7cad 100644
--- a/shell/store/type-map.js
+++ b/shell/store/type-map.js
@@ -205,6 +205,8 @@ export const ROOT = 'root';
 export const SPOOFED_PREFIX = '__[[spoofed]]__';
 export const SPOOFED_API_PREFIX = '__[[spoofedapi]]__';
 
+export const PRODUCT_ALL = '*';
+
 const instanceMethods = {};
 
 export const IF_HAVE = {
@@ -315,6 +317,12 @@ export function DSL(store, product, module = 'type-map') {
       }
     },
 
+    labelGroup(group, label, labelKey) {
+      store.commit(`${ module }/labelGroup`, {
+        group, label, labelKey
+      });
+    },
+
     setGroupDefaultType(input, defaultType) {
       if ( isArray(input) ) {
         store.commit(`${ module }/setGroupDefaultType`, { groups: input, defaultType });
@@ -395,6 +403,7 @@ export const state = function() {
     groupIgnore:             [],
     groupWeights:            {},
     groupDefaultTypes:       {},
+    groupLabels:             {},
     basicGroupWeights:       { [ROOT]: 1000 },
     groupMappings:           [],
     typeIgnore:              [],
@@ -497,6 +506,15 @@ export const getters = {
     };
   },
 
+  groupLabel(state) {
+    return (group) => {
+      // If this has been explicitly set, use that
+      if (state.groupLabels[group]) {
+        return state.groupLabels[group];
+      }
+    };
+  },
+
   groupForBasicType(state) {
     return (product, schemaId) => {
       return state.basicTypes?.[product]?.[schemaId];
@@ -738,10 +756,21 @@ export const getters = {
 
         // Translate if an entry exists
         let label = name;
-        // i18n-uses nav.group.*
-        const key = `nav.group."${ name }"`;
+        let key;
+
+        // See if we have a configured label for this group
+        const groupLabel = getters['groupLabel'](name);
 
-        if ( rootGetters['i18n/exists'](key) ) {
+        if (groupLabel?.label) {
+          label = groupLabel.label;
+        } else if (groupLabel?.labelKey) {
+          key = groupLabel.labelKey
+        } else {
+          // i18n-uses nav.group.*
+          key = `nav.group."${ name }"`;
+        }
+
+        if (key && rootGetters['i18n/exists'](key) ) {
           label = rootGetters['i18n/t'](key);
         }
 
@@ -1659,6 +1688,10 @@ export const mutations = {
     }
   },
 
+  labelGroup(state, { group, label, labelKey }) {
+    state.groupLabels[group.toLowerCase()] = { label, labelKey };
+  },
+
   // setGroupDefaultType({group: 'core', defaultType: 'name'});
   // By default when a group is clicked, the first item is selected - this allows
   // this behaviour to be changed and a named child type can be chosen
diff --git a/shell/types/rancher/index.d.ts b/shell/types/rancher/index.d.ts
index c7677856e5c..305f307881e 100644
--- a/shell/types/rancher/index.d.ts
+++ b/shell/types/rancher/index.d.ts
@@ -5,6 +5,7 @@ declare module '@rancher/auto-import' {
 declare module '@shell/store/type-map' {
   export function DSL(store: any, name: string): any;
   export function isAdminUser(getters: any): boolean;
+  export const PRODUCT_ALL = '*';
 }
 
 declare module '@shell/plugins/dashboard-store';
diff --git a/shell/utils/dynamic-importer.js b/shell/utils/dynamic-importer.js
index 4a1ba411abe..817917c19b2 100644
--- a/shell/utils/dynamic-importer.js
+++ b/shell/utils/dynamic-importer.js
@@ -94,8 +94,9 @@ export function loadProduct(name) {
 }
 
 export function listProducts() {
-  const ctx = require.context('@shell/config/product', true, /.*/);
-  const products = ctx.keys().filter(path => !path.endsWith('.js') && path.startsWith('./')).map(path => path.substr(2));
+  // We just want the .js or .ts files
+  const ctx = require.context('@shell/config/product', true, /\.\/.*\.[js|ts]/);
+  const products = ctx.keys().map(path => path.substr(2)).map(path => path.slice(0, -3));
 
   return products;
 }
diff --git a/shell/utils/router.js b/shell/utils/router.js
index 7165b7ce146..d0a59bf2c24 100644
--- a/shell/utils/router.js
+++ b/shell/utils/router.js
@@ -41,6 +41,14 @@ export function getClusterFromRoute(to) {
 export function getProductFromRoute(to) {
   let product = to.params?.product;
 
+  // If no product, see if the route indicates the product via route metadata
+  if (!product) {
+    product = findMeta(to, 'product');
+  }
+
+  // Special case of the form c-cluster-<product>, extract product from there
+  // TODO: We should remove this, as it's better to be explicit via params or meta
+  // This can match unexpected routes
   if ( !product ) {
     const match = to.name?.match(/^c-cluster-([^-]+)/);
 
@@ -49,11 +57,6 @@ export function getProductFromRoute(to) {
     }
   }
 
-  // If still no product, see if the route indicates the product via route metadata
-  if (!product) {
-    product = findMeta(to, 'product');
-  }
-
   return product;
 }