diff --git a/shell/components/SortableTable/sorting.js b/shell/components/SortableTable/sorting.js
index 0791d1c50bd..392a9fab738 100644
--- a/shell/components/SortableTable/sorting.js
+++ b/shell/components/SortableTable/sorting.js
@@ -79,7 +79,7 @@ export default {
 
       if ( markedColumn ) {
         this._defaultSortBy = markedColumn.name;
-        descending = markedColumn.defaultSortDescending;
+        descending = markedColumn.defaultSortDescending || false;
       } else if ( nameColumn ) {
         // Use the name column if there is one
         this._defaultSortBy = nameColumn.name;
diff --git a/shell/components/nav/TopLevelMenu.helper.ts b/shell/components/nav/TopLevelMenu.helper.ts
index ccab261e475..47bfd63bb2b 100644
--- a/shell/components/nav/TopLevelMenu.helper.ts
+++ b/shell/components/nav/TopLevelMenu.helper.ts
@@ -28,7 +28,9 @@ interface UpdateArgs {
   searchTerm: string,
   pinnedIds: string[],
   unPinnedMax?: number,
-  forceWatch?: boolean
+  forceWatch?: boolean,
+  mgmtClusterRevision?: string,
+  provClusterRevision?: string,
 }
 
 type MgmtCluster = {
@@ -179,7 +181,7 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
     // No need to monitor for changes, the UNPINNED request will handle it
     this.clustersPinnedWrapper = new PaginationWrapper({
       $store,
-      id:         'tlm-pinned-clusters',
+      id:         'top-level-menu-pinned-clusters',
       enabledFor: {
         store:    STORE.MANAGEMENT,
         resource: {
@@ -192,13 +194,19 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
     // Fetch all UNPINNED clusters capped at 10 (see `clustersOthers` description for details)
     this.clustersOthersWrapper = new PaginationWrapper({
       $store,
-      id:       'tlm-unpinned-clusters',
-      onChange: async({ forceWatch }) => {
-        if (this.args) {
+      id:       'top-level-menu-unpinned-clusters',
+      onChange: async({ forceWatch, revision }) => {
+        if (!this.args) {
+          return;
+        }
+        try {
           await this.update({
             ...this.args,
-            forceWatch
+            forceWatch,
+            mgmtClusterRevision: revision,
           });
+        } catch {
+          // Failures should be logged lower down, not much we can do here except catch to prevent whole ui page warnings in dev mode
         }
       },
       enabledFor: {
@@ -213,13 +221,19 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
     // Fetch all prov clusters for the mgmt clusters we have
     this.provClusterWrapper = new PaginationWrapper({
       $store,
-      id:       'tlm-prov-clusters',
-      onChange: async({ forceWatch }) => {
-        if (this.args) {
+      id:       'top-level-menu-prov-clusters',
+      onChange: async({ forceWatch, revision }) => {
+        if (!this.args) {
+          return;
+        }
+        try {
           await this.update({
             ...this.args,
-            forceWatch
+            forceWatch,
+            provClusterRevision: revision,
           });
+        } catch {
+          // Failures should be logged lower down, not much we can do here except catch to prevent whole ui page warnings in dev mode
         }
       },
       enabledFor: {
@@ -251,7 +265,8 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
       pinned: MgmtCluster[],
       notPinned: MgmtCluster[]
     } = await allHash(promises) as any;
-    const provClusters = await this.updateProvCluster(res.notPinned, res.pinned, args.forceWatch || false);
+
+    const provClusters = await this.updateProvCluster(res.notPinned, res.pinned, args);
     const provClustersByMgmtId = provClusters.reduce((res: { [mgmtId: string]: ProvCluster}, provCluster: ProvCluster) => {
       if (provCluster.mgmtClusterId) {
         res[provCluster.mgmtClusterId] = provCluster;
@@ -357,7 +372,9 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
         sort:                 DEFAULT_SORT,
         projectsOrNamespaces: []
       },
-    }).then((r) => r.data);
+      revision: args.mgmtClusterRevision
+    })
+      .then((r) => r.data);
   }
 
   /**
@@ -378,15 +395,17 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
         sort:                 DEFAULT_SORT,
         projectsOrNamespaces: []
       },
-    }).then((r) => r.data);
+      revision: args.mgmtClusterRevision
+    })
+      .then((r) => r.data);
   }
 
   /**
    * Find all provisioning clusters associated with the displayed mgmt clusters
    */
-  private async updateProvCluster(notPinned: MgmtCluster[], pinned: MgmtCluster[], forceWatch: boolean): Promise<ProvCluster[]> {
+  private async updateProvCluster(notPinned: MgmtCluster[], pinned: MgmtCluster[], args: UpdateArgs): Promise<ProvCluster[]> {
     return this.provClusterWrapper.request({
-      forceWatch,
+      forceWatch: args.forceWatch,
       pagination: {
         filters: [
           PaginationParamFilter.createMultipleFields(
@@ -400,7 +419,9 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
         sort:                 [],
         projectsOrNamespaces: []
       },
-    }).then((r) => r.data);
+      revision: args.provClusterRevision
+    })
+      .then((r) => r.data);
   }
 }
 
@@ -585,6 +606,8 @@ export class TopLevelMenuHelperLegacy extends BaseTopLevelMenuHelper implements
  */
 class TopLevelMenuHelperService {
   private _helper?: TopLevelMenuHelper;
+  public initialized = false;
+
   public init($store: VuexStore) {
     if (this._helper) {
       return;
@@ -599,6 +622,8 @@ class TopLevelMenuHelperService {
     });
 
     this._helper = canPagination ? new TopLevelMenuHelperPagination({ $store }) : new TopLevelMenuHelperLegacy({ $store });
+
+    this.initialized = true;
   }
 
   public async reset() {
diff --git a/shell/components/nav/TopLevelMenu.vue b/shell/components/nav/TopLevelMenu.vue
index 00587e0e838..c1ce2523aa3 100644
--- a/shell/components/nav/TopLevelMenu.vue
+++ b/shell/components/nav/TopLevelMenu.vue
@@ -27,6 +27,9 @@ export default {
   },
 
   data() {
+    const sideNavServiceInitialized = sideNavService.initialized;
+    const maxClustersToShow = MENU_MAX_CLUSTERS;
+
     sideNavService.init(this.$store);
 
     const { displayVersion, fullVersion } = getVersionInfo(this.$store);
@@ -43,26 +46,27 @@ export default {
     const provClusters = !canPagination && hasProvCluster ? this.$store.getters[`management/all`](CAPI.RANCHER_CLUSTER) : [];
     const mgmtClusters = !canPagination ? this.$store.getters[`management/all`](MANAGEMENT.CLUSTER) : [];
 
-    if (!canPagination) {
-      // Reduce the impact of the initial load, but only if we're not making a request
+    if (!canPagination || !sideNavServiceInitialized) {
+      // Reduce the impact of the initial load, or properly initialised
+      // Doing this here means we don't need an 'immediate' on the watches below
       const args = {
-        pinnedIds:   this.pinnedIds,
-        searchTerm:  this.search,
-        unPinnedMax: this.maxClustersToShow
+        pinnedIds:   this.$store.getters['prefs/get'](PINNED_CLUSTERS),
+        searchTerm:  '',
+        unPinnedMax: maxClustersToShow
       };
 
       helper.update(args);
     }
 
     return {
-      shown:             false,
+      shown:         false,
       displayVersion,
       fullVersion,
-      clusterFilter:     '',
+      clusterFilter: '',
       hasProvCluster,
-      maxClustersToShow: MENU_MAX_CLUSTERS,
-      emptyCluster:      BLANK_CLUSTER,
-      routeCombo:        false,
+      maxClustersToShow,
+      emptyCluster:  BLANK_CLUSTER,
+      routeCombo:    false,
 
       canPagination,
       helper,
@@ -284,7 +288,6 @@ export default {
     // 2. When SSP is disabled (legacy) reduce fn churn (this was a known performance customer issue)
 
     pinnedIds: {
-      immediate: true,
       handler(neu, old) {
         if (sameContents(neu, old)) {
           return;
@@ -302,20 +305,28 @@ export default {
 
     provClusters: {
       handler(neu, old) {
+        if (this.canPagination) {
+          // Shouldn't be doing this at all if pagination is on (updates handled by  TopLevelMenu pagination wrapper)
+          return;
+        }
+
         // Potentially incredibly high throughput. Changes should be at least limited (slow if state change, quick if added/removed). Shouldn't get here if SSP
         this.updateClusters(this.pinnedIds, neu?.length === old?.length ? 'slow' : 'quick');
       },
-      deep:      true,
-      immediate: true,
+      deep: true,
     },
 
     mgmtClusters: {
       handler(neu, old) {
+        if (this.canPagination) {
+          // Shouldn't be doing this at all if pagination is on (updates handled by  TopLevelMenu pagination wrapper)
+          return;
+        }
+
         // Potentially incredibly high throughput. Changes should be at least limited (slow if state change, quick if added/removed). Shouldn't get here if SSP
         this.updateClusters(this.pinnedIds, neu?.length === old?.length ? 'slow' : 'quick');
       },
-      deep:      true,
-      immediate: true,
+      deep: true,
     },
 
     hideLocalCluster() {
@@ -454,16 +465,25 @@ export default {
         unPinnedMax: this.maxClustersToShow
       };
 
-      switch (speed) {
-      case 'slow':
-        this.debouncedHelperUpdateSlow(args);
-        break;
-      case 'medium':
-        this.debouncedHelperUpdateMedium(args);
-        break;
-      case 'quick':
-        this.debouncedHelperUpdateQuick(args);
-        break;
+      try {
+        switch (speed) {
+        case 'slow':
+          this.debouncedHelperUpdateSlow(args);
+          break;
+        case 'medium':
+          this.debouncedHelperUpdateMedium(args);
+          break;
+        case 'quick':
+          this.debouncedHelperUpdateQuick(args);
+          break;
+        }
+      } catch (err) {
+        if (this.canPagination) {
+          // Double bubble up errors here, errors are tracked further down
+          // Note that this won't pick up async errors, further tweaks are required for that
+        } else {
+          throw err;
+        }
       }
     }
   }
diff --git a/shell/components/nav/__tests__/TopLevelMenu.helper.test.ts b/shell/components/nav/__tests__/TopLevelMenu.helper.test.ts
new file mode 100644
index 00000000000..766e9833579
--- /dev/null
+++ b/shell/components/nav/__tests__/TopLevelMenu.helper.test.ts
@@ -0,0 +1,277 @@
+import TopLevelMenuHelperService, { TopLevelMenuHelperLegacy, TopLevelMenuHelperPagination } from '../TopLevelMenu.helper';
+import { CAPI, MANAGEMENT } from '@shell/config/types';
+import PaginationWrapper from '@shell/utils/pagination-wrapper';
+
+// Mock dependencies
+jest.mock('@shell/utils/pagination-wrapper');
+jest.mock('@shell/utils/cluster', () => ({
+  filterHiddenLocalCluster:     jest.fn((clusters) => clusters),
+  filterOnlyKubernetesClusters: jest.fn((clusters) => clusters),
+  paginationFilterClusters:     jest.fn(() => []),
+}));
+
+describe('topLevelMenu.helper', () => {
+  let mockStore: any;
+
+  beforeEach(() => {
+    mockStore = {
+      getters: {
+        'management/schemaFor':         jest.fn(),
+        'management/all':               jest.fn(),
+        'management/paginationEnabled': jest.fn(),
+      },
+      dispatch: jest.fn(),
+    };
+
+    jest.clearAllMocks();
+    (PaginationWrapper as unknown as jest.Mock).mockImplementation(() => ({
+      request:   jest.fn().mockResolvedValue({ data: [] }),
+      onDestroy: jest.fn(),
+    }));
+  });
+
+  describe('class: TopLevelMenuHelperLegacy', () => {
+    it('should dispatch findAll for CAPI.RANCHER_CLUSTER on init if schema exists', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      new TopLevelMenuHelperLegacy({ $store: mockStore });
+      expect(mockStore.dispatch).toHaveBeenCalledWith('management/findAll', { type: CAPI.RANCHER_CLUSTER });
+    });
+
+    it('should not dispatch findAll if schema does not exist', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(false);
+      new TopLevelMenuHelperLegacy({ $store: mockStore });
+      expect(mockStore.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('should filter and sort clusters correctly in update', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtClusters = [
+        {
+          id: 'c1', nameDisplay: 'Cluster 1', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+        },
+        {
+          id: 'c2', nameDisplay: 'Cluster 2', isReady: true, pinned: true, pin: jest.fn(), unpin: jest.fn()
+        },
+        {
+          id: 'local', nameDisplay: 'Local', isReady: true, pinned: true, isLocal: true, pin: jest.fn(), unpin: jest.fn()
+        },
+      ];
+      const provClusters = [
+        { mgmt: { id: 'c1' } },
+        { mgmt: { id: 'c2' } },
+        { mgmt: { id: 'local' } },
+      ];
+
+      mockStore.getters['management/all'].mockImplementation((type: string) => {
+        if (type === MANAGEMENT.CLUSTER) {
+          return mgmtClusters;
+        }
+        if (type === CAPI.RANCHER_CLUSTER) {
+          return provClusters;
+        }
+
+        return [];
+      });
+
+      const helper = new TopLevelMenuHelperLegacy({ $store: mockStore });
+
+      // Test with no search, expecting pinned clusters (local + c2)
+      await helper.update({
+        searchTerm: '',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersPinned).toHaveLength(2);
+      expect(helper.clustersPinned[0].id).toBe('local');
+      expect(helper.clustersPinned[1].id).toBe('c2');
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c1');
+
+      // Test with search
+      await helper.update({
+        searchTerm: 'Cluster 1',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c1');
+    });
+  });
+
+  describe('class: TopLevelMenuHelperPagination', () => {
+    it('should initialize PaginationWrappers', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      new TopLevelMenuHelperPagination({ $store: mockStore });
+      expect(PaginationWrapper).toHaveBeenCalledTimes(3);
+    });
+
+    it('should update clusters correctly', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtPinned = [{
+        id: 'c1', nameDisplay: 'Pinned', isReady: true, pinned: true, pin: jest.fn(), unpin: jest.fn()
+      }];
+      const mgmtOthers = [{
+        id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+      }];
+      const provClusters = [
+        { mgmtClusterId: 'c1' },
+        { mgmtClusterId: 'c2' }
+      ];
+
+      const mockRequestPinned = jest.fn().mockResolvedValue({ data: mgmtPinned });
+      const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
+      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
+
+      (PaginationWrapper as unknown as jest.Mock)
+        .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
+
+      const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
+
+      const input = {
+        searchTerm: '',
+        pinnedIds:  ['c1'],
+      };
+
+      await helper.update(input);
+
+      expect(mockRequestPinned).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equals: true, exact: true, field: 'id', value: input.pinnedIds[0]
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          projectsOrNamespaces: [],
+          sort:                 [{ asc: false, field: 'spec.internal' }, { asc: false, field: 'status.connected' }, { asc: true, field: 'spec.displayName' }]
+        },
+        revision: undefined
+      });
+      expect(mockRequestOthers).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equality: '!=', equals: false, exact: true, exists: false, field: 'id', value: input.pinnedIds[0]
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          pageSize:             undefined,
+          projectsOrNamespaces: [],
+          sort:                 [{ asc: false, field: 'spec.internal' }, { asc: false, field: 'status.connected' }, { asc: true, field: 'spec.displayName' }]
+        },
+        revision: undefined
+      });
+      expect(mockRequestProv).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equals: true, exact: true, field: 'status.clusterName', value: mgmtOthers[0].id
+            }, {
+              equals: true, exact: true, field: 'status.clusterName', value: mgmtPinned[0].id
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          projectsOrNamespaces: [],
+          sort:                 []
+        },
+        revision: undefined
+      });
+
+      expect(helper.clustersPinned).toHaveLength(1);
+      expect(helper.clustersPinned[0].id).toBe('c1');
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c2');
+    });
+
+    it('should filter out mgmt clusters without matching prov clusters', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtOthers = [{
+        id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+      }];
+      // No prov cluster for c2
+      const provClusters: any[] = [];
+
+      const mockRequestPinned = jest.fn().mockResolvedValue({ data: [] });
+      const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
+      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
+
+      (PaginationWrapper as unknown as jest.Mock)
+        .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
+
+      const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
+
+      await helper.update({
+        searchTerm: '',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersOthers).toHaveLength(0);
+    });
+  });
+
+  describe('class: TopLevelMenuHelperService', () => {
+    beforeEach(async() => {
+      await TopLevelMenuHelperService.reset();
+    });
+
+    it('should throw error if helper is accessed before init', () => {
+      expect(() => TopLevelMenuHelperService.helper).toThrow('Unable to use the side nav cluster helper (not initialised)');
+    });
+
+    it('should initialize with Legacy helper when pagination is disabled', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+
+      TopLevelMenuHelperService.init(mockStore);
+
+      expect(TopLevelMenuHelperService.helper).toBeInstanceOf(TopLevelMenuHelperLegacy);
+    });
+
+    it('should initialize with Pagination helper when pagination is enabled', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(true);
+
+      TopLevelMenuHelperService.init(mockStore);
+
+      expect(TopLevelMenuHelperService.helper).toBeInstanceOf(TopLevelMenuHelperPagination);
+    });
+
+    it('should not re-initialize if already initialized', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+      TopLevelMenuHelperService.init(mockStore);
+      const helper1 = TopLevelMenuHelperService.helper;
+
+      // Change condition
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(true);
+      TopLevelMenuHelperService.init(mockStore);
+      const helper2 = TopLevelMenuHelperService.helper;
+
+      expect(helper1).toBe(helper2);
+      expect(helper2).toBeInstanceOf(TopLevelMenuHelperLegacy);
+    });
+
+    it('should reset correctly', async() => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+      TopLevelMenuHelperService.init(mockStore);
+
+      const helper = TopLevelMenuHelperService.helper;
+      const destroySpy = jest.spyOn(helper, 'destroy');
+
+      await TopLevelMenuHelperService.reset();
+
+      expect(destroySpy).toHaveBeenCalledWith();
+      expect(() => TopLevelMenuHelperService.helper).toThrow('Unable to use the side nav cluster helper (not initialised)');
+    });
+  });
+});
diff --git a/shell/components/nav/__tests__/TopLevelMenu.test.ts b/shell/components/nav/__tests__/TopLevelMenu.test.ts
index d78ef746fae..d414ab71159 100644
--- a/shell/components/nav/__tests__/TopLevelMenu.test.ts
+++ b/shell/components/nav/__tests__/TopLevelMenu.test.ts
@@ -5,6 +5,15 @@ import { PINNED_CLUSTERS } from '@shell/store/prefs';
 import { nextTick } from 'vue';
 import sideNavService from '@shell/components/nav/TopLevelMenu.helper';
 
+jest.mock('@shell/utils/pagination-wrapper', () => {
+  return jest.fn().mockImplementation(() => {
+    return {
+      request:   jest.fn().mockResolvedValue({ data: [] }),
+      onDestroy: jest.fn(),
+    };
+  });
+});
+
 /**
  * `clusters` doubles up as both mgmt and prov clusters (don't shoot the messenger)
  */
@@ -55,11 +64,14 @@ describe('topLevelMenu', () => {
   beforeEach(() => {
     jest.useFakeTimers();
     sideNavService.reset();
+    sideNavService.initialized = false;
+    jest.restoreAllMocks();
   });
 
   afterEach(() => {
     jest.runOnlyPendingTimers();
     jest.useRealTimers();
+    jest.restoreAllMocks();
   });
 
   it('should display clusters', async() => {
@@ -434,8 +446,6 @@ describe('topLevelMenu', () => {
     describe('should displays a no results message if have clusters but', () => {
       it('given no matching clusters', async() => {
         const wrapper: Wrapper<InstanceType<typeof TopLevelMenu>> = mount(TopLevelMenu, {
-          data: () => ({ clusterFilter: 'whatever' }),
-
           global: {
             mocks: {
               $route: {},
@@ -454,6 +464,8 @@ describe('topLevelMenu', () => {
           },
         });
 
+        await wrapper.setData({ clusterFilter: 'whatever' });
+
         await waitForIt();
 
         const noResults = wrapper.find('[data-testid="top-level-menu-no-results"]');
@@ -527,8 +539,6 @@ describe('topLevelMenu', () => {
       it('given clusters with status pinned', async() => {
         const search = 'you found me';
         const wrapper: Wrapper<InstanceType<typeof TopLevelMenu>> = mount(TopLevelMenu, {
-          data: () => ({ clusterFilter: search }),
-
           global: {
             mocks: {
               $route: {},
@@ -548,6 +558,8 @@ describe('topLevelMenu', () => {
           },
         });
 
+        await wrapper.setData({ clusterFilter: search });
+
         await waitForIt();
 
         const noResults = wrapper.find('[data-testid="top-level-menu-no-results"]');
@@ -557,4 +569,148 @@ describe('topLevelMenu', () => {
       });
     });
   });
+
+  describe('initialization', () => {
+    it('should initialize sideNavService', () => {
+      const spyInit = jest.spyOn(sideNavService, 'init');
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: { ...generateStore([]) },
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(spyInit).toHaveBeenCalled(); // eslint-disable-line jest/prefer-called-with
+    });
+
+    it('should call helper.update if pagination is disabled', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => false;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).toHaveBeenCalledWith({
+        pinnedIds: [], searchTerm: '', unPinnedMax: 10
+      });
+    });
+
+    it('should call helper.update if pagination is enabled but service not initialized', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      sideNavService.initialized = false;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).toHaveBeenCalledWith({
+        pinnedIds: [], searchTerm: '', unPinnedMax: 10
+      });
+    });
+
+    it('should NOT call helper.update if pagination is enabled and service initialized', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      sideNavService.initialized = true;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should populate clusters from store if pagination is disabled', () => {
+      const clusters = [{ id: 'c1' }];
+      const store = generateStore(clusters);
+
+      store.getters['management/paginationEnabled'] = () => false;
+      store.getters['management/schemaFor'] = () => true;
+
+      const wrapper = mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(wrapper.vm.provClusters).toStrictEqual(clusters);
+      expect(wrapper.vm.mgmtClusters).toStrictEqual(clusters);
+    });
+
+    it('should NOT populate clusters from store if pagination is enabled', () => {
+      const clusters = [{ id: 'c1' }];
+      const store = generateStore(clusters);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      store.getters['management/schemaFor'] = () => true;
+
+      const wrapper = mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(wrapper.vm.provClusters).toStrictEqual([]);
+      expect(wrapper.vm.mgmtClusters).toStrictEqual([]);
+    });
+  });
 });
diff --git a/shell/list/catalog.cattle.io.clusterrepo.vue b/shell/list/catalog.cattle.io.clusterrepo.vue
index 7dcd86aeb8c..9ae3b297c7d 100644
--- a/shell/list/catalog.cattle.io.clusterrepo.vue
+++ b/shell/list/catalog.cattle.io.clusterrepo.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import PaginatedResourceTable from '@shell/components/PaginatedResourceTable.vue';
 import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
-import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+import { RancherKubeMetadata } from '@shell/types/rancher/steve.api';
 import { PaginationArgs, PaginationParamFilter } from '@shell/types/store/pagination.types';
 import { defineComponent } from 'vue';
 
diff --git a/shell/list/projectsecret.vue b/shell/list/projectsecret.vue
index db79c960ec8..d13b6ec9e64 100644
--- a/shell/list/projectsecret.vue
+++ b/shell/list/projectsecret.vue
@@ -10,7 +10,7 @@ import { TableColumn } from '@shell/types/store/type-map';
 import { mapGetters } from 'vuex';
 import { GROUP_RESOURCES, mapPref } from '@shell/store/prefs';
 import { DEFAULT_PROJECT, SYSTEM_PROJECT, UI_PROJECT_SECRET, UI_PROJECT_SECRET_COPY } from '@shell/config/labels-annotations';
-import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+import { RancherKubeMetadata } from '@shell/types/rancher/steve.api';
 import {
   AGE, SECRET_DATA, STATE, SUB_TYPE, NAME as NAME_COL,
 } from '@shell/config/table-headers';
diff --git a/shell/plugins/dashboard-store/actions.js b/shell/plugins/dashboard-store/actions.js
index fa6bfeb9e8f..77626a29a76 100644
--- a/shell/plugins/dashboard-store/actions.js
+++ b/shell/plugins/dashboard-store/actions.js
@@ -471,7 +471,7 @@ export default {
       return findAllGetter(getters, type, opt);
     }
 
-    console.log(`Find Page: [${ ctx.state.config.namespace }] ${ type }. Page: ${ opt.pagination.page }. Size: ${ opt.pagination.pageSize }. Sort: ${ opt.pagination.sort.map((s) => s.field).join(', ') }`); // eslint-disable-line no-console
+    console.log(`Find Page: [${ ctx.state.config.namespace }] ${ type }. Page: ${ opt.pagination.page }. Revision: ${ opt.revision || 'none' }. Size: ${ opt.pagination.pageSize }. Sort: ${ opt.pagination.sort.map((s) => s.field).join(', ') }`); // eslint-disable-line no-console
     opt = opt || {};
     opt.url = getters.urlFor(type, null, opt);
 
@@ -491,7 +491,7 @@ export default {
       return Promise.reject(e);
     }
 
-    // Of type @StorePagination
+    // Of type @StorePaginationResult
     const pagination = opt.pagination ? {
       request: {
         namespace:  opt.namespaced,
@@ -500,7 +500,8 @@ export default {
       result: {
         count:     out.count,
         pages:     out.pages || Math.ceil(out.count / (opt.pagination.pageSize || Number.MAX_SAFE_INTEGER)),
-        timestamp: new Date().getTime()
+        timestamp: new Date().getTime(),
+        revision:  out.revision
       }
     } : undefined;
 
diff --git a/shell/plugins/steve/__tests__/revision.test.ts b/shell/plugins/steve/__tests__/revision.test.ts
new file mode 100644
index 00000000000..0f1e653647b
--- /dev/null
+++ b/shell/plugins/steve/__tests__/revision.test.ts
@@ -0,0 +1,84 @@
+import { SteveRevision } from '../revision';
+
+describe('class: SteveRevision', () => {
+  describe('constructor', () => {
+    it('should correctly parse a numeric string', () => {
+      const rev = new SteveRevision('123');
+
+      expect(rev.asNumber).toBe(123);
+      expect(rev.isNumber).toBe(true);
+    });
+
+    it('should correctly parse a number', () => {
+      const rev = new SteveRevision(456);
+
+      expect(rev.asNumber).toBe(456);
+      expect(rev.isNumber).toBe(true);
+    });
+
+    it('should handle non-numeric strings', () => {
+      const rev = new SteveRevision('abc');
+
+      expect(rev.asNumber).toBeNaN();
+      expect(rev.isNumber).toBe(false);
+    });
+
+    it('should handle undefined', () => {
+      const rev = new SteveRevision(undefined);
+
+      expect(rev.asNumber).toBeNaN();
+      expect(rev.isNumber).toBe(false);
+    });
+  });
+
+  describe('method: isNewerThan', () => {
+    it('should return true if current revision is greater than provided revision', () => {
+      const r1 = new SteveRevision('10');
+      const r2 = new SteveRevision('5');
+
+      expect(r1.isNewerThan(r2)).toBe(true);
+    });
+
+    it('should return false if current revision is less than provided revision', () => {
+      const r1 = new SteveRevision('5');
+      const r2 = new SteveRevision('10');
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+
+    it('should return false if revisions are equal', () => {
+      const r1 = new SteveRevision('10');
+      const r2 = new SteveRevision('10');
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+
+    it('should return false if current revision is not a number', () => {
+      const r1 = new SteveRevision('abc');
+      const r2 = new SteveRevision('10');
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+
+    it('should return false if provided revision is not a number', () => {
+      const r1 = new SteveRevision('10');
+      const r2 = new SteveRevision('abc');
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+
+    it('should return false if current revision is undefined', () => {
+      const r1 = new SteveRevision(undefined);
+      const r2 = new SteveRevision('10');
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+
+    it('should return false if provided revision is undefined', () => {
+      const r1 = new SteveRevision('10');
+      const r2 = new SteveRevision(undefined);
+
+      expect(r1.isNewerThan(r2)).toBe(false);
+    });
+  });
+});
diff --git a/shell/plugins/steve/__tests__/subscribe.spec.ts b/shell/plugins/steve/__tests__/subscribe.spec.ts
index 95e18425291..948d8727bde 100644
--- a/shell/plugins/steve/__tests__/subscribe.spec.ts
+++ b/shell/plugins/steve/__tests__/subscribe.spec.ts
@@ -3,6 +3,7 @@ import { REVISION_TOO_OLD } from '../../../utils/socket';
 import { STEVE_WATCH_MODE } from '../../../types/store/subscribe.types';
 import backOff from '../../../utils/back-off';
 import { SteveWatchEventListenerManager } from '../../subscribe-events';
+import { STEVE_RESPONSE_CODE } from '../../../types/rancher/steve.api';
 
 describe('steve: subscribe', () => {
   describe('actions', () => {
@@ -110,6 +111,139 @@ describe('steve: subscribe', () => {
         expect(commit).toHaveBeenCalledWith('setInError', { msg, reason: 'NO_PERMS' });
       });
     });
+
+    describe('fetchPageResources', () => {
+      const dispatch = jest.fn();
+      const getters = {
+        backOffId:    jest.fn(),
+        typeEntry:    jest.fn(),
+        canBackoff:   jest.fn(),
+        watchStarted: jest.fn(),
+        inError:      jest.fn(),
+      };
+      let backOffSpy: any;
+      const context = { $socket: {} };
+
+      beforeEach(() => {
+        jest.clearAllMocks();
+        backOffSpy = {
+          getBackOff: jest.spyOn(backOff, 'getBackOff'),
+          reset:      jest.spyOn(backOff, 'reset'),
+          recurse:    jest.spyOn(backOff, 'recurse'),
+        };
+        getters.backOffId.mockReturnValue('backoff-id');
+        getters.typeEntry.mockReturnValue({ revision: '10' });
+        backOffSpy.getBackOff.mockReturnValue({ metadata: { revision: '10' } } as any);
+        backOffSpy.recurse.mockResolvedValue(undefined);
+      });
+
+      afterEach(() => {
+        jest.restoreAllMocks();
+      });
+
+      it('should abort if current revision is newer than target revision', async() => {
+        // Current (10) > Target (5)
+        const params = {
+          resourceType: 'type', namespace: 'ns', revision: '5'
+        };
+
+        await actions.fetchPageResources.call(context, { getters, dispatch }, {
+          opt: {}, storePagination: {}, params
+        });
+
+        expect(backOffSpy.recurse).not.toHaveBeenCalled();
+      });
+
+      it('should reset backoff if target revision is newer than active revision', async() => {
+        // Active (10) < Target (15)
+        const params = {
+          resourceType: 'type', namespace: 'ns', revision: '15'
+        };
+
+        await actions.fetchPageResources.call(context, { getters, dispatch }, {
+          opt: {}, storePagination: {}, params
+        });
+
+        expect(backOffSpy.reset).toHaveBeenCalledWith('backoff-id');
+        expect(backOffSpy.recurse).toHaveBeenCalledWith(expect.objectContaining({
+          id:       'backoff-id',
+          metadata: { revision: '15' }
+        }));
+      });
+
+      it('should recurse if revisions are valid', async() => {
+        const params = {
+          resourceType: 'type', namespace: 'ns', revision: '10'
+        };
+
+        await actions.fetchPageResources.call(context, { getters, dispatch }, {
+          opt: {}, storePagination: {}, params
+        });
+
+        expect(backOffSpy.recurse).toHaveBeenCalledWith(expect.objectContaining({
+          id:       'backoff-id',
+          metadata: { revision: '10' }
+        }));
+      });
+
+      describe('recurse options', () => {
+        const params = {
+          resourceType: 'type', namespace: 'ns', revision: '10'
+        };
+        let recurseArgs: any;
+
+        beforeEach(async() => {
+          await actions.fetchPageResources.call(context, { getters, dispatch }, {
+            opt: {}, storePagination: { request: { filter: 'foo' } }, params
+          });
+          recurseArgs = backOffSpy.recurse.mock.calls[0][0];
+        });
+
+        it('canFn should return false if socket closed', () => {
+          getters.canBackoff.mockReturnValue(false);
+          expect(recurseArgs.canFn()).toBe(false);
+          expect(getters.canBackoff).toHaveBeenCalledWith(context.$socket);
+        });
+
+        it('canFn should return false if watch not started and not in REVISION_TOO_OLD error', () => {
+          getters.canBackoff.mockReturnValue(true);
+          getters.watchStarted.mockReturnValue(false);
+          getters.inError.mockReturnValue('some-other-error');
+          expect(recurseArgs.canFn()).toBe(false);
+        });
+
+        it('canFn should return true if watch started', () => {
+          getters.canBackoff.mockReturnValue(true);
+          getters.watchStarted.mockReturnValue(true);
+          expect(recurseArgs.canFn()).toBe(true);
+        });
+
+        it('canFn should return true if watch not started but in REVISION_TOO_OLD error', () => {
+          getters.canBackoff.mockReturnValue(true);
+          getters.watchStarted.mockReturnValue(false);
+          getters.inError.mockReturnValue(REVISION_TOO_OLD);
+          expect(recurseArgs.canFn()).toBe(true);
+        });
+
+        it('continueOnError should return true for UNKNOWN_REVISION error', async() => {
+          const err = { status: 400, code: STEVE_RESPONSE_CODE.UNKNOWN_REVISION };
+
+          expect(await recurseArgs.continueOnError(err)).toBe(true);
+        });
+
+        it('delayedFn should dispatch findPage', async() => {
+          await recurseArgs.delayedFn();
+          expect(dispatch).toHaveBeenCalledWith('findPage', {
+            type: 'type',
+            opt:  {
+              namespaced: 'ns',
+              revision:   '10',
+              filter:     'foo'
+            }
+          });
+        });
+      });
+    });
   });
 
   describe('getters', () => {
diff --git a/shell/plugins/steve/revision.ts b/shell/plugins/steve/revision.ts
new file mode 100644
index 00000000000..93a76e50634
--- /dev/null
+++ b/shell/plugins/steve/revision.ts
@@ -0,0 +1,26 @@
+/**
+ * Helper class to handle Steve API revisions comparisons
+ */
+export class SteveRevision {
+  public asNumber: number;
+  public isNumber: boolean;
+
+  constructor(public revision: any) {
+    this.asNumber = Number(revision);
+    this.isNumber = !Number.isNaN(this.asNumber);
+  }
+
+  /**
+   * Is this provided revision newer than this revision?
+   *
+   * @param revision
+   * @returns
+   */
+  isNewerThan(revision: SteveRevision): boolean {
+    return SteveRevision.areAllNumbers([this, revision]) && this.asNumber > revision.asNumber;
+  }
+
+  private static areAllNumbers(revisions: SteveRevision[]): boolean {
+    return revisions.every((r) => r.isNumber);
+  }
+}
diff --git a/shell/plugins/steve/subscribe.js b/shell/plugins/steve/subscribe.js
index 01d702a4c49..dfa4ae15963 100644
--- a/shell/plugins/steve/subscribe.js
+++ b/shell/plugins/steve/subscribe.js
@@ -20,40 +20,67 @@
  *
  * Below are some VERY brief steps for common flows. Some will link together
  *
- * Successfully flow - watch
+ * # Successfully flow
+ * ## watch - standard mode
  * 1. UI --> Rancher: _watch_ request
  * 2. Rancher --> UI: `resource.start`. UI sets watch as started
  * ...
  * 3. Rancher --> UI: `resource.change` (contains data). UI caches data
  *
- * Successful flow - watch - new mode
+ * ## watch - new resource.changes mode
  * 1. UI --> Rancher: _watch_ request
  * 2. Rancher --> UI: `resource.start`. UI sets watch as started
  * ...
  * 3. Rancher --> UI: `resource.changes` (contains no data). UI makes a HTTP request to fetch data
  *
- * Successful flow - unwatch
+ * ## watch - unwatch
  * 1. UI --> Rancher: _unwatch_ request
  * 2. Rancher --> UI: `resource.stop`. UI sets watch as stopped
  *
- * Successful flow - resource.stop received
+ * ## watch - resource.stop received
  * 1. Rancher --> UI: `resource.stop`. UI sets watch as stopped
  * 2. UI --> Rancher: _watch_ request
  *
- * Successful flow - socket disconnected
+ * ## watch - socket disconnected
  * 1. Socket closes|disconnects (not sure which)
  * 2. UI: reopens socket
  * 3. UI --> Rancher: _watch_ request (for every started watch)
  *
- * Error Flow
+ * # Error Flow
+ * ## resource.error
  * 1. UI --> Rancher: _watch_ request
  * 2. Rancher --> UI: `resource.start`. UI sets watch as started
  * 3. Rancher --> UI: `resource.error`. UI sets watch as errored.
  *   a) UI: in the event of 'too old' the UI will make a http request to fetch a new revision and re-watch with it. This process is delayed on each call
  * 4. Rancher --> UI: `resource.stop`. UI sets watch as stop (note the resource.stop flow above is avoided given error state)
  *
+ * # HA Support for Stale Replicates - https://github.com/rancher/dashboard/issues/14974
+ *
+ * ## Scenario 1 - handle case where watch request is handled by a stale replica
+ * 1. UI --> Rancher: _watch_ request (contains latest revision)
+ * 2. Rancher --> UI: `resource.error` (stale replica does not know new revision)
+ * 3. Rancher --> UI: `resource.stop` (stale replica cannot provide updates for unknown revision)
+ * 4. UI --> Rancher : UI makes a HTTP request to fetch data
+ * 5. Loop back to step 1 (if stale again, backoff retry)
+ *
+ * ## Scenario 2 - handle case where http request is handled by a stale replica (don't fetch stale data)
+ * 1. UI --> Rancher: _watch_ request
+ * 2. Rancher --> UI: `resource.start`. UI sets watch as started
+ * ...
+ * 3. Rancher --> UI: `resource.changes` (sent by good replica containing good revision)
+ * 4. UI --> Rancher : UI makes a HTTP request to fetch data. Stale Replica handles request, does not know revision, returns error
+ * 5. Loop back to step 4 (if errors with stale again, backoff retry)
+ *
+ * ## Scenario 3 - handle case where update request was sent by stale replica (don't overwrite good data with stale)
+ * 1. UI --> Rancher: _watch_ request
+ * 2. Rancher --> UI: `resource.start`. UI sets watch as started
+ * ...
+ * 3. Rancher --> UI: `resource.changes` (sent by stale replica containing stale revision)
+ * 4. UI compares stale revision with newer store revision
+ * 5. UI does not make new http request, which could be handled by stale replica --> overwrites newer local values
+ *
  * Additionally
- * - if we receive resource.stop, unless the watch is in error, we immediately send back a watch event
+ * - if we receive resource.stop, unless the watch is in error, we immediately send back a watch request to re-start the watch
  * - if the web socket is disconnected (for steve based sockets it happens every 30 mins, or when there are permission changes)
  *   the ui will re-connect it and re-watch all previous watches using a best effort revision
  */
@@ -68,7 +95,6 @@ import Socket, {
   EVENT_CONNECTED,
   EVENT_DISCONNECTED,
   EVENT_MESSAGE,
-  //  EVENT_FRAME_TIMEOUT,
   EVENT_CONNECT_ERROR,
   EVENT_DISCONNECT_ERROR,
   NO_WATCH,
@@ -90,6 +116,8 @@ import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_MODE } from '@shell/types/store/su
 import paginationUtils from '@shell/utils/pagination-utils';
 import backOff from '@shell/utils/back-off';
 import { SteveWatchEventListenerManager } from '@shell/plugins/subscribe-events';
+import { SteveRevision } from '@shell/plugins/steve/revision';
+import { STEVE_RESPONSE_CODE } from '@shell/types/rancher/steve.api';
 
 // minimum length of time a disconnect notification is shown
 const MINIMUM_TIME_NOTIFIED = 3000;
@@ -683,7 +711,7 @@ const sharedActions = {
   /**
    * Ensure there's no back-off process waiting to run for
    * - resource.changes fetchResources
-   * - resource.error resyncWatches
+   * - resource.error resyncWatch
    */
   resetWatchBackOff({ state, getters, commit }, {
     type, compareWatches, resetInError = true, resetStarted = true
@@ -820,17 +848,117 @@ const defaultActions = {
   async resyncWatch({ getters, dispatch }, params) {
     console.info(`Resync [${ getters.storeName }]`, params); // eslint-disable-line no-console
 
+    const { backOffId, ...others } = params;
+
     await dispatch('fetchResources', {
-      ...params,
-      opt: { force: true, forceWatch: true }
+      params: others,
+      backOffId,
+      opt:    { force: true, forceWatch: true }
     });
   },
 
+  /**
+   * Helper function used by fetchResources
+   *
+   * Integrates the concept of 'back-off' to reduce spam, overwrite stale old requests, etc
+   */
+  async fetchPageResources({ getters, dispatch }, {
+    opt, storePagination, params, backOffId
+  }) {
+    const { resourceType, namespace, revision } = params;
+    const type = resourceType || params.type;
+
+    const safeBackOffId = backOffId || getters.backOffId(params, `fetchPageResources`);
+
+    const activeRevisionSt = backOff.getBackOff(safeBackOffId)?.metadata?.revision;
+    const cachedRevisionSt = getters['typeEntry'](resourceType || type)?.revision;
+
+    const targetRevision = new SteveRevision(revision);
+    const activeRevision = new SteveRevision(activeRevisionSt);
+    const cachedRevision = new SteveRevision(cachedRevisionSt);
+    const currentRevision = new SteveRevision(activeRevisionSt || cachedRevisionSt);
+
+    // Three cases to support HA scenarios 2 + 3
+    // 1. current version is newer than target revision - abort/ignore (don't overwrite new with old)
+    // 2. current version is older than target revision - reset previous (drop older requests with older revision, use new revision)
+    // 3. current version is same as target revision - we're retrying
+
+    // There are two places we do this to cover the two cases we make http request following socket changes
+    // shell/utils/pagination-wrapper.ts - request
+    // shell/plugins/steve/subscribe.js - fetchPageResources
+
+    if (currentRevision.isNewerThan(targetRevision)) {
+      // Case 1 - abort/ignore (don't overwrite new with old)
+
+      // eslint-disable-next-line no-console
+      console.warn(`Ignoring subscribe request to update '${ type }' with revision '${ targetRevision.revision }' (active revision '${ currentRevision.revision } & cached revision '${ cachedRevision.revision }''). ` +
+              `This probably means the replica that provided the web socket message has not yet correctly synced it's cache with other fresher replicas.`);
+
+      return;
+    }
+
+    if (targetRevision.isNewerThan(activeRevision)) {
+      // Case 2 - reset previous (drop older requests with older revision, use new revision)
+
+      console.info(`Dropping previous subscribe request to update '${ type }' with revision '${ currentRevision.revision }' (new target revision '${ targetRevision.revision }'). `); // eslint-disable-line no-console
+
+      backOff.reset(safeBackOffId);
+    }
+
+    try {
+      // Keep making requests until we make one that succeeds, fails with unknown revision or we run out of retries
+      await backOff.recurse({
+        id:          safeBackOffId,
+        metadata:    { revision },
+        description: `Fetching resources for ${ type }. Triggered by web socket`,
+        canFn:       () => {
+          if (!getters.canBackoff(this.$socket)) {
+            console.info(`Aborting subscribe request to update '${ type }' with revision '${ currentRevision.revision }' (socket closed). `); // eslint-disable-line no-console
+
+            return false;
+          }
+
+          if (!getters['watchStarted'](params)) {
+            // No watch has started... but are we in initial state where the watch failed due to a bad revision?
+            const inError = getters.inError(params);
+
+            if (inError !== REVISION_TOO_OLD) {
+              console.info(`Aborting subscribe request to update '${ type }' with revision '${ currentRevision.revision }' (resource not watched). `); // eslint-disable-line no-console
+
+              return false;
+            }
+          }
+
+          return true;
+        },
+        continueOnError: async(err) => {
+          // Have we made a request to a stale replica that does not know about the required revision? If so continue to try until we hit a ripe replica
+          return err?.status === 400 && err?.code === STEVE_RESPONSE_CODE.UNKNOWN_REVISION;
+        },
+        delayedFn: async() => {
+          return await dispatch('findPage', {
+            type,
+            opt: {
+              ...opt,
+              namespaced: namespace,
+              revision,
+              // This brings in page, page size, filter, etc
+              ...storePagination.request,
+            }
+          });
+        },
+      });
+    } catch (err) {
+      // Nothing depends on the error higher in the call stack, so prevent dev full screen errors by catching it
+      console.info(`Failed subscribe request to update '${ type }' with revision '${ currentRevision.revision }' (error). `, err); // eslint-disable-line no-console
+    }
+  },
+
   async fetchResources({
     state, getters, dispatch, commit
-  }, { opt, ...params }) {
+  }, { opt, params, backOffId }) {
     const {
-      resourceType, namespace, id, selector, mode
+      resourceType, namespace, id, selector, mode, revision
     } = params;
 
     if (!resourceType) {
@@ -840,6 +968,7 @@ const defaultActions = {
     }
 
     if ( id ) {
+      // Fetch an individual resource
       await dispatch('find', {
         type: resourceType,
         id,
@@ -857,6 +986,7 @@ const defaultActions = {
     let have = []; let want = [];
 
     if ( selector ) {
+      // Fetch a selection of resources
       have = getters['matching'](resourceType, selector).slice();
       want = await dispatch('findMatching', {
         type: resourceType,
@@ -864,39 +994,40 @@ const defaultActions = {
         opt,
       });
     } else {
+      // Fetch all or a page of resources
       if (mode === STEVE_WATCH_MODE.RESOURCE_CHANGES) {
+        // Fetch a page of resources
+
         // Other findX use options (id/ns/selector) from the messages received over socket.
-        // However paginated requests have more complex params so grab them from store from the store.
+        // However paginated requests have more complex params so grab them from the store.
+
         // of type @StorePagination
         const storePagination = getters['havePage'](resourceType);
 
         if (!!storePagination) {
-          have = []; // findPage removes stale entries, so we don't need to rely on below process to remove them
-
-          // This could have been kicked off given a resource.changes message
-          // If the messages come in quicker than findPage completes (resource.changes debounce time >= http request time),
-          // and the request is the same, only the first request will be processed. all others until it finishes will be ignored
-          // (see deferred process - `waiting.push(later);` - in request action).
-          // If this becomes an issue we need to debounce and work around the deferred issue within request
-          want = await dispatch('findPage', {
-            type: resourceType,
-            opt:  {
-              ...opt,
-              namespaced: namespace,
-              // This brings in page, page size, filter, etc
-              ...storePagination.request
-            }
+          await dispatch('fetchPageResources', {
+            params,
+            storePagination,
+            opt,
+            backOffId
           });
+
+          // findPage removes stale entries, so we don't need to rely on below process to remove them
+          have = [];
+          want = [];
         }
+
         // Should any listeners be notified of this request for them to kick off their own event handling?
         getters.listenerManager.triggerEventListener({
           event:  STEVE_WATCH_MODE.RESOURCE_CHANGES,
           params: {
             ...params,
-            forceWatch: opt.forceWatch
+            revision,
+            forceWatch: opt.forceWatch,
           }
         });
       } else {
+        // Fetch all of a resource
         have = getters['all'](resourceType).slice();
 
         if ( namespace ) {
@@ -1110,7 +1241,7 @@ const defaultActions = {
       // 2) will be cleared when resyncWatch --> watch (with force) --> resource.start completes
       commit('setInError', { msg, reason: REVISION_TOO_OLD });
 
-      // See Scenario 1 from https://github.com/rancher/dashboard/issues/14974
+      // HA scenario 1 - handle case where stale replica processes watch request
       // The watch that results from resyncWatch will fail and end up here if the revision isn't (yet) known
       // So re-retry resyncWatch until it does OR
       // - we're already re-retrying
@@ -1120,11 +1251,17 @@ const defaultActions = {
       // - we need to stop (socket is disconnected or closed, type is 'forgotten', watch is unwatched)
       //   - `reset` called asynchronously
       //   - Note - we won't need to clear the id outside of the above scenarios because `too old` only occurs on fresh watches (covered by above scenarios)
+
+      const backOffId = getters.backOffId(msg, REVISION_TOO_OLD);
+
       backOff.execute({
-        id:          getters.backOffId(msg, REVISION_TOO_OLD),
+        id:          backOffId,
         description: `Invalid watch revision, re-syncing`,
         canFn:       () => getters.canBackoff(this.$socket),
-        delayedFn:   () => dispatch('resyncWatch', msg),
+        delayedFn:   () => dispatch('resyncWatch', {
+          ...msg,
+          backOffId: undefined,
+        }),
       });
     } else if ( err.includes('the server does not allow this method on the requested resource')) {
       commit('setInError', { msg, reason: NO_PERMS });
@@ -1268,10 +1405,10 @@ const defaultActions = {
     }
   },
 
-  'ws.resource.changes'({ dispatch }, msg) {
-    dispatch('fetchResources', {
-      ...msg,
-      opt: { force: true, load: _MERGE }
+  async 'ws.resource.changes'({ dispatch }, msg) {
+    await dispatch('fetchResources', {
+      params: msg,
+      opt:    { force: true, load: _MERGE }
     } );
   },
 
@@ -1413,7 +1550,7 @@ const defaultGetters = {
    * @param postFix - something else to uniquely id this back-off
    */
   backOffId: () => (obj, postFix) => {
-    return `${ keyForSubscribe(obj) }${ postFix ? `:${ postFix }` : '' }`;
+    return `${ keyForSubscribe(obj) }${ postFix ? `:detail=${ postFix }` : '' }`;
   },
 
   /**
@@ -1454,15 +1591,15 @@ const defaultGetters = {
    */
   nextResourceVersion: (state, getters) => (type, id) => {
     type = normalizeType(type);
-    let revision = 0;
+    let nextRevision = 0;
 
     if ( id ) {
       const existing = getters['byId'](type, id);
 
-      revision = existing?.metadata?.resourceVersion;
+      nextRevision = existing?.metadata?.resourceVersion;
     }
 
-    if ( !revision ) {
+    if ( !nextRevision ) {
       const cache = state.types[type];
 
       // No Cache, nothing to compare to, return early
@@ -1470,27 +1607,29 @@ const defaultGetters = {
         return null;
       }
 
-      revision = Number(cache.revision);
+      const cacheRevision = new SteveRevision(cache.revision);
 
       // Cached LIST revision isn't a number, cannot compare to, return early
-      if (Number.isNaN(revision)) {
+      if (!cacheRevision.isNumber) {
         return cache.revision || null;
       }
 
+      nextRevision = cacheRevision;
+
       for ( const obj of cache.list || [] ) {
         if ( obj && obj.metadata ) {
-          const neu = Number(obj.metadata.resourceVersion);
+          const candidateRevision = new SteveRevision(obj.metadata.resourceVersion);
 
-          if (Number.isNaN(neu)) {
-            continue;
+          if (candidateRevision.isNewerThan(nextRevision)) {
+            nextRevision = candidateRevision;
           }
-
-          revision = Math.max(revision, neu);
         }
       }
+
+      nextRevision = nextRevision.asNumber;
     }
 
-    return revision || null;
+    return nextRevision || null;
   },
 
   /**
diff --git a/shell/plugins/subscribe-events.ts b/shell/plugins/subscribe-events.ts
index b36fca8e815..50010fe7323 100644
--- a/shell/plugins/subscribe-events.ts
+++ b/shell/plugins/subscribe-events.ts
@@ -167,7 +167,7 @@ export class SteveWatchEventListenerManager {
 
     if (eventWatcher) {
       Object.values(eventWatcher.callbacks).forEach((cb) => {
-        cb({ forceWatch: params.forceWatch }); // eslint-disable-line node/no-callback-literal
+        cb({ forceWatch: params.forceWatch, revision: params.revision }); // eslint-disable-line node/no-callback-literal
       });
     }
   }
@@ -177,7 +177,7 @@ export class SteveWatchEventListenerManager {
 
     watch.listeners.forEach((l) => {
       Object.values(l.callbacks || {}).forEach((cb) => {
-        cb({ forceWatch: params.forceWatch });// eslint-disable-line node/no-callback-literal
+        cb({ forceWatch: params.forceWatch, revision: params.revision });// eslint-disable-line node/no-callback-literal
       });
     });
   }
diff --git a/shell/types/kube/kube-api.ts b/shell/types/kube/kube-api.ts
index 57fdd6b5571..7a29a80df5f 100644
--- a/shell/types/kube/kube-api.ts
+++ b/shell/types/kube/kube-api.ts
@@ -25,11 +25,37 @@ export interface KubeLabelSelector {
  * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.31/#objectmeta-v1-meta
  */
 export interface KubeMetadata {
+  namespace?: string,
+  name: string
+
   labels?: { [key: string]: string },
   annotations?: { [key: string]: string },
 }
 
-export interface RancherKubeMetadata extends KubeMetadata {
-  namespace?: string,
-  name: string
+/**
+ * Kube API JSON response for LIST requests
+ */
+export interface KubeListResponse<T = any> {
+  kind: string,
+  apiVersion: string,
+
+  items: T[],
+
+  // Bucket for everything else (hopefully to remove once above populated)
+  [key: string]: any
+}
+
+/**
+ * Kube API JSON response for GET requests
+ */
+export interface KubeGetResponse {
+  kind: string,
+  apiVersion: string,
+
+  metadata: KubeMetadata,
+  spec: any,
+  status: any,
+
+  // Bucket for everything else (hopefully to remove once above populated)
+  [key: string]: any
 }
diff --git a/shell/types/rancher/steve.api.ts b/shell/types/rancher/steve.api.ts
new file mode 100644
index 00000000000..ecb0e68b0be
--- /dev/null
+++ b/shell/types/rancher/steve.api.ts
@@ -0,0 +1,40 @@
+import { KubeGetResponse, KubeMetadata } from '@shell/types/kube/kube-api';
+
+/**
+ * Collection of string based values used by the Steve API response's `code` field
+ */
+export const STEVE_RESPONSE_CODE = {
+  /**
+   * When the query param `revision` is sent and it's not in the vai cache then return this error
+   */
+  UNKNOWN_REVISION: 'unknown revision'
+};
+
+/**
+ * Steve API JSON response for LIST requests
+ */
+export interface SteveListResponse<T = any> {
+  actions: any,
+  count: number,
+  data: T[],
+  links: any,
+  resourceType: string,
+  revision: string,
+  type: string,
+
+  // Bucket for everything else (hopefully to remove once above populated)
+  [key: string]: any
+}
+
+/**
+ * Steve API JSON response for GET requests
+ */
+export interface SteveGetResponse extends KubeGetResponse {
+  // Rancher specific properties (there are more)
+  id: string,
+
+  // Bucket for everything else (hopefully to remove once above populated)
+  [key: string]: any
+}
+
+export type RancherKubeMetadata = KubeMetadata
diff --git a/shell/types/store/pagination.types.ts b/shell/types/store/pagination.types.ts
index 07b2bb264c8..107b06e5fde 100644
--- a/shell/types/store/pagination.types.ts
+++ b/shell/types/store/pagination.types.ts
@@ -599,6 +599,7 @@ export interface StorePaginationResult {
    * The last time the resource was updated. Used to assist list watching for changes
    */
   timestamp: number,
+  revision: string,
 }
 
 export interface StorePaginationRequest {
diff --git a/shell/types/store/subscribe-events.types.ts b/shell/types/store/subscribe-events.types.ts
index b5fa0c21f36..b8add76a5e3 100644
--- a/shell/types/store/subscribe-events.types.ts
+++ b/shell/types/store/subscribe-events.types.ts
@@ -17,6 +17,7 @@ export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
  */
 export type STEVE_WATCH_EVENT_LISTENER_CALLBACK_PARAMS = {
   forceWatch?: boolean,
+  revision?: string,
 }
 
 /**
diff --git a/shell/utils/__tests__/back-off.test.ts b/shell/utils/__tests__/back-off.test.ts
index 02e305b09f8..17ad01ac77b 100644
--- a/shell/utils/__tests__/back-off.test.ts
+++ b/shell/utils/__tests__/back-off.test.ts
@@ -1,5 +1,3 @@
-// Import the BackOff instance from your code.
-// Assuming the file is named `backoff.ts` and the default export is the BackOff instance.
 import backOff from '../back-off';
 
 describe('backOff', () => {
@@ -10,345 +8,466 @@ describe('backOff', () => {
   let consoleLogMock: jest.SpyInstance;
   let consoleErrorMock: jest.SpyInstance;
 
-  beforeEach(() => {
+  const beforeEachFn = () => {
     // Before each test, reset the BackOff state.
     backOff.resetAll();
 
     // Create new mocks for each test to ensure a clean slate.
     consoleLogMock = jest.spyOn(console, 'log').mockImplementation(() => {});
     consoleErrorMock = jest.spyOn(console, 'error').mockImplementation(() => {});
-  });
+  };
 
-  afterEach(() => {
+  const afterEachFn = () => {
     // Restore the original console functions after each test.
     consoleLogMock.mockRestore();
     consoleErrorMock.mockRestore();
-  });
+  };
+
+  describe('execute', () => {
+    beforeEach(beforeEachFn);
+
+    afterEach(afterEachFn);
 
-  // --- Test Suite for `execute` method ---
+    it('should execute the function immediately the first time without a delay', async() => {
+      const delayedFn = jest.fn();
 
-  it('should execute the function immediately the first time without a delay', async() => {
-    const delayedFn = jest.fn();
+      // Call the function for the first time.
+      await backOff.execute({
+        id: 'test1', description: 'Test 1', delayedFn
+      });
 
-    // Call the function for the first time.
-    await backOff.execute({
-      id: 'test1', description: 'Test 1', delayedFn
+      // The function should have been called immediately, since the fake timer hasn't advanced.
+      expect(delayedFn).toHaveBeenCalledTimes(0);
+      expect(backOff.getBackOff('test1')).toBeDefined();
     });
 
-    // The function should have been called immediately, since the fake timer hasn't advanced.
-    expect(delayedFn).toHaveBeenCalledTimes(0);
-    expect(backOff.getBackOff('test1')).toBeDefined();
-  });
+    it('should back off and delay the second execution', async() => {
+      const delayedFn = jest.fn();
+      const id = 'backoff-test';
 
-  it('should back off and delay the second execution', async() => {
-    const delayedFn = jest.fn();
-    const id = 'backoff-test';
+      // First call, which should run immediately.
+      await backOff.execute({
+        id, description: 'Backoff Test', delayedFn,
+      });
 
-    // First call, which should run immediately.
-    await backOff.execute({
-      id, description: 'Backoff Test', delayedFn,
-    });
+      jest.advanceTimersByTime(1);
+
+      // Expect the first call to be immediate.
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-    jest.advanceTimersByTime(1);
+      // Call it a second time. This should initiate a backoff delay.
+      await backOff.execute({
+        id, description: 'Backoff Test', delayedFn
+      });
 
-    // Expect the first call to be immediate.
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // The function should not have been called a second time yet.
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-    // Call it a second time. This should initiate a backoff delay.
-    await backOff.execute({
-      id, description: 'Backoff Test', delayedFn
+      // Advance the timer by less than the first backoff delay (250ms).
+      jest.advanceTimersByTime(200);
+      expect(delayedFn).toHaveBeenCalledTimes(1);
+
+      // Now, advance the timer by the required delay to trigger the second call.
+      jest.advanceTimersByTime(50);
+
+      // The function should have been called a second time.
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
+
+      // Verify the backoff entry was created correctly.
+      const backOffEntry = backOff.getBackOff(id);
+
+      expect(backOffEntry.try).toBe(2);
     });
 
-    // The function should not have been called a second time yet.
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+    it('should implement exponential backoff on subsequent calls', async() => {
+      const delayedFn = jest.fn();
+      const id = 'exp-backoff';
+
+      // First call (immediate)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn
+      });
+
+      jest.advanceTimersByTime(1);
+      expect(delayedFn).toHaveBeenCalledTimes(1);
+
+      // Second call (should have a delay of 1^2 * 250 = 250ms)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn
+      });
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
+
+      // Third call (should have a delay of 2^2 * 250 = 1000ms)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn
+      });
+      jest.advanceTimersByTime(1000);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(3);
+
+      // Fourth call (should have a delay of 3^2 * 250 = 2250ms)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn
+      });
+      jest.advanceTimersByTime(2250);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(4);
+    });
 
-    // Advance the timer by less than the first backoff delay (250ms).
-    jest.advanceTimersByTime(200);
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+    it('should skip execution if a previous backoff process is already running', async() => {
+      const delayedFn = jest.fn();
+      const id = 'skip-test';
 
-    // Now, advance the timer by the required delay to trigger the second call.
-    jest.advanceTimersByTime(50);
+      await backOff.execute({
+        id, description: 'Skip Test', delayedFn
+      });
+      expect(delayedFn).toHaveBeenCalledTimes(0);
 
-    // The function should have been called a second time.
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // Second call, will be ignored
+      await backOff.execute({
+        id, description: 'Skip Test', delayedFn
+      });
 
-    // Verify the backoff entry was created correctly.
-    const backOffEntry = backOff.getBackOff(id);
+      expect(delayedFn).toHaveBeenCalledTimes(0);
 
-    expect(backOffEntry.try).toBe(2);
-  });
+      // We should only have 1 call so far.
+      jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-  it('should implement exponential backoff on subsequent calls', async() => {
-    const delayedFn = jest.fn();
-    const id = 'exp-backoff';
+      // A third call while the first is still pending.
+      // This call should be ignored and the delayedFn should not be executed.
+      await backOff.execute({
+        id, description: 'Skip Test', delayedFn
+      });
 
-    // First call (immediate)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
-    });
+      expect(delayedFn).toHaveBeenCalledTimes(1);
 
-    jest.advanceTimersByTime(1);
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      jest.advanceTimersByTime(300);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
 
-    // Second call (should have a delay of 1^2 * 250 = 250ms)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
+      // Advance timers to complete the pending second call.
+      jest.advanceTimersByTime(1000);
+      await Promise.resolve();
+      // Now there should be 2 calls, not 3.
+      expect(delayedFn).toHaveBeenCalledTimes(2);
     });
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
 
-    // Third call (should have a delay of 2^2 * 250 = 1000ms)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
+    it('should not execute if the number of retries is exceeded', async() => {
+      const delayedFn = jest.fn();
+      const id = 'retries-test';
+
+      // Set retries to 2.
+      const retries = 2;
+
+      // Call 1 (immediate)
+      await backOff.execute({
+        id, description: 'Retries Test', retries, delayedFn
+      });
+      jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(1);
+
+      // Call 2 (after 250ms delay)
+      await backOff.execute({
+        id, description: 'Retries Test', retries, delayedFn
+      });
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
+
+      // Call 3 (should be ignored because it exceeds the `retries` limit of 2)
+      await backOff.execute({
+        id, description: 'Retries Test', retries, delayedFn
+      });
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+
+      expect(delayedFn).toHaveBeenCalledTimes(2);
     });
-    jest.advanceTimersByTime(1000);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(3);
 
-    // Fourth call (should have a delay of 3^2 * 250 = 2250ms)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn
-    });
-    jest.advanceTimersByTime(2250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(4);
-  });
+    it('should skip execution if `canFn` returns false', async() => {
+      const delayedFn = jest.fn();
+      const canFn = jest.fn().mockResolvedValue(false);
 
-  it('should skip execution if a previous backoff process is already running', async() => {
-    const delayedFn = jest.fn();
-    const id = 'skip-test';
+      await backOff.execute({
+        id: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+      });
 
-    await backOff.execute({
-      id, description: 'Skip Test', delayedFn
-    });
-    expect(delayedFn).toHaveBeenCalledTimes(0);
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
 
-    // Second call, will be ignored
-    await backOff.execute({
-      id, description: 'Skip Test', delayedFn
+      expect(delayedFn).not.toHaveBeenCalled();
     });
 
-    expect(delayedFn).toHaveBeenCalledTimes(0);
+    it('should not clear backoff entry if the delayedFn throws an error', async() => {
+      const id = 'error-test';
+      const delayedFn = jest.fn().mockRejectedValue(new Error('Test Error'));
 
-    // We should only have 1 call so far.
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // Call the function for the first time.
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn
+      });
 
-    // A third call while the first is still pending.
-    // This call should be ignored and the delayedFn should not be executed.
-    await backOff.execute({
-      id, description: 'Skip Test', delayedFn
-    });
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeDefined();
 
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // Wait for the immediate call to finish.
+      jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
 
-    jest.advanceTimersByTime(300);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // The entry should be removed after success/failure.
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeUndefined();
 
-    // Advance timers to complete the pending second call.
-    jest.advanceTimersByTime(1000);
-    await Promise.resolve();
-    // Now there should be 2 calls, not 3.
-    expect(delayedFn).toHaveBeenCalledTimes(2);
-  });
+      // Call again to trigger a backoff delay and an error.
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn
+      });
 
-  it('should not execute if the number of retries is exceeded', async() => {
-    const delayedFn = jest.fn();
-    const id = 'retries-test';
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeDefined();
 
-    // Set retries to 2.
-    const retries = 2;
+      // Advance timers to trigger the delayed function.
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
 
-    // Call 1 (immediate)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
-    });
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
+      // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
+      expect(backOff.getBackOff(id).execute?.timeoutId).toBeUndefined();
 
-    // Call 2 (after 250ms delay)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
-    });
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(2);
+      // Check if the next call will still back off.
+      const newDelayedFn = jest.fn();
 
-    // Call 3 (should be ignored because it exceeds the `retries` limit of 2)
-    await backOff.execute({
-      id, description: 'Retries Test', retries, delayedFn
+      await backOff.execute({
+        id, description: 'Error Test', delayedFn: newDelayedFn
+      });
+      expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
     });
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
 
-    expect(delayedFn).toHaveBeenCalledTimes(2);
-  });
+    it('should save metadata', async() => {
+      const delayedFn = jest.fn();
+      const id = 'exp-backoff';
+      const metadata = { a: true };
 
-  it('should skip execution if `canFn` returns false', async() => {
-    const delayedFn = jest.fn();
-    const canFn = jest.fn().mockResolvedValue(false);
+      // First call (immediate)
+      await backOff.execute({
+        id, description: 'Exponential Backoff Test', delayedFn, metadata
+      });
 
-    await backOff.execute({
-      id: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+      expect(backOff.getBackOff(id)).toBeDefined();
+      expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
     });
+  });
 
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
+  describe('reset', () => {
+    beforeEach(beforeEachFn);
 
-    expect(delayedFn).not.toHaveBeenCalled();
-  });
+    afterEach(afterEachFn);
 
-  it('should not clear backoff entry if the delayedFn throws an error', async() => {
-    const id = 'error-test';
-    const delayedFn = jest.fn().mockRejectedValue(new Error('Test Error'));
+    it('should reset a specific backoff process', async() => {
+      const delayedFn = jest.fn();
+      const id = 'reset-test';
 
-    // Call the function for the first time.
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn
-    });
+      // Start a backoff process.
+      await backOff.execute({
+        id, description: 'Reset Test', delayedFn
+      });
+
+      expect(backOff.getBackOff(id)).toBeDefined();
 
-    // Wait for the immediate call to finish.
-    jest.advanceTimersByTime(1);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
+      // Reset the process.
+      backOff.reset(id);
 
-    // The entry should be removed after success/failure.
-    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+      // The entry should be deleted from the map.
+      expect(backOff.getBackOff(id)).toBeUndefined();
 
-    // Call again to trigger a backoff delay and an error.
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn
+      // Now, a new execution should not be delayed.
+      await backOff.execute({
+        id, description: 'Reset Test', delayedFn
+      });
+
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+      expect(delayedFn).toHaveBeenCalledTimes(1);
     });
 
-    // Advance timers to trigger the delayed function.
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
+    it('should reset all backoff processes', async() => {
+      const delayedFn1 = jest.fn();
+      const delayedFn2 = jest.fn();
 
-    // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
-    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+      await backOff.execute({
+        id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+      });
+      await backOff.execute({
+        id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+      });
 
-    // Check if the next call will still back off.
-    const newDelayedFn = jest.fn();
+      await backOff.execute({
+        id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      });
+      await backOff.execute({
+        id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      });
 
-    await backOff.execute({
-      id, description: 'Error Test', delayedFn: newDelayedFn
-    });
-    expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
-  });
+      expect(backOff.getBackOff('all-1')).toBeDefined();
+      expect(backOff.getBackOff('all-2')).toBeDefined();
 
-  it('should save metadata', async() => {
-    const delayedFn = jest.fn();
-    const id = 'exp-backoff';
-    const metadata = { a: true };
+      // Reset all processes.
+      backOff.resetAll();
 
-    // First call (immediate)
-    await backOff.execute({
-      id, description: 'Exponential Backoff Test', delayedFn, metadata
+      expect(backOff.getBackOff('all-1')).toBeUndefined();
+      expect(backOff.getBackOff('all-2')).toBeUndefined();
     });
 
-    expect(backOff.getBackOff(id)).toBeDefined();
-    expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
+    it('should reset only processes with a specific prefix', async() => {
+      const delayedFn = jest.fn();
+
+      await backOff.execute({
+        id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+      });
+      await backOff.execute({
+        id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+      });
+
+      await backOff.execute({
+        id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+      });
+      await backOff.execute({
+        id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+      });
+
+      await backOff.execute({
+        id: 'other-test-1', description: 'Other Test 1', delayedFn
+      });
+      await backOff.execute({
+        id: 'other-test-1', description: 'Other Test 1', delayedFn
+      });
+
+      expect(backOff.getBackOff('prefix-test-1')).toBeDefined();
+      expect(backOff.getBackOff('prefix-test-2')).toBeDefined();
+      expect(backOff.getBackOff('other-test-1')).toBeDefined();
+
+      // Reset only the "prefix-test" processes.
+      backOff.resetPrefix('prefix-test');
+
+      expect(backOff.getBackOff('prefix-test-1')).toBeUndefined();
+      expect(backOff.getBackOff('prefix-test-2')).toBeUndefined();
+      // The other process should still exist.
+      expect(backOff.getBackOff('other-test-1')).toBeDefined();
+    });
   });
 
-  // --- Test Suite for Reset methods ---
+  describe('recurse', () => {
+    beforeEach(beforeEachFn);
 
-  it('should reset a specific backoff process', async() => {
-    const delayedFn = jest.fn();
-    const id = 'reset-test';
+    afterEach(afterEachFn);
 
-    // Start a backoff process.
-    await backOff.execute({
-      id, description: 'Reset Test', delayedFn
-    });
+    const handlePromises = async() => {
+      for (let i = 0; i < 10; i++) {
+        await Promise.resolve();
+      }
+    };
 
-    expect(backOff.getBackOff(id)).toBeDefined();
+    const iterationLoop = async(wait: number) => {
+      await handlePromises();
 
-    // Reset the process.
-    backOff.reset(id);
+      jest.advanceTimersByTime(wait);
 
-    // The entry should be deleted from the map.
-    expect(backOff.getBackOff(id)).toBeUndefined();
+      await handlePromises();
+    };
 
-    // Now, a new execution should not be delayed.
-    await backOff.execute({
-      id, description: 'Reset Test', delayedFn
-    });
+    it('should execute the function immediately', async() => {
+      const delayedFn = jest.fn().mockResolvedValue('success');
+      const id = 'recurse-test';
 
-    jest.advanceTimersByTime(250);
-    await Promise.resolve();
-    expect(delayedFn).toHaveBeenCalledTimes(1);
-  });
+      const promise = backOff.recurse({
+        id, description: 'Recurse Test', delayedFn, continueOnError: async() => false
+      });
 
-  it('should reset all backoff processes', async() => {
-    const delayedFn1 = jest.fn();
-    const delayedFn2 = jest.fn();
+      await iterationLoop(1);
 
-    await backOff.execute({
-      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
-    });
-    await backOff.execute({
-      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
-    });
+      const result = await promise;
 
-    await backOff.execute({
-      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
-    });
-    await backOff.execute({
-      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+      expect(delayedFn).toHaveBeenCalledTimes(1);
+      expect(result).toBe('success');
     });
 
-    expect(backOff.getBackOff('all-1')).toBeDefined();
-    expect(backOff.getBackOff('all-2')).toBeDefined();
+    it('should retry on failure if continueOnError returns true', async() => {
+      const delayedFn = jest.fn()
+        .mockRejectedValueOnce(new Error('Fail 1'))
+        .mockResolvedValue('success');
+      const id = 'recurse-retry';
+      const continueOnError = jest.fn().mockResolvedValue(true);
 
-    // Reset all processes.
-    backOff.resetAll();
+      const promise = backOff.recurse({
+        id, description: 'Recurse Retry', delayedFn, continueOnError
+      });
 
-    expect(backOff.getBackOff('all-1')).toBeUndefined();
-    expect(backOff.getBackOff('all-2')).toBeUndefined();
-  });
+      // First attempt (i=0)
+      await iterationLoop(1);
 
-  it('should reset only processes with a specific prefix', async() => {
-    const delayedFn = jest.fn();
+      // Second attempt (i=1), delay 250ms
+      await iterationLoop(250);
 
-    await backOff.execute({
-      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
-    });
-    await backOff.execute({
-      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
-    });
+      const result = await promise;
 
-    await backOff.execute({
-      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
-    });
-    await backOff.execute({
-      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+      expect(delayedFn).toHaveBeenCalledTimes(2);
+      expect(result).toBe('success');
     });
 
-    await backOff.execute({
-      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    it('should stop retrying if continueOnError returns false', async() => {
+      const delayedFn = jest.fn().mockRejectedValue(new Error('Fail'));
+      const id = 'recurse-stop';
+      const continueOnError = jest.fn().mockResolvedValue(false);
+
+      const promise = backOff.recurse({
+        id, description: 'Recurse Stop', delayedFn, continueOnError
+      });
+
+      await iterationLoop(1);
+
+      await expect(promise).rejects.toThrow('Failed call');
+      expect(delayedFn).toHaveBeenCalledTimes(1);
     });
-    await backOff.execute({
-      id: 'other-test-1', description: 'Other Test 1', delayedFn
+
+    it('should stop retrying if max retries reached', async() => {
+      const delayedFn = jest.fn().mockRejectedValue(new Error('Fail'));
+      const id = 'recurse-max';
+      const continueOnError = jest.fn().mockResolvedValue(true);
+      const retries = 2;
+
+      const promise = backOff.recurse({
+        id, description: 'Recurse Max', delayedFn, continueOnError, retries
+      });
+
+      // Try 1
+      await iterationLoop(1);
+
+      // Try 2
+      await iterationLoop(250);
+
+      const result = await promise;
+
+      expect(result).toBeUndefined();
+      expect(delayedFn).toHaveBeenCalledTimes(2);
     });
 
-    expect(backOff.getBackOff('prefix-test-1')).toBeDefined();
-    expect(backOff.getBackOff('prefix-test-2')).toBeDefined();
-    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+    it('should skip if canFn returns false', async() => {
+      const delayedFn = jest.fn();
+      const id = 'recurse-canfn';
+      const canFn = jest.fn().mockResolvedValue(false);
 
-    // Reset only the "prefix-test" processes.
-    backOff.resetPrefix('prefix-test');
+      const promise = backOff.recurse({
+        id, description: 'Recurse CanFn', delayedFn, continueOnError: async() => false, canFn
+      });
 
-    expect(backOff.getBackOff('prefix-test-1')).toBeUndefined();
-    expect(backOff.getBackOff('prefix-test-2')).toBeUndefined();
-    // The other process should still exist.
-    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+      await expect(promise).rejects.toThrow('Skipping (canFn test failed)');
+      expect(delayedFn).not.toHaveBeenCalled();
+    });
   });
 });
diff --git a/shell/utils/__tests__/pagination-wrapper.test.ts b/shell/utils/__tests__/pagination-wrapper.test.ts
new file mode 100644
index 00000000000..505214a2d24
--- /dev/null
+++ b/shell/utils/__tests__/pagination-wrapper.test.ts
@@ -0,0 +1,167 @@
+import PaginationWrapper from '@shell/utils/pagination-wrapper';
+import paginationUtils from '@shell/utils/pagination-utils';
+import backOff from '@shell/utils/back-off';
+import { STEVE_RESPONSE_CODE } from '@shell/types/rancher/steve.api';
+
+jest.mock('@shell/utils/pagination-utils');
+jest.mock('@shell/utils/back-off');
+
+describe('paginationWrapper', () => {
+  let store: any;
+  let args: any;
+
+  beforeEach(() => {
+    store = {
+      getters:    {},
+      dispatch:   jest.fn(),
+      $extension: {}
+    };
+    args = {
+      $store:     store,
+      id:         'test-id',
+      enabledFor: {
+        store:    'management',
+        resource: {
+          id:      'cluster',
+          context: 'side-bar'
+        }
+      },
+      onChange: jest.fn(),
+    };
+
+    (paginationUtils.isEnabled as jest.Mock).mockReturnValue(true);
+    (backOff.getBackOff as jest.Mock).mockReturnValue(undefined);
+    (backOff.recurse as jest.Mock).mockImplementation(async({ delayedFn }) => {
+      return await delayedFn();
+    });
+    (backOff.reset as jest.Mock).mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should initialize correctly', () => {
+    const wrapper = new PaginationWrapper(args);
+
+    expect(wrapper.isEnabled).toBe(true);
+    expect(paginationUtils.isEnabled).toHaveBeenCalledWith({ rootGetters: store.getters, $extension: store.$extension }, args.enabledFor);
+  });
+
+  it('request should throw if not enabled', async() => {
+    (paginationUtils.isEnabled as jest.Mock).mockReturnValue(false);
+    const wrapper = new PaginationWrapper(args);
+
+    await expect(wrapper.request({ pagination: {} as any })).rejects.toThrow('not supported');
+  });
+
+  it('request should handle HA scenario 1,2 case 1: active revision newer than target', async() => {
+    (backOff.getBackOff as jest.Mock).mockReturnValue({ metadata: { revision: '10' } });
+    const wrapper = new PaginationWrapper(args);
+
+    await expect(wrapper.request({ pagination: {} as any, revision: '5' })).rejects.toThrow('Ignoring current request');
+  });
+
+  it('request should handle HA scenario 1,2 case 2: cached revision newer than target', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    // Mock internal state if possible or simulate a previous request
+    // Since cachedRevision is private, we can simulate it by making a request first
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '10' } }, data: [] });
+    await wrapper.request({ pagination: {} as any, revision: '10' }); // Sets cachedRevision to 10
+
+    await expect(wrapper.request({ pagination: {} as any, revision: '5' })).resolves.toBeDefined(); // Should return cached result
+    // Note: The implementation warns but returns cachedResult if available.
+  });
+
+  it('request should handle HA scenario 1,2 case 3: target revision newer than current', async() => {
+    (backOff.getBackOff as jest.Mock).mockReturnValue({ metadata: { revision: '5' } });
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '10' } }, data: [] });
+    await wrapper.request({ pagination: {} as any, revision: '10' });
+
+    expect(backOff.reset).toHaveBeenCalledWith('test-id');
+  });
+
+  it('request should call backOff.recurse and dispatch findPage', async() => {
+    const wrapper = new PaginationWrapper(args);
+    const pagination = { page: 1 } as any;
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination });
+
+    expect(backOff.recurse).toHaveBeenCalledWith(expect.objectContaining({
+      id:       'test-id',
+      metadata: { revision: undefined }
+    }));
+    expect(store.dispatch).toHaveBeenCalledWith('management/findPage', expect.objectContaining({
+      opt:  expect.objectContaining({ pagination }),
+      type: 'cluster'
+    }));
+  });
+
+  it('request should setup watch on first call if onChange provided', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination: {} as any });
+
+    expect(store.dispatch).toHaveBeenCalledWith('management/watchEvent', expect.objectContaining({
+      id:     'test-id',
+      params: expect.objectContaining({ type: 'cluster' })
+    }));
+  });
+
+  it('request should classify data if requested', async() => {
+    args.formatResponse = { classify: true };
+    const wrapper = new PaginationWrapper(args);
+    const rawData = [{ id: '1' }];
+    const classifiedData = [{ id: '1', _classified: true }];
+
+    store.dispatch.mockImplementation((action: string) => {
+      if (action === 'management/findPage') {
+        return { pagination: { result: { revision: '1' } }, data: rawData };
+      }
+      if (action === 'management/createMany') {
+        return classifiedData;
+      }
+    });
+
+    const res = await wrapper.request({ pagination: {} as any });
+
+    expect(res.data).toStrictEqual(classifiedData);
+    expect(store.dispatch).toHaveBeenCalledWith('management/createMany', rawData);
+  });
+
+  it('onDestroy should unwatch', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination: {} as any }); // Setup watch
+    await wrapper.onDestroy();
+
+    expect(store.dispatch).toHaveBeenCalledWith('management/unwatchEvent', expect.objectContaining({ id: 'test-id' }));
+  });
+
+  describe('backOff configuration', () => {
+    it('continueOnError should return true for UNKNOWN_REVISION', async() => {
+      const wrapper = new PaginationWrapper(args);
+
+      store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+      await wrapper.request({ pagination: {} as any });
+
+      const recurseCall = (backOff.recurse as jest.Mock).mock.calls[0][0];
+      const continueOnError = recurseCall.continueOnError;
+
+      expect(await continueOnError({ status: 200 })).toBe(false);
+      expect(await continueOnError({ status: 400, code: STEVE_RESPONSE_CODE.UNKNOWN_REVISION })).toBe(true);
+      expect(await continueOnError({ status: 500 })).toBe(false);
+    });
+  });
+});
diff --git a/shell/utils/back-off.ts b/shell/utils/back-off.ts
index 944a0fc7bb6..200f0123f90 100644
--- a/shell/utils/back-off.ts
+++ b/shell/utils/back-off.ts
@@ -1,11 +1,99 @@
-type BackOffEntry = {
-  timeoutId?: NodeJS.Timeout,
+import { randomStr } from '@shell/utils/string';
+
+type BackOffEntry<MetadataType = any> = {
   try: number,
   retries: number,
   description: string,
-  metadata: any,
+  metadata: MetadataType,
+  execute?: {
+    timeoutId?: NodeJS.Timeout,
+  },
+  recurse?: {
+    id: string,
+  }
 }
 
+interface BackOffArgs<MetadataType = any> {
+  /**
+   * Unique id for the execution of this function.
+   *
+   * This will be used to delay further executions, and also to cancel it
+   */
+  id: string,
+  /**
+   * Basic text description to use in logging
+   */
+  description: string,
+  /**
+   * Number of executions allowed before flatly refusing to call more. Defaults to 10
+   */
+  retries?: number,
+  /**
+   * Before calling delayedFn check if it can still run
+   *
+   * Useful for checking state after a looong delay
+   */
+  canFn?: () => Promise<boolean>,
+  /**
+   * Call this function
+   * - if it's not already waiting to run
+   * - if it's passed canFn
+   * - if it hasn't been tried over `retries` amount
+   *
+   * The function will be increasingly (exponentially) delayed if it has previously been called
+   */
+  delayedFn: () => Promise<any>,
+  /**
+   * Anything that might be important outside of this file (used with `getBackOff`)
+   */
+  metadata?: MetadataType,
+  /**
+   *
+   * RESET_ON_SUCCESS
+   */
+  mode?: ''
+}
+
+const metadataToString = (metadata: any) => {
+  if (!metadata) {
+    return '';
+  }
+
+  return JSON.stringify(metadata, (_, value) => {
+    return value === undefined ? '' : value;
+  });
+};
+
+export type BackOffExecuteArgs<MetadataType> = BackOffArgs<MetadataType>
+
+export interface BackOffRecurseArgs<MetadataType> extends BackOffArgs<MetadataType> {
+  /**
+   * Should we continue to to try even if the previous attempt failed?
+   */
+  continueOnError: (arg: any) => Promise<boolean>,
+}
+
+const logStyle = 'font-weight: bold; font-style: italic;';
+const logStyleReset = 'font-weight: normal; font-style: normal;';
+
+enum LOG_TYPE { // eslint-disable-line no-unused-vars
+  /** Aligns with `execute` method */
+  EXECUTE = 'delay', // eslint-disable-line no-unused-vars
+  /** Aligns with `recurse` method */
+  RECURSE = 'recurse', // eslint-disable-line no-unused-vars
+}
+type LogLevel = 'error' | 'info' | 'debug' | 'warn' | undefined;
+type LogArgs = { id: string, status: string, description: string, metadata?: any, type: string }
+
+const logInitialBackOffRequest = false;
+const calcLogLevel = (iteration: number): LogLevel => {
+  if (!logInitialBackOffRequest && iteration === 0) {
+    return undefined;
+  }
+
+  return 'info';
+};
+
 /**
  * Helper class which handles backing off making the supplied request
  *
@@ -16,21 +104,65 @@ class BackOff {
    [id: string]: BackOffEntry
   } = {};
 
-  private log(level: 'error' | 'info' | 'debug', id: string, classDescription: string, description: string, ...args: any[]) {
-    console[level](`BackOff... Id: "${ id }". Description: "${ description }"\nStatus: ${ classDescription }\n`, ...args); // eslint-disable-line no-console
+  private getLogTypeFromMap(id: string): string {
+    const entry = this.getBackOff(id);
+
+    let safeType = '';
+
+    if (!!entry?.execute) {
+      safeType = LOG_TYPE.EXECUTE;
+    } else if (!!entry?.recurse) {
+      safeType = LOG_TYPE.RECURSE;
+    }
+
+    return safeType;
+  }
+
+  private log(level: LogLevel, {
+    id, status, description, metadata, type
+  }: LogArgs, ...args: any[]) {
+    if (!level) {
+      return;
+    }
+
+    let safeType = type || this.getLogTypeFromMap(id);
+
+    safeType = safeType ? ` (${ safeType })` : '';
+
+    // eslint-disable-next-line no-console
+    console[level](
+      `%cBackOff${ safeType }%c... \n%cId%c:          ${ id }\n%cDescription%c: ${ description }\n%cStatus%c:      ${ status }\n%cMetadata%c:    ${ metadataToString(metadata) }\n%cCache %c:       ${ Object.keys(this.map).map((e) => `"${ e }"`).join(' + ') }`,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      ...args
+    );
+  }
+
+  private logAndError(level: LogLevel, {
+    id, status, description, metadata, type
+  }: LogArgs, ...args: any[]): Promise<undefined> {
+    this.log(level, {
+      id, status, description, metadata, type
+    }, ...args);
+
+    return Promise.reject(new Error(status));
   }
 
   /**
    * Get a specific back off process
    */
-  getBackOff(id: string): BackOffEntry {
+  public getBackOff(id: string): BackOffEntry {
     return this.map[id];
   }
 
   /**
    * Stop ALL back off processes started since the ui was loaded
    */
-  resetAll() {
+  public resetAll() {
     Object.keys(this.map).forEach((id) => {
       this.reset(id);
     });
@@ -39,7 +171,7 @@ class BackOff {
   /**
    * Stop all back off process with a specific prefix
    */
-  resetPrefix(prefix:string) {
+  public resetPrefix(prefix:string) {
     Object.keys(this.map).forEach((id) => {
       if (id.startsWith(prefix)) {
         this.reset(id);
@@ -50,23 +182,148 @@ class BackOff {
   /**
    * Stop a back off process with a specific id
    */
-  reset(id: string) {
+  public reset(id: string) {
     const backOff: BackOffEntry = this.map[id];
 
-    if (backOff) {
-      if (backOff?.timeoutId) {
-        this.log('info', id, 'Stopping (cancelling active back-off)', backOff.description);
+    if (!backOff) {
+      return;
+    }
+
+    const logType = this.getLogTypeFromMap(id);
+
+    if (backOff?.execute?.timeoutId) {
+      this.log('info', {
+        id, status: 'Stopping (cancelling active back-off)', description: backOff.description, metadata: backOff.metadata, type: logType
+      });
+
+      clearTimeout(backOff.execute.timeoutId);
+    }
+    const backOffTry = backOff?.try || 0;
+    const logLevel = backOffTry <= 1 ? undefined : 'debug';
 
-        clearTimeout(backOff.timeoutId);
+    delete this.map[id];
+
+    this.log(logLevel, {
+      id, status: 'Reset', description: backOff.description, metadata: backOff.metadata, type: logType
+    });
+  }
+
+  private sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  private calcDelay = (iteration: number) => {
+    // First step is immediate (0.001s)
+    // Second and others are exponential
+    // Iteration: 1,     2,   3,     4,    5,      6,    7,       8,    9
+    // Delay:     0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
+    return iteration === 0 ? 1 : Math.pow(iteration, 2) * 250;
+  }
+
+  private canRecurse = async(backOffEntry: BackOffEntry, {
+    id, description, metadata, canFn = async() => true
+  }: BackOffRecurseArgs<any>) => {
+    if (!this.map[id]) {
+      // was reset, don't care now, abort
+      // could be a pagination-wrapper request with a stale revision, which can be safely ignored
+      return this.logAndError('info', {
+        id, status: 'Aborting (backoff was reset, do not continue to process)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+
+    if (this.map[id].recurse?.id !== backOffEntry.recurse?.id) {
+      return this.logAndError('info', {
+        id, status: 'Aborting (stale backoff, a new one exists)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+
+    const cont = await canFn();
+
+    if (!cont) {
+      return this.logAndError('info', {
+        id, status: 'Skipping (canFn test failed)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+  };
+
+  /**
+   * Call a function, if it fails keep trying but with a delay (aka back off)
+   *
+   * Return the successful result, or error if reached the max number of retries
+   *
+   * @template MetadataType - Type of configuration that can be internally stored with the backoff record
+   */
+  public async recurse<MetadataType = any, ResponseType = any>(args: BackOffRecurseArgs<MetadataType>): Promise<ResponseType | undefined> {
+    const {
+      id, description, retries = 10, delayedFn, continueOnError, metadata
+    } = args;
+
+    if (this.map[id]) {
+      return this.logAndError('info', {
+        id, status: 'Skipping (previous recurse back off process still running)', description, metadata, type: 'recurse',
+      });
+    }
+
+    this.map[id] = {
+      try:     1,
+      retries,
+      description,
+      metadata,
+      recurse: { id: randomStr() }
+    };
+
+    for (let i = 0; i < retries; i++) {
+      await this.canRecurse(this.map[id], args); // Check that we can start the process
+
+      this.map[id].try = i + 1;
+
+      const delay = this.calcDelay(i);
+      const logLevel = calcLogLevel(i);
+
+      this.log(logLevel, {
+        id, status: `Delaying call (attempt ${ i + 1 }, delayed by ${ delay }ms)`, description, metadata, type: LOG_TYPE.RECURSE
+      });
+
+      await this.sleep(delay);
+
+      await this.canRecurse(this.map[id], args); // Check that we can call the function (things could have changed after delay...)
+
+      this.log(logLevel, {
+        id, status: `Executing call`, description, metadata, type: LOG_TYPE.RECURSE
+      });
+
+      let res: ResponseType | undefined;
+
+      try {
+        res = await delayedFn();
+      } catch (e) {
+        const cont = await continueOnError(e);
+
+        if (!cont) {
+          this.reset(id); // Allow future calls to execute
+
+          const errorMessage = 'Failed call';
+
+          return this.logAndError('error', {
+            id, status: errorMessage, description, metadata, type: LOG_TYPE.RECURSE
+          }, e);
+        }
       }
-      this.log('debug', id, 'Reset', backOff.description);
 
-      delete this.map[id];
+      if (res) {
+        await this.canRecurse(this.map[id], args); // Check that we can return a result (things could have changed after delayedFn...)
+
+        this.reset(id); // Allow future calls to execute
+
+        this.log(logLevel, {
+          id, status: 'Successful call', description, metadata, type: LOG_TYPE.RECURSE
+        });
+
+        return res;
+      }
     }
   }
 
   /**
-   * Call a function, but if it's recently been called delay execution aka back off
+   * Call a function, but if it's recently been called delay execution (aka back off)
    *
    * This can be used in a totally disjoined asynchronous way
    *
@@ -76,91 +333,67 @@ class BackOff {
    * 4. Repeat steps 2 and 3, with an exponential increasing delay
    *
    * This can be called repeatedly, if the previous delay is still running new requests will be ignored
+   *
+   * @template MetadataType - Type of configuration that can be internally stored with the backoff record
    */
-  async execute<T = any>({
+  public async execute<MetadataType = any>({
     id, description, retries = 10, delayedFn, canFn = async() => true, metadata
-  }: {
-    /**
-     * Unique id for the execution of this function.
-     *
-     * This will be used to delay further executions, and also to cancel it
-     */
-    id: string,
-    /**
-     * Basic text description to use in logging
-     */
-    description: string,
-    /**
-     * Number of executions allowed before flatly refusing to call more. Defaults to 10
-     */
-    retries?: number,
-    /**
-     * Before calling delayedFn check if it can still run
-     *
-     * Useful for checking state after a looong delay
-     */
-    canFn?: () => Promise<boolean>,
-    /**
-     * Call this function
-     * - if it's not already waiting to run
-     * - if it's passed canFn
-     * - if it hasn't been tried over `retries` amount
-     *
-     * The function will be increasingly (exponentially) delayed if it has previously been called
-     */
-    delayedFn: () => Promise<any>,
-    /**
-     * Anything that might be important outside of this file (used with `getBackOff`)
-     */
-    metadata?: T,
-  }): Promise<NodeJS.Timeout | undefined> {
+  }: BackOffExecuteArgs<MetadataType>): Promise<NodeJS.Timeout | undefined> {
     const backOff: BackOffEntry = this.map[id];
 
     const cont = await canFn();
 
     if (!cont) {
-      this.log('info', id, 'Skipping (can execute fn test failed)', description);
+      this.log('info', {
+        id, status: 'Skipping (canExecute test failed)', description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
       return undefined;
-    } else if (backOff?.timeoutId) {
-      this.log('info', id, 'Skipping (previous back off process still running)', description);
+    } else if (backOff?.execute?.timeoutId) {
+      this.log('info', {
+        id, status: 'Skipping (previous back off process still running)', description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
-      return backOff.timeoutId;
+      return backOff?.execute?.timeoutId;
     } else {
       const backOffTry = backOff?.try || 0;
 
       if (backOffTry + 1 > retries) {
-        this.log('error', id, 'Aborting (too many retries)', description);
+        this.log('error', {
+          id, status: 'Aborting (too many retries)', description, metadata, type: LOG_TYPE.EXECUTE
+        });
 
         return undefined;
       }
 
-      // First step is immediate (0.001s)
-      // Second and others are exponential
-      // Try:         1,     2,   3,     4,    5,      6,    7,       8,    9
-      // Multiple:    1,     4,   9,     16,   25,     36,   49,      64,   81
-      // Actual Time: 0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
-      const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
+      const delay = this.calcDelay(backOffTry);
+      const logLevel = calcLogLevel(backOffTry);
 
-      this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);
+      this.log(logLevel, {
+        id, status: `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
       const timeout = setTimeout(async() => {
         try {
-          this.log('info', id, `Executing call`, description);
+          this.log(logLevel, {
+            id, status: `Executing call`, description, metadata, type: LOG_TYPE.EXECUTE
+          });
 
           await delayedFn();
         } catch (e) {
           // Error occurred. Don't clear the map. Next time this is called we'll back off before trying ...
-          this.log('error', id, 'Failed call', description, e);
+          this.log('error', {
+            id, status: 'Failed call', description, metadata, type: LOG_TYPE.EXECUTE
+          });
         }
 
         // Unblock future calls
-        delete this.map[id]?.timeoutId;
+        delete this.map[id]?.execute?.timeoutId;
       }, delay);
 
       this.map[id] = {
-        timeoutId: timeout,
-        try:       backOff?.try ? backOff.try + 1 : 1,
+        execute: { timeoutId: timeout },
+        try:     backOff?.try ? backOff.try + 1 : 1,
         retries,
         description,
         metadata
diff --git a/shell/utils/inactivity.ts b/shell/utils/inactivity.ts
index 0737a1ec4c3..b079251f07b 100644
--- a/shell/utils/inactivity.ts
+++ b/shell/utils/inactivity.ts
@@ -1,8 +1,7 @@
 import { EXT } from '@shell/config/types';
-import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+import { SteveGetResponse } from '@shell/types/rancher/steve.api';
 
-interface UserActivityResponse {
-  metadata: RancherKubeMetadata,
+interface UserActivityResponse extends SteveGetResponse {
   status: {
     expiresAt: string
   }
diff --git a/shell/utils/pagination-wrapper.ts b/shell/utils/pagination-wrapper.ts
index 9349faa1907..4d5c4eee5c4 100644
--- a/shell/utils/pagination-wrapper.ts
+++ b/shell/utils/pagination-wrapper.ts
@@ -5,6 +5,9 @@ import { ActionFindPageArgs, ActionFindPageTransientResponse } from '@shell/type
 import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 import { Reactive, reactive } from 'vue';
 import { STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON } from '@shell/types/store/subscribe-events.types';
+import backOff from '@shell/utils/back-off';
+import { SteveRevision } from '@shell/plugins/steve/revision';
+import { STEVE_RESPONSE_CODE } from '@shell/types/rancher/steve.api';
 
 interface Args {
   $store: VuexStore,
@@ -31,7 +34,7 @@ interface Args {
 }
 
 interface Result<T> extends Omit<ActionFindPageTransientResponse<T>, 'data'> {
-  data: Reactive<T[]>
+  data: Reactive<T[]> | T[]
 }
 
 /**
@@ -50,9 +53,12 @@ class PaginationWrapper<T extends object> {
   private $store: VuexStore;
   private enabledFor: PaginationResourceContext;
   private onChange?: STEVE_WATCH_EVENT_LISTENER_CALLBACK;
-  private id: string;
+  public id: string;
+  private backOffId: string;
   private classify: boolean;
   private reactive: boolean;
+  private cachedRevision?: string;
+  private cachedResult?: Result<T>;
 
   public isEnabled: boolean;
   private steveWatchParams: STEVE_WATCH_EVENT_PARAMS_COMMON | undefined;
@@ -64,6 +70,7 @@ class PaginationWrapper<T extends object> {
 
     this.$store = $store;
     this.id = id;
+    this.backOffId = `${ this.id }`;
     this.enabledFor = enabledFor;
     this.onChange = onChange;
     this.classify = formatResponse?.classify || false;
@@ -72,31 +79,106 @@ class PaginationWrapper<T extends object> {
     this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters, $extension: this.$store.$extension }, enabledFor);
   }
 
-  async request({ pagination, forceWatch }: {
+  async request(requestArgs: {
     forceWatch?: boolean,
     pagination: PaginationArgs,
+    revision?: string,
   }): Promise<Result<T>> {
+    const { pagination, forceWatch, revision } = requestArgs;
+    const type = this.enabledFor.resource?.id;
+
     if (!this.isEnabled) {
-      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ type }' in context '${ this.enabledFor.resource?.context }' not supported`);
     }
-    const opt: ActionFindPageArgs = {
-      watch:     false,
-      pagination,
-      transient: true,
-    };
 
-    // Fetch
-    const out: ActionFindPageTransientResponse<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+    const backOffId = this.backOffId;
+
+    const activeRevisionSt = backOff.getBackOff(backOffId)?.metadata.revision;
+    const cachedRevisionSt = this.cachedRevision;
+
+    const targetRevision = new SteveRevision(revision);
+    const activeRevision = new SteveRevision(activeRevisionSt);
+    const cachedRevision = new SteveRevision(cachedRevisionSt);
+    const currentRevision = new SteveRevision(activeRevisionSt || cachedRevisionSt);
+
+    // Three cases to support HA scenarios 2 + 3
+    // 1. current version is newer than target revision - abort/ignore (don't overwrite new with old)
+    // 2. current version in cache is older than target revision - reset previous (drop older requests with older revision, use new revision)
+    // 3. current version in cache is same as target revision - we're retrying
+
+    // There are two places we do this to cover the two cases we make http request following socket changes
+    // shell/utils/pagination-wrapper.ts - request
+    // shell/plugins/steve/subscribe.js - fetchPageResources
+
+    if (currentRevision.isNewerThan(targetRevision)) {
+      if (activeRevision.isNewerThan(targetRevision)) {
+        // eslint-disable-next-line no-console
+        console.info(`Ignoring event listener request to update '${ this.id }' with revision '${ targetRevision.revision }' (newer in-progress revision '${ activeRevision.revision }'). `);
+
+        // Case 1 - abort/ignore (don't overwrite new with old). Specifically we're fetching something with a higher revision, ignore the newer request with older revision
+        return Promise.reject(new Error('Ignoring current request in favour of other in-progress request with newer revision')); // This will abort the current batch of updates, meaning the other in-progress can update with the newer revision
+      }
+
+      if (cachedRevision.isNewerThan(targetRevision)) {
+        // eslint-disable-next-line no-console
+        console.info(`Ignoring event listener request to update '${ this.id }' with revision '${ targetRevision.revision }' (newer cached revision '${ cachedRevision.revision }'). `);
+
+        // Case 1 - abort/ignore (don't overwrite new with old). Specifically we're already fetched something with a higher revision, ignore the newer request with older revision and just return the cached version
+        if (this.cachedResult) {
+          return this.cachedResult;
+        }
+
+        return Promise.reject(new Error('Cache has higher revision than target revision... but no cached results?'));
+      }
+    }
+
+    if (targetRevision.isNewerThan(activeRevision)) {
+      // Case 2 - reset previous (drop older requests with older revision, use new revision)
+
+      // eslint-disable-next-line no-console
+      console.info(`Dropping event listener request to update '${ this.id }' with revision '${ currentRevision.revision }' (newer target revision '${ targetRevision.revision }'). `);
+
+      backOff.reset(backOffId);
+    }
+
+    // Keep making requests until we make one that succeeds, fails with unknown revision or we run out of retries
+    const out = await backOff.recurse<any, ActionFindPageTransientResponse<T>>({
+      id:              backOffId,
+      metadata:        { revision },
+      description:     `Fetching resources for ${ type } (wrapper). Initial request, or triggered by web socket`,
+      continueOnError: async(err) => {
+        // Have we made a request to a stale replica that does not know about the required revision? If so continue to try until we hit a ripe replica
+        return err?.status === 400 && err?.code === STEVE_RESPONSE_CODE.UNKNOWN_REVISION;
+      },
+      delayedFn: async() => {
+        const opt: ActionFindPageArgs = {
+          watch:     false,
+          pagination,
+          transient: true,
+          revision
+        };
+        const res: ActionFindPageTransientResponse<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type });
+
+        this.cachedRevision = res.pagination?.result.revision;
+
+        return res;
+      },
+    });
+
+    if (!out) {
+      // Skip
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ type }' in context '${ this.enabledFor.resource?.context }' failed to fetch resources`);
+    }
 
     // Watch
     const firstTime = !this.steveWatchParams;
 
-    if (this.onChange && (firstTime || forceWatch) ) { // && !this.steveWatchParams
+    if (this.onChange && (firstTime || forceWatch) ) {
       this.steveWatchParams = {
         event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
         id:     this.id,
         params: {
-          type:  this.enabledFor.resource?.id as string,
+          type:  type as string,
           mode:  STEVE_WATCH_MODE.RESOURCE_CHANGES,
           force: forceWatch,
         },
@@ -112,13 +194,15 @@ class PaginationWrapper<T extends object> {
     }
 
     if (this.reactive) {
-      return {
+      this.cachedResult = {
         ...out,
         data: reactive(out.data)
       };
+    } else {
+      this.cachedResult = out;
     }
 
-    return out;
+    return this.cachedResult;
   }
 
   private async watch() {