diff --git a/shell/detail/provisioning.cattle.io.cluster.vue b/shell/detail/provisioning.cattle.io.cluster.vue
index 953fa3c9608..c455d66265b 100644
--- a/shell/detail/provisioning.cattle.io.cluster.vue
+++ b/shell/detail/provisioning.cattle.io.cluster.vue
@@ -1,12 +1,9 @@
 <script>
 import Loading from '@shell/components/Loading';
 import { Banner } from '@components/Banner';
-import ResourceTable, { defaultTableSortGenerationFn } from '@shell/components/ResourceTable';
 import ResourceTabs from '@shell/components/form/ResourceTabs';
-import SortableTable from '@shell/components/SortableTable';
 import CopyCode from '@shell/components/CopyCode';
 import Tab from '@shell/components/Tabbed/Tab';
-import { allHash } from '@shell/utils/promise';
 import { CAPI, MANAGEMENT, NORMAN, SNAPSHOT } from '@shell/config/types';
 import {
   STATE, NAME as NAME_COL, AGE, AGE_NORMAN, INTERNAL_EXTERNAL_IP, STATE_NORMAN, ROLES, MACHINE_NODE_OS, MANAGEMENT_NODE_OS, NAME,
@@ -29,34 +26,14 @@ import Socket, {
   EVENT_CONNECT_ERROR
 } from '@shell/utils/socket';
 import { get } from '@shell/utils/object';
-import CapiMachineDeployment from '@shell/models/cluster.x-k8s.io.machinedeployment';
 import { isAlternate } from '@shell/utils/platform';
 import PaginatedResourceTable from '@shell/components/PaginatedResourceTable';
+import { PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { hasAccessToLocalCluster } from '@shell/utils/cluster';
 
 let lastId = 1;
 const ansiup = new AnsiUp();
 
-/**
- * Machine Deployment has a reference to the 'template' used to create that deployment
- * For an empty machine pool, we (obviously) don't get any machine deployments for that pool.
- *
- * This class allows us to fake a machine deployment - when created, we set additional properties (_cluster etc)
- * and use these in the getters.
- **/
-class EmptyCapiMachineDeployment extends CapiMachineDeployment {
-  get inClusterSpec() {
-    return this._clusterSpec;
-  }
-
-  get cluster() {
-    return this._cluster;
-  }
-
-  get template() {
-    return this._template;
-  }
-}
-
 export default {
   emits: ['input'],
 
@@ -64,9 +41,7 @@ export default {
     Loading,
     Banner,
     PaginatedResourceTable,
-    ResourceTable,
     ResourceTabs,
-    SortableTable,
     Tab,
     CopyCode,
     CustomCommand,
@@ -103,78 +78,12 @@ export default {
       this.extCustomParams = { provider: this.value.machineProvider };
     }
 
-    const schema = this.$store.getters[`management/schemaFor`](CAPI.RANCHER_CLUSTER);
-    const fetchOne = { schemaDefinitions: schema.fetchResourceFields() };
-
     if ( this.value.isImported || this.value.isCustom || this.value.isHostedKubernetesProvider ) {
-      fetchOne.clusterToken = this.value.getOrCreateToken();
-    }
-
-    // Need to get Norman clusters so that we can check if user has permissions to access the local cluster
-    if ( this.$store.getters['rancher/canList'](NORMAN.CLUSTER) ) {
-      fetchOne.normanClusters = this.$store.dispatch('rancher/findAll', { type: NORMAN.CLUSTER });
+      this.clusterToken = await this.value.getOrCreateToken();
     }
 
-    if ( this.value.isRke1 && this.$store.getters['isRancher'] ) {
-      fetchOne.normanNodePools = this.$store.dispatch('rancher/findAll', { type: NORMAN.NODE_POOL });
-    }
-
-    const fetchOneRes = await allHash(fetchOne);
-
-    this.allMachines = fetchOneRes.machines || [];
-    this.allMachineDeployments = fetchOneRes.machineDeployments || [];
-    this.haveMachines = !!fetchOneRes.machines;
-    this.haveDeployments = !!fetchOneRes.machineDeployments;
-    this.clusterToken = fetchOneRes.clusterToken;
-
-    if (fetchOneRes.normanClusters) {
-      // Does the user have access to the local cluster? Need to in order to be able to show the 'Related Resources' tab
-      this.hasLocalAccess = !!fetchOneRes.normanClusters.find((c) => c.internal);
-    }
-
-    const fetchTwo = {};
-
-    const thisClusterMachines = this.allMachineDeployments.filter((deployment) => {
-      return deployment?.spec?.clusterName === this.value.metadata.name;
-    });
-
-    const machineDeploymentTemplateType = thisClusterMachines?.[0]?.templateType;
-
-    if (machineDeploymentTemplateType && this.$store.getters['management/schemaFor'](machineDeploymentTemplateType) ) {
-      fetchTwo.mdtt = this.$store.dispatch('management/findAll', { type: machineDeploymentTemplateType });
-    }
-
-    if (!this.showMachines) {
-      if ( this.$store.getters['management/canList'](MANAGEMENT.NODE) ) {
-        fetchTwo.allNodes = this.$store.dispatch('management/findAll', { type: MANAGEMENT.NODE });
-      }
-
-      if ( this.$store.getters['management/canList'](MANAGEMENT.NODE_POOL) ) {
-        fetchTwo.allNodePools = this.$store.dispatch('management/findAll', { type: MANAGEMENT.NODE_POOL });
-      }
-
-      if ( this.$store.getters['management/canList'](MANAGEMENT.NODE_TEMPLATE) ) {
-        fetchTwo.nodeTemplates = this.$store.dispatch('management/findAll', { type: MANAGEMENT.NODE_TEMPLATE });
-      }
-    }
-
-    const fetchTwoRes = await allHash(fetchTwo);
-
-    this.allNodes = fetchTwoRes.allNodes || [];
-    this.haveNodes = !!fetchTwoRes.allNodes;
-    this.allNodePools = fetchTwoRes.allNodePools || [];
-    this.haveNodePools = !!fetchTwoRes.allNodePools;
-    this.machineTemplates = fetchTwoRes.mdtt || [];
-
-    // Fetch RKE template revisions so we can show when an updated template is available
-    // This request does not need to be blocking
-    if ( this.$store.getters['management/canList'](MANAGEMENT.RKE_TEMPLATE) ) {
-      this.$store.dispatch('management/findAll', { type: MANAGEMENT.RKE_TEMPLATE });
-    }
-
-    if ( this.$store.getters['management/canList'](MANAGEMENT.RKE_TEMPLATE_REVISION) ) {
-      this.$store.dispatch('management/findAll', { type: MANAGEMENT.RKE_TEMPLATE_REVISION });
-    }
+    // Does the user have access to the local cluster? Need to in order to be able to show the 'Related Resources' tab
+    this.hasLocalAccess = await hasAccessToLocalCluster(this.$store);
   },
 
   created() {
@@ -198,11 +107,9 @@ export default {
       allNodes:              [],
       allNodePools:          [],
 
-      haveMachines:    false,
-      haveDeployments: false,
-      haveNodes:       false,
-      haveNodePools:   false,
-      hasLocalAccess:  false,
+      haveMachines:   false,
+      haveNodes:      false,
+      hasLocalAccess: false,
 
       mgmtNodeSchema:     this.$store.getters[`management/schemaFor`](MANAGEMENT.NODE),
       machineSchema:      this.$store.getters[`management/schemaFor`](CAPI.MACHINE),
@@ -231,15 +138,15 @@ export default {
     };
   },
 
-  watch: {
-    showNodes(neu) {
-      if (neu) {
-        this.$store.dispatch('rancher/findAll', { type: NORMAN.NODE });
-      }
+  computed: {
+    machinePools() {
+      return this.$store.getters['management/all'](CAPI.MACHINE);
+    },
+
+    machineNodes() {
+      return this.$store.getters['management/all'](MANAGEMENT.NODE);
     },
-  },
 
-  computed: {
     defaultTab() {
       if (this.showRegistration) {
         if (this.value.isRke2 ? !this.machines?.length : !this.nodes?.length) {
@@ -271,97 +178,8 @@ export default {
       return info;
     },
 
-    fakeMachines() {
-      const machineNameFn = (clusterName, machinePoolName) => `${ clusterName }-${ machinePoolName }`;
-
-      // When we scale up, the quantity will change to N+1 - so from 0 to 1, the quantity changes,
-      // but it takes tiem for the machine to appear, so the pool is empty, but if we just go off on a non-zero quqntity
-      // then the pool would be hidden - so we find empty pool by checking the machines
-      const emptyPools = (this.value.spec.rkeConfig?.machinePools || []).filter((mp) => {
-        const machineFullName = machineNameFn(this.value.name, mp.name);
-
-        const machines = this.value.machines.filter((machine) => {
-          const isElementalCluster = machine.spec?.infrastructureRef?.apiVersion.startsWith('elemental.cattle.io');
-          const machinePoolInfName = machine.spec?.infrastructureRef?.name;
-
-          if (isElementalCluster) {
-            return machinePoolInfName.includes(machineFullName);
-          }
-
-          // if labels exist, then the machineFullName must unequivocally be equal to manchineLabelFullName (based on labels)
-          const machineLabelClusterName = machine.metadata?.labels?.['cluster.x-k8s.io/cluster-name'];
-          const machineLabelPoolName = machine.metadata?.labels?.['rke.cattle.io/rke-machine-pool-name'];
-
-          if (machineLabelClusterName && machineLabelPoolName) {
-            const manchineLabelFullName = machineNameFn(machineLabelClusterName, machineLabelPoolName);
-
-            return machineFullName === manchineLabelFullName;
-          }
-
-          return machinePoolInfName.startsWith(machineFullName);
-        });
-
-        return machines.length === 0;
-      });
-
-      // When a deployment has no machines it's not shown.... so add a fake machine to it
-      // This is a catch all scenario seen in older node pool world but not deployments
-      return emptyPools.map((mp, i) => {
-        const pool = new EmptyCapiMachineDeployment(
-          {
-            id:       i,
-            metadata: {
-              name:      `${ this.value.nameDisplay }-${ mp.name }`,
-              namespace: this.value.namespace,
-            },
-            spec: {}
-          },
-          {
-            getters:     this.$store.getters,
-            rootGetters: this.$root.$store.getters,
-          }
-        );
-
-        const templateNamePrefix = `${ pool.metadata.name }-`;
-
-        // All of these properties are needed to ensure the pool displays correctly and that we can scale up and down
-        pool._template = this.machineTemplates.find((t) => t.metadata.name.startsWith(templateNamePrefix));
-        pool._cluster = this.value;
-        pool._clusterSpec = mp;
-
-        return {
-          poolId:           pool.id,
-          mainRowKey:       'isFake',
-          pool,
-          availableActions: []
-        };
-      });
-    },
-
-    machines() {
-      return [...this.value.machines, ...this.fakeMachines];
-    },
-
-    nodes() {
-      const nodes = this.allNodes.filter((x) => x.mgmtClusterId === this.value.mgmtClusterId);
-
-      return [...nodes, ...this.fakeNodes];
-    },
-
-    fakeNodes() {
-      // When a pool has no nodes it's not shown.... so add a fake node to it
-      const emptyNodePools = this.allNodePools.filter((x) => x.spec.clusterName === this.value.mgmtClusterId && x.spec.quantity === 0);
-
-      return emptyNodePools.map((np) => ({
-        spec:             { nodePoolName: np.id.replace('/', ':') },
-        mainRowKey:       'isFake',
-        pool:             np,
-        availableActions: []
-      }));
-    },
-
     showMachines() {
-      const showMachines = this.haveMachines && (this.value.isRke2 || !!this.machines.length);
+      const showMachines = this.machinePools.length && (this.value.isRke2 || !!this.machines.length);
 
       return showMachines && this.extDetailTabs.machines;
     },
@@ -548,26 +366,65 @@ export default {
   },
 
   methods: {
-    async fetchSecondaryResourcesMachinePools() {
-      if ( this.$store.getters['management/canList'](CAPI.MACHINE_DEPLOYMENT) ) {
-        await this.$store.dispatch('management/findAll', { type: CAPI.MACHINE_DEPLOYMENT });
+    snapshotApiFilter(pagination) {
+      if (!pagination.filters) {
+        pagination.filters = [];
       }
 
-      if ( this.$store.getters['management/canList'](CAPI.MACHINE) ) {
-        await this.$store.dispatch('management/findAll', { type: CAPI.MACHINE });
+      const required = PaginationParamFilter.createSingleField({
+        field: 'spec.clusterName',
+        exact: true,
+        value: this.value.metadata.name,
+      });
+
+      pagination.filters.push(required);
+
+      return pagination;
+    },
+
+    snapshotLocalFilter(rows) {
+      return rows.filter((r) => r.spec.clusterName === this.value.metadata.name);
+    },
+
+    machinePoolApiFilter(pagination) {
+      if (!pagination.filters) {
+        pagination.filters = [];
       }
+
+      const required = PaginationParamFilter.createSingleField({
+        field: 'spec.clusterName',
+        exact: true,
+        value: this.value.metadata.name,
+      });
+
+      pagination.filters.push(required);
+
+      return pagination;
+    },
+
+    machinePoolLocalFilter(rows) {
+      return rows.filter((r) => r.spec.clusterName === this.value.metadata.name);
     },
-    async fetchPageSecondaryResourcesMachinePools() {},
 
-    async fetchSecondaryResourcesSnapshots() {
-      if ( this.$store.getters['management/canList'](SNAPSHOT) ) {
-        await this.$store.dispatch('management/findAll', { type: SNAPSHOT });
+    nodePoolApiFilter(pagination) {
+      if (!pagination.filters) {
+        pagination.filters = [];
       }
+
+      const required = PaginationParamFilter.createSingleField({
+        field: 'spec.clusterName',
+        exact: true,
+        value: this.value.metadata.name,
+      });
+
+      pagination.filters.push(required);
+
+      return pagination;
     },
-    async fetchPageSecondaryResourcesSnapshots() {},
 
-    async fetchSecondaryResourcesNodes() {},
-    async fetchPageSecondaryResourcesNodes() {},
+    nodePoolLocalFilter(rows) {
+      return rows.filter((r) => r.spec.clusterName === this.value.metadata.name);
+    },
 
     toggleScaleDownModal( event, resources ) {
       // Check if the user held alt key when an action is clicked.
@@ -686,26 +543,6 @@ export default {
         return day(time).format(this.dateTimeFormatStr);
       }
     },
-
-    machineSortGenerationFn() {
-      // The sort generation function creates a unique value and is used to create a key including sort details.
-      // The unique key determines if the list is redrawn or a cached version is shown.
-      // Because we ensure the 'not in a pool' group is there via a row, and timing issues, the unqiue key doesn't change
-      // after a machine is added/removed... so the list won't update... so we need to inject a string to ensure the key is fresh
-      const base = defaultTableSortGenerationFn(this.machineSchema, this.$store);
-
-      return base + (!!this.fakeMachines.length ? '-fake' : '');
-    },
-
-    nodeSortGenerationFn() {
-      // The sort generation function creates a unique value and is used to create a key including sort details.
-      // The unique key determines if the list is redrawn or a cached version is shown.
-      // Because we ensure the 'not in a pool' group is there via a row, and timing issues, the unqiue key doesn't change
-      // after a machine is added/removed... so the list won't update... so we need to inject a string to ensure the key is fresh
-      const base = defaultTableSortGenerationFn(this.mgmtNodeSchema, this.$store);
-
-      return base + (!!this.fakeNodes.length ? '-fake' : '');
-    },
   }
 };
 </script>
@@ -740,13 +577,12 @@ export default {
       @update:value="$emit('input', $event)"
     >
       <Tab
-        v-if="showMachines"
+        v-if="showMachines || true"
         name="machine-pools"
         :label-key="value.isCustom ? 'cluster.tabs.machines' : 'cluster.tabs.machinePools'"
         :weight="4"
       >
         <PaginatedResourceTable
-          :rows="machines"
           :schema="machineSchema"
           :headers="machineHeaders"
           default-sort-by="name"
@@ -754,19 +590,9 @@ export default {
           :group-by="value.isCustom ? null : 'poolId'"
           group-ref="pool"
           :group-sort="['pool.nameDisplay']"
-          :sort-generation-fn="machineSortGenerationFn"
+          :api-filter="machinePoolApiFilter"
+          :local-filter="machinePoolLocalFilter"
         >
-          <template #main-row:isFake="{fullColspan}">
-            <tr class="main-row">
-              <td
-                :colspan="fullColspan"
-                class="no-entries"
-              >
-                {{ t('node.list.noNodes') }}
-              </td>
-            </tr>
-          </template>
-
           <template #group-by="{group}">
             <div
               class="pool-row"
@@ -828,7 +654,7 @@ export default {
       </Tab>
 
       <Tab
-        v-else-if="showNodes"
+        v-else-if="showNodes || true"
         name="node-pools"
         :label-key="value.isCustom ? 'cluster.tabs.machines' : 'cluster.tabs.machinePools'"
         :weight="4"
@@ -841,19 +667,9 @@ export default {
           :group-by="value.isCustom ? null : 'spec.nodePoolName'"
           group-ref="pool"
           :group-sort="['pool.nameDisplay']"
-          :sort-generation-fn="nodeSortGenerationFn"
+          :api-filter="nodePoolApiFilter"
+          :local-filter="nodePoolLocalFilter"
         >
-          <template #main-row:isFake="{fullColspan}">
-            <tr class="main-row">
-              <td
-                :colspan="fullColspan"
-                class="no-entries"
-              >
-                {{ t('node.list.noNodes') }}
-              </td>
-            </tr>
-          </template>
-
           <template #group-by="{group}">
             <div
               class="pool-row"
@@ -1020,9 +836,13 @@ export default {
           default-sort-by="age"
           :table-actions="value.isRke1"
           :search="false"
-          :groupable="true"
+          :namespaces="false"
           :group-by="snapshotsGroupBy"
+          :api-filter="snapshotApiFilter"
+          :local-filter="snapshotLocalFilter"
         >
+          <!-- Removing the group by namespace/list buttons in the middle header -->
+          <template #header-middle />
           <template #header-right>
             <AsyncButton
               mode="snapshot"
diff --git a/shell/utils/cluster.js b/shell/utils/cluster.js
index ac05751ae47..ad57a01b8c6 100644
--- a/shell/utils/cluster.js
+++ b/shell/utils/cluster.js
@@ -3,7 +3,7 @@ import { camelToTitle } from '@shell/utils/string';
 import { CAPI } from '@shell/config/labels-annotations';
 import { MANAGEMENT, VIRTUAL_HARVESTER_PROVIDER } from '@shell/config/types';
 import { SETTING } from '@shell/config/settings';
-import { PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { PaginationFilterField, PaginationParamFilter, FilterArgs } from '@shell/types/store/pagination.types';
 
 /**
  * Combination of paginationFilterHiddenLocalCluster and paginationFilterOnlyKubernetesClusters
@@ -63,6 +63,26 @@ export function paginationFilterHiddenLocalCluster(store, filterMgmtCluster = tr
   return PaginationParamFilter.createMultipleFields(filter);
 }
 
+export async function hasAccessToLocalCluster(store) {
+  const opt = {
+    force:      true,
+    pagination: new FilterArgs({
+      filters: PaginationParamFilter.createMultipleFields([new PaginationFilterField({
+        field:  `id`,
+        value:  'fleet-local/local',
+        exact:  true,
+        equals: false,
+      })]),
+    })
+  };
+
+  const clusters = await store.dispatch('management/findPage', { type: MANAGEMENT.CLUSTER, opt });
+
+  const localCluster = clusters.filter((c) => c.id === 'local');
+
+  return localCluster.length > 0;
+}
+
 /**
  * The vai backed api's `filter` equivalent of `filterOnlyKubernetesClusters`
  *
diff --git a/shell/utils/pagination-utils.ts b/shell/utils/pagination-utils.ts
index db40dc104a3..e0465b57c94 100644
--- a/shell/utils/pagination-utils.ts
+++ b/shell/utils/pagination-utils.ts
@@ -95,15 +95,7 @@ class PaginationUtils {
         return setting === enabledFor.resource?.id;
       }
 
-      if (setting.resource === enabledFor.resource?.id) {
-        if (!!setting.context) {
-          return enabledFor.resource?.context ? setting.context.includes(enabledFor.resource.context) : false;
-        }
-
-        return true;
-      }
-
-      return false;
+      return enabledFor.resource?.context ? setting.context.includes(enabledFor.resource.context) : false;
     })) {
       return true;
     }
diff --git a/shell/utils/settings.ts b/shell/utils/settings.ts
index 1af7553a724..29208bc142c 100644
--- a/shell/utils/settings.ts
+++ b/shell/utils/settings.ts
@@ -104,5 +104,11 @@ export const getPerformanceSetting = (rootGetters: Record<string, (arg0: string,
   // Start with the default and overwrite the values from the setting - ensures we have defaults for newly added options
   const safeDefaults = Object.assign({}, DEFAULT_PERF_SETTING);
 
-  return Object.assign(safeDefaults, perfSetting || {});
+  const r = Object.assign(safeDefaults, perfSetting || {});
+
+  r.serverPagination.stores.cluster.resources.enableSome.enabled.push('provisioning.cattle.io.cluster');
+  r.serverPagination.stores.cluster.resources.enableSome.enabled.push('cluster');
+  r.serverPagination.stores.cluster.resources.enableSome.enabled.push('rke.cattle.io.etcdsnapshot');
+
+  return r;
 };