diff --git a/shell/assets/translations/en-us.yaml b/shell/assets/translations/en-us.yaml
index b2fbc025d..0d8a05ceb 100644
--- a/shell/assets/translations/en-us.yaml
+++ b/shell/assets/translations/en-us.yaml
@@ -3062,7 +3062,9 @@ clusterIndexPage:
     pods: Pods
     ram: Memory
     used: Used
+    usedTooltip: The amount in use right now, including by the system, out of the total capacity.
     reserved: Reserved
+    reservedTooltip: The amount pods have requested, out of what is available to pods, which is the total capacity minus what is set aside for the system.
     allocated: Allocated
     units:
       cores: |-
@@ -3080,6 +3082,7 @@ clusterIndexPage:
     capacity:
       label: Capacity
       countedNodes: "{counted} of {total} nodes. Cordoned nodes, and control plane or etcd nodes that don't run workloads, aren't counted"
+      reportingNodes: "Used covers {reporting} of {counted} nodes. The others are not reporting metrics"
     events:
       label: Events
       resource:
@@ -5626,7 +5629,6 @@ node:
     glance:
       consumptionGauge:
         used: Used
-        reserved: Reserved
         amount: "{used} of {total} {unit}"
         cpu: CPU
         memory: Memory
diff --git a/shell/components/HardwareResourceGauge.vue b/shell/components/HardwareResourceGauge.vue
index 883afe2ef..291b04a39 100644
--- a/shell/components/HardwareResourceGauge.vue
+++ b/shell/components/HardwareResourceGauge.vue
@@ -25,6 +25,11 @@ export default {
       default: null
     },
 
+    usedTooltip: {
+      type:    String,
+      default: null
+    },
+
     reserved: {
       type:    Object,
       default: null
@@ -33,6 +38,11 @@ export default {
     reservedTitle: {
       type:    String,
       default: null
+    },
+
+    reservedTooltip: {
+      type:    String,
+      default: null
     }
   },
   computed: {
@@ -90,6 +100,15 @@ export default {
           <template #title>
             <span>
               {{ reservedTitle ?? t('clusterIndexPage.hardwareResourceGauge.reserved') }}
+              <i
+                v-if="reservedTooltip"
+                v-clean-tooltip="{ content: reservedTooltip, triggers: ['hover', 'touch', 'focus'] }"
+                class="icon icon-info text-muted"
+                role="img"
+                tabindex="0"
+                :aria-label="reservedTooltip"
+                data-testid="hardware-resource-gauge-reserved-tooltip"
+              />
               <span class="values text-muted">
                 <span v-if="reserved.formattedUseful">
                   {{ reserved.formattedUseful }}
@@ -125,6 +144,15 @@ export default {
           <template #title>
             <span>
               {{ usedTitle ?? t('clusterIndexPage.hardwareResourceGauge.used') }}
+              <i
+                v-if="usedTooltip"
+                v-clean-tooltip="{ content: usedTooltip, triggers: ['hover', 'touch', 'focus'] }"
+                class="icon icon-info text-muted"
+                role="img"
+                tabindex="0"
+                :aria-label="usedTooltip"
+                data-testid="hardware-resource-gauge-used-tooltip"
+              />
               <span class="values text-muted">
                 <span v-if="used.formattedUseful">
                   {{ used.formattedUseful }}
diff --git a/shell/components/__tests__/HardwareResourceGauge.test.ts b/shell/components/__tests__/HardwareResourceGauge.test.ts
index d2098274d..49c0874ac 100644
--- a/shell/components/__tests__/HardwareResourceGauge.test.ts
+++ b/shell/components/__tests__/HardwareResourceGauge.test.ts
@@ -3,11 +3,12 @@ import HardwareResourceGauge from '@shell/components/HardwareResourceGauge.vue';
 import ConsumptionGauge from '@shell/components/ConsumptionGauge.vue';
 
 describe('component: HardwareResourceGauge', () => {
-  const createWrapper = () => mount(HardwareResourceGauge, {
+  const createWrapper = (props = {}) => mount(HardwareResourceGauge, {
     props: {
       name:     'CPU',
       used:     { total: 10, useful: 2 },
       reserved: { total: 10, useful: 5 },
+      ...props,
     },
     global: { stubs: { ConsumptionGauge: true } },
   });
@@ -25,4 +26,36 @@ describe('component: HardwareResourceGauge', () => {
 
     expect(gauge.props('barSize')).toStrictEqual('small');
   });
+
+  describe('tooltips', () => {
+    // A stub drops the slot the tooltips are in
+    const createWrapperWithGauges = (props = {}) => mount(HardwareResourceGauge, {
+      props: {
+        name:     'CPU',
+        used:     { total: 10, useful: 2 },
+        reserved: { total: 10, useful: 5 },
+        ...props,
+      },
+    });
+
+    it('should explain used and reserved when given what to say', () => {
+      const wrapper = createWrapperWithGauges({ usedTooltip: 'used text', reservedTooltip: 'reserved text' });
+
+      expect(wrapper.find('[data-testid="hardware-resource-gauge-used-tooltip"]').attributes('aria-label')).toStrictEqual('used text');
+      expect(wrapper.find('[data-testid="hardware-resource-gauge-reserved-tooltip"]').attributes('aria-label')).toStrictEqual('reserved text');
+    });
+
+    it('should reach the tooltips with the keyboard', () => {
+      const wrapper = createWrapperWithGauges({ usedTooltip: 'used text', reservedTooltip: 'reserved text' });
+
+      expect(wrapper.find('[data-testid="hardware-resource-gauge-used-tooltip"]').attributes('tabindex')).toStrictEqual('0');
+      expect(wrapper.find('[data-testid="hardware-resource-gauge-reserved-tooltip"]').attributes('tabindex')).toStrictEqual('0');
+    });
+
+    it('should not show them otherwise, e.g. for the pods gauge', () => {
+      const wrapper = createWrapperWithGauges();
+
+      expect(wrapper.find('.icon-info').exists()).toBe(false);
+    });
+  });
 });
diff --git a/shell/components/graph/Bar.vue b/shell/components/graph/Bar.vue
index cf4e197b9..402a31a2b 100644
--- a/shell/components/graph/Bar.vue
+++ b/shell/components/graph/Bar.vue
@@ -28,11 +28,8 @@ export default {
   },
   computed: {
     indicatorStyle() {
-      // A width outside 0-100% isn't drawn as such, e.g. a negative one is dropped, which leaves the indicator full width
-      const width = Number.isFinite(this.percentage) ? Math.min(Math.max(this.percentage, 0), 100) : 0;
-
       return {
-        width:           `${ width }%`,
+        width:           `${ this.percentage }%`,
         backgroundColor: `var(${ this.primaryColor })`
       };
     },
diff --git a/shell/components/graph/__tests__/Bar.test.ts b/shell/components/graph/__tests__/Bar.test.ts
index 4a6e5b85f..35fc920e6 100644
--- a/shell/components/graph/__tests__/Bar.test.ts
+++ b/shell/components/graph/__tests__/Bar.test.ts
@@ -36,20 +36,6 @@ describe('component: Bar', () => {
     });
   });
 
-  it.each([
-    [50, '50%'],
-    [0, '0%'],
-    [100, '100%'],
-    [-5.62, '0%'],
-    [130, '100%'],
-    [NaN, '0%'],
-    [Infinity, '0%'],
-  ])('should draw a percentage of %p as an indicator %p wide', (percentage, width) => {
-    const wrapper = shallowMount(Bar, { props: { percentage } });
-
-    expect(wrapper.vm.indicatorStyle.width).toStrictEqual(width);
-  });
-
   it('should keep the secondary color as the bar background', () => {
     const wrapper = shallowMount(Bar, { props: { percentage: 50, secondaryColor: '--muted' } });
 
diff --git a/shell/detail/__tests__/node.test.ts b/shell/detail/__tests__/node.test.ts
index ad70f1b94..14b89f948 100644
--- a/shell/detail/__tests__/node.test.ts
+++ b/shell/detail/__tests__/node.test.ts
@@ -1,7 +1,6 @@
 import { shallowMount } from '@vue/test-utils';
 import node from '@shell/detail/node.vue';
-import ConsumptionGauge from '@shell/components/ConsumptionGauge.vue';
-import Card from '@shell/components/Resource/Detail/Card/index.vue';
+import HardwareResourceGauge from '@shell/components/HardwareResourceGauge.vue';
 
 describe('view: node detail', () => {
   const mockStore = {
@@ -27,6 +26,7 @@ describe('view: node detail', () => {
     },
     spec:               { taints: [] },
     pods:               [],
+    usage:              { cpu: '2', memory: '4000' },
     cpuCapacity:        5,
     cpuAllocatable:     4,
     cpuReserved:        3,
@@ -47,117 +47,85 @@ describe('view: node detail', () => {
   function createWrapper(nodeOverrides = {}) {
     return shallowMount(node, {
       props:  { value: { ...defaultNodeValue, ...nodeOverrides } },
-      global: {
-        mocks,
-        // Each gauge lives in a card's default slot, which a stub drops unless told otherwise
-        renderStubDefaultSlot: true,
-      },
+      global: { mocks },
     });
   }
 
-  function findCardByResource(wrapper: ReturnType<typeof createWrapper>, resourceKey: string) {
-    return wrapper.findAllComponents(Card).find((c) => c.props('title')?.includes(resourceKey));
+  function findGauge(wrapper: ReturnType<typeof createWrapper>, resourceKey: string) {
+    return wrapper.findAllComponents(HardwareResourceGauge).find((gauge) => gauge.props('name')?.includes(resourceKey))!;
   }
 
-  function findGaugeByResource(wrapper: ReturnType<typeof createWrapper>, resourceKey: string) {
-    return findCardByResource(wrapper, resourceKey)?.findComponent(ConsumptionGauge);
-  }
-
-  function findGaugesByResource(wrapper: ReturnType<typeof createWrapper>, resourceKey: string) {
-    return findCardByResource(wrapper, resourceKey)?.findAllComponents(ConsumptionGauge) || [];
-  }
-
-  it.each([
-    'consumptionGauge.cpu',
-    'consumptionGauge.memory',
-    'consumptionGauge.pods',
-  ])('should render the %s gauge inside a card titled with its resource name', (resourceKey) => {
+  it('should show the pods, CPU and memory in the order of the cluster dashboard', () => {
     const wrapper = createWrapper();
 
-    const gauge = findGaugeByResource(wrapper, resourceKey);
-
-    expect(gauge?.exists()).toStrictEqual(true);
+    expect(wrapper.findAllComponents(HardwareResourceGauge).map((gauge) => gauge.props('name'))).toStrictEqual([
+      '%node.detail.glance.consumptionGauge.pods%',
+      '%node.detail.glance.consumptionGauge.cpu%',
+      '%node.detail.glance.consumptionGauge.memory%',
+    ]);
   });
 
-  it.each([
-    'consumptionGauge.cpu',
-    'consumptionGauge.memory',
-    'consumptionGauge.pods',
-  ])('should NOT pass a resource name to the %s gauge, so the card title is not repeated', (resourceKey) => {
-    const wrapper = createWrapper();
-
-    const gauge = findGaugeByResource(wrapper, resourceKey);
+  it('should show the running pods out of the capacity, without reserved', () => {
+    const gauge = findGauge(createWrapper(), 'consumptionGauge.pods');
 
-    expect(gauge!.props('resourceName')).toStrictEqual('');
+    expect(gauge.props('used')).toStrictEqual({ total: 110, useful: 5 });
+    expect(gauge.props('usedTitle')).toContain('consumptionGauge.running');
+    expect(gauge.props('reserved')).toBeNull();
   });
 
-  it.each([
-    'consumptionGauge.cpu',
-    'consumptionGauge.memory',
-    'consumptionGauge.pods',
-  ])('should render the %s gauge with a small bar', (resourceKey) => {
-    const wrapper = createWrapper();
-
-    const gauge = findGaugeByResource(wrapper, resourceKey);
+  // The same as the cluster dashboard: reserved is out of the allocatable, used out of the capacity
+  it('should show the reserved CPU out of the allocatable and the used CPU out of the capacity', () => {
+    const gauge = findGauge(createWrapper(), 'consumptionGauge.cpu');
 
-    expect(gauge!.props('barSize')).toStrictEqual('small');
+    expect([gauge.props('reserved')?.total, gauge.props('reserved')?.useful]).toStrictEqual([4, 3]);
+    expect([gauge.props('used')?.total, gauge.props('used')?.useful]).toStrictEqual([5, 2]);
   });
 
-  it('should pass the "running" translation key as usedlabel to the pods ConsumptionGauge', () => {
-    const wrapper = createWrapper();
+  it('should show the reserved memory out of the allocatable and the used memory out of the capacity', () => {
+    const gauge = findGauge(createWrapper(), 'consumptionGauge.memory');
 
-    const podsGauge = findGaugeByResource(wrapper, 'consumptionGauge.pods');
-
-    expect(podsGauge).toBeDefined();
-    expect(podsGauge!.attributes('usedlabel')).toContain('consumptionGauge.running');
+    expect([gauge.props('reserved')?.total, gauge.props('reserved')?.useful]).toStrictEqual([8000, 6000]);
+    expect([gauge.props('used')?.total, gauge.props('used')?.useful]).toStrictEqual([9000, 4000]);
   });
 
-  // The same as the cluster dashboard: reserved is out of the allocatable, used out of the capacity
   it.each([
-    ['consumptionGauge.cpu', [[4, 3], [5, 2]]],
-    ['consumptionGauge.memory', [[8000, 6000], [9000, 4000]]],
-  ])('should render the %s reserved gauge, then the used gauge, as [capacity, used] %p', (resourceKey, expected) => {
-    const wrapper = createWrapper();
-
-    const gauges = findGaugesByResource(wrapper, resourceKey);
+    'consumptionGauge.cpu',
+    'consumptionGauge.memory',
+  ])('should not show the used %s of a node without metrics, rather than a usage of 0, but still the reserved', (resourceKey) => {
+    const gauge = findGauge(createWrapper({ usage: undefined }), resourceKey);
 
-    expect(gauges.map((gauge) => [gauge.props('capacity'), gauge.props('used')])).toStrictEqual(expected);
+    expect(gauge.props('used')).toBeNull();
+    expect(gauge.props('reserved')).not.toBeNull();
   });
 
   it.each([
     'consumptionGauge.cpu',
     'consumptionGauge.memory',
-  ])('should label the %s reserved gauge as reserved, and leave the used gauge with the default label', (resourceKey) => {
-    const wrapper = createWrapper();
-
-    const [reserved, used] = findGaugesByResource(wrapper, resourceKey);
+  ])('should explain used and reserved on the %s gauge', (resourceKey) => {
+    const gauge = findGauge(createWrapper(), resourceKey);
 
-    expect([reserved.attributes('usedlabel'), used.attributes('usedlabel')]).toStrictEqual(['%node.detail.glance.consumptionGauge.reserved%', undefined]);
+    expect(gauge.props('usedTooltip')).toContain('hardwareResourceGauge.usedTooltip');
+    expect(gauge.props('reservedTooltip')).toContain('hardwareResourceGauge.reservedTooltip');
   });
 
-  describe('memory ConsumptionGauge', () => {
-    // The gauge renders a single unit label, taken from the total. The used and total values are
-    // scaled independently, so a shared label misreports any node whose usage is orders of
-    // magnitude below its capacity - 900MiB of 62GiB would read "900 GiB of 62 GiB".
-    it('should NOT pass a shared units label', () => {
-      const wrapper = createWrapper();
-
-      const memoryGauge = findGaugeByResource(wrapper, 'consumptionGauge.memory');
-
-      expect(memoryGauge!.props('units')).toBe('');
-    });
-
+  describe('memory', () => {
+    // The used and total values are scaled independently, so each carries its own unit -
+    // 900MiB of 62GiB would otherwise read "900 GiB of 62 GiB".
     it.each([
       ['scales each value on its own', 900 * 1024 ** 2, '900 MiB'],
       ['keeps used and total in step when they share a unit', 3.55 * 1024 ** 3, '3.55 GiB'],
       ['reads plain bytes as B rather than iB', 512, '512 B'],
-    ])('should pass a numberFormatter that %s', (_, value, expected) => {
-      const wrapper = createWrapper();
+      ['keeps two decimals like the cluster dashboard, so it adds up with the percentage', 15.42 * 1024 ** 3, '15.42 GiB'],
+    ])('should format the used amount so it %s', (_, ramUsage, expected) => {
+      const gauge = findGauge(createWrapper({ ramUsage }), 'consumptionGauge.memory');
+
+      expect(gauge.props('used')?.formattedUseful).toStrictEqual(expected);
+    });
 
-      const memoryGauge = findGaugeByResource(wrapper, 'consumptionGauge.memory');
-      const numberFormatter = memoryGauge!.props('numberFormatter') as (v: number) => string;
+    it('should format the totals of used and reserved on their own', () => {
+      const gauge = findGauge(createWrapper({ ramCapacity: 8 * 1024 ** 3, ramAllocatable: 900 * 1024 ** 2 }), 'consumptionGauge.memory');
 
-      expect(numberFormatter(value as number)).toBe(expected);
+      expect([gauge.props('used')?.formattedTotal, gauge.props('reserved')?.formattedTotal]).toStrictEqual(['8 GiB', '900 MiB']);
     });
   });
 });
diff --git a/shell/detail/node.vue b/shell/detail/node.vue
index 276eaa6f4..fbc0b2a53 100644
--- a/shell/detail/node.vue
+++ b/shell/detail/node.vue
@@ -1,6 +1,5 @@
 <script>
-import ConsumptionGauge from '@shell/components/ConsumptionGauge';
-import Card from '@shell/components/Resource/Detail/Card/index.vue';
+import HardwareResourceGauge from '@shell/components/HardwareResourceGauge';
 import Alert from '@shell/components/Alert';
 import ResourceTable from '@shell/components/ResourceTable';
 import Tab from '@shell/components/Tabbed/Tab';
@@ -14,7 +13,7 @@ import {
 import ResourceTabs from '@shell/components/form/ResourceTabs';
 import { METRIC, POD } from '@shell/config/types';
 import createEditView from '@shell/mixins/create-edit-view';
-import { formatSi } from '@shell/utils/units';
+import { createMemoryValues } from '@shell/utils/units';
 import DashboardMetrics from '@shell/components/DashboardMetrics';
 import { mapGetters } from 'vuex';
 import { allDashboardsExist } from '@shell/utils/grafana';
@@ -32,9 +31,8 @@ export default {
 
   components: {
     Alert,
-    Card,
-    ConsumptionGauge,
     DashboardMetrics,
+    HardwareResourceGauge,
     Loading,
     ResourceTabs,
     Tab,
@@ -152,20 +150,53 @@ export default {
 
     graphVars() {
       return { instance: `${ this.value.internalIp }:9796` };
+    },
+
+    podsUsed() {
+      return { total: this.value.podCapacity, useful: this.value.podConsumed };
+    },
+
+    cpuReserved() {
+      return this.cpuValues(this.value.cpuAllocatable, this.value.cpuReserved);
+    },
+
+    cpuUsed() {
+      return this.value.usage ? this.cpuValues(this.value.cpuCapacity, this.value.cpuUsage) : null;
+    },
+
+    ramReserved() {
+      return this.memoryValues(this.value.ramAllocatable, this.value.ramReserved);
+    },
+
+    ramUsed() {
+      return this.value.usage ? this.memoryValues(this.value.ramCapacity, this.value.ramUsage) : null;
     }
   },
 
   methods: {
+    cpuValues(total, useful) {
+      return {
+        total,
+        useful,
+        units: this.t('clusterIndexPage.hardwareResourceGauge.units.cores', { count: total })
+      };
+    },
+
+    memoryValues(total, useful) {
+      return {
+        total,
+        useful,
+        formattedTotal:  this.memoryFormatter(total),
+        formattedUseful: this.memoryFormatter(useful)
+      };
+    },
+
     memoryFormatter(value) {
       // Each value is scaled independently, so it has to carry its own unit -
       // a node using 900MiB of 62GiB must not read "900 GiB of 62 GiB".
-      const formatOptions = {
-        increment:   1024,
-        suffix:      'iB',
-        firstSuffix: 'B',
-      };
+      const { useful, units } = createMemoryValues(value, value);
 
-      return formatSi(value, formatOptions);
+      return `${ useful } ${ units === 'iB' ? 'B' : units }`;
     },
 
     mapToStatus(isOk) {
@@ -217,48 +248,26 @@ export default {
       />
     </div>
     <div class="mt-20 resources">
-      <!-- Like the cluster dashboard: reserved is what pods request out of the allocatable, used is the usage of the whole node out of its capacity -->
-      <Card :title="t('node.detail.glance.consumptionGauge.cpu')">
-        <div class="gauges mmb-1">
-          <ConsumptionGauge
-            :capacity="value.cpuAllocatable"
-            :used="value.cpuReserved"
-            :used-label="t('node.detail.glance.consumptionGauge.reserved')"
-            bar-size="small"
-          />
-          <ConsumptionGauge
-            :capacity="value.cpuCapacity"
-            :used="value.cpuUsage"
-            bar-size="small"
-          />
-        </div>
-      </Card>
-      <Card :title="t('node.detail.glance.consumptionGauge.memory')">
-        <div class="gauges mmb-1">
-          <ConsumptionGauge
-            :capacity="value.ramAllocatable"
-            :used="value.ramReserved"
-            :used-label="t('node.detail.glance.consumptionGauge.reserved')"
-            :number-formatter="memoryFormatter"
-            bar-size="small"
-          />
-          <ConsumptionGauge
-            :capacity="value.ramCapacity"
-            :used="value.ramUsage"
-            :number-formatter="memoryFormatter"
-            bar-size="small"
-          />
-        </div>
-      </Card>
-      <Card :title="t('node.detail.glance.consumptionGauge.pods')">
-        <ConsumptionGauge
-          class="mmb-1"
-          :capacity="value.podCapacity"
-          :used="value.podConsumed"
-          :used-label="t('node.detail.glance.consumptionGauge.running')"
-          bar-size="small"
-        />
-      </Card>
+      <!-- The same cards as the cluster dashboard: reserved is what pods request out of the allocatable, used is the usage of the whole node out of its capacity -->
+      <HardwareResourceGauge
+        :name="t('node.detail.glance.consumptionGauge.pods')"
+        :used="podsUsed"
+        :used-title="t('node.detail.glance.consumptionGauge.running')"
+      />
+      <HardwareResourceGauge
+        :name="t('node.detail.glance.consumptionGauge.cpu')"
+        :reserved="cpuReserved"
+        :used="cpuUsed"
+        :used-tooltip="t('clusterIndexPage.hardwareResourceGauge.usedTooltip')"
+        :reserved-tooltip="t('clusterIndexPage.hardwareResourceGauge.reservedTooltip')"
+      />
+      <HardwareResourceGauge
+        :name="t('node.detail.glance.consumptionGauge.memory')"
+        :reserved="ramReserved"
+        :used="ramUsed"
+        :used-tooltip="t('clusterIndexPage.hardwareResourceGauge.usedTooltip')"
+        :reserved-tooltip="t('clusterIndexPage.hardwareResourceGauge.reservedTooltip')"
+      />
     </div>
     <div class="spacer" />
     <ResourceTabs
@@ -350,10 +359,4 @@ export default {
   grid-template-columns: repeat(3, 1fr);
   gap: var(--gap-md);
 }
-
-.gauges {
-  display: flex;
-  flex-direction: column;
-  gap: var(--gap-lg);
-}
 </style>
diff --git a/shell/models/__tests__/node.test.ts b/shell/models/__tests__/node.test.ts
index 380644d9a..63a840165 100644
--- a/shell/models/__tests__/node.test.ts
+++ b/shell/models/__tests__/node.test.ts
@@ -25,11 +25,11 @@ describe('class Node', () => {
     const WORKER = 'node-role.kubernetes.io/worker';
 
     const createNode = ({
-      status = {}, spec = {}, labels = {}, metrics
+      status = {}, spec = {}, labels = {}, metrics, annotations = {}, currentCluster = { metadata: { labels: {} }, provisioner: 'k3s' }
     }: any = {}) => new Node({
       id:       'node-1',
       metadata: {
-        name: 'node-1', labels, annotations: {}
+        name: 'node-1', labels, annotations
       },
       spec,
       status: {
@@ -44,7 +44,7 @@ describe('class Node', () => {
     }, {
       rootGetters: {
         'cluster/byId': () => metrics,
-        currentCluster: { metadata: { labels: {} }, provisioner: 'k3s' },
+        currentCluster,
       }
     });
 
@@ -54,6 +54,31 @@ describe('class Node', () => {
       expect([node.cpuUsagePercentage, node.ramUsagePercentage]).toStrictEqual(['25', '25']);
     });
 
+    it('should have no usage without metrics', () => {
+      const node = createNode();
+
+      expect([node.usage, node.cpuUsage, node.ramUsage]).toStrictEqual([undefined, 0, 0]);
+    });
+
+    describe('on an EKS cluster created through Norman', () => {
+      const currentCluster = { metadata: { labels: { 'cattle.io/creator': 'norman' } }, provisioner: 'EKS' };
+      const annotations = { 'management.cattle.io/pod-requests': JSON.stringify({ cpu: '3', memory: '6Gi' }) };
+
+      it('should use the metrics when there are any, like everywhere else', () => {
+        const node = createNode({
+          currentCluster, annotations, metrics: { usage: { cpu: '1', memory: '2Gi' } }
+        });
+
+        expect([node.cpuUsagePercentage, node.ramUsagePercentage]).toStrictEqual(['25', '25']);
+      });
+
+      it('should fall back to what the pods request without metrics', () => {
+        const node = createNode({ currentCluster, annotations });
+
+        expect([node.cpuUsage, node.ramUsage]).toStrictEqual([3, 6 * 1024 ** 3]);
+      });
+    });
+
     it('should sort by the CPU and memory usage out of the capacity', () => {
       const node = createNode({ metrics: { usage: { cpu: '1', memory: '2Gi' } } });
 
diff --git a/shell/models/cluster/node.js b/shell/models/cluster/node.js
index bb5402670..97ba6bb41 100644
--- a/shell/models/cluster/node.js
+++ b/shell/models/cluster/node.js
@@ -185,16 +185,23 @@ export default class ClusterNode extends SteveModel {
     return this.status.nodeInfo.kubeletVersion;
   }
 
-  get cpuUsage() {
-    /*
-      With EKS nodes that have been migrated from norman,
-      cpu/memory usage is by the annotation `management.cattle.io/pod-requests`
-    */
-    if ( this.isFromNorman && this.provider === 'eks' ) {
-      return parseSi(this.podRequests.cpu || '0');
+  /**
+   * The usage of the whole node, which it only has with metrics, e.g. not without a metrics server or when the node isn't reporting.
+   *
+   * EKS clusters created through Norman might not have a metrics server, so there it falls back to what the pods request
+   */
+  get usage() {
+    const usage = this.$rootGetters['cluster/byId'](METRIC.NODE, this.id)?.usage;
+
+    if ( !usage && this.isFromNorman && this.provider === 'eks' ) {
+      return this.podRequests;
     }
 
-    return parseSi(this.$rootGetters['cluster/byId'](METRIC.NODE, this.id)?.usage?.cpu || '0');
+    return usage;
+  }
+
+  get cpuUsage() {
+    return parseSi(this.usage?.cpu || '0');
   }
 
   get cpuAllocatable() {
@@ -221,11 +228,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get ramUsage() {
-    if ( this.isFromNorman && this.provider === 'eks' ) {
-      return parseSi(this.podRequests.memory || '0');
-    }
-
-    return parseSi(this.$rootGetters['cluster/byId'](METRIC.NODE, this.id)?.usage?.memory || '0');
+    return parseSi(this.usage?.memory || '0');
   }
 
   get ramCapacity() {
@@ -322,15 +325,13 @@ export default class ClusterNode extends SteveModel {
       return false;
     }
 
-    const roles = [NODE_ROLES.ETCD, NODE_ROLES.CONTROL_PLANE, NODE_ROLES.CONTROL_PLANE_OLD, NODE_ROLES.WORKER];
-    const isWorker = NODE_ROLES.WORKER in this.labels || !roles.some((role) => role in this.labels);
+    const serverRoles = [NODE_ROLES.ETCD, NODE_ROLES.CONTROL_PLANE, NODE_ROLES.CONTROL_PLANE_OLD];
+    const isWorker = NODE_ROLES.WORKER in this.labels || !serverRoles.some((role) => role in this.labels);
 
     if (isWorker) {
       return true;
     }
 
-    const serverRoles = [NODE_ROLES.ETCD, NODE_ROLES.CONTROL_PLANE, NODE_ROLES.CONTROL_PLANE_OLD];
-
     return !(this.spec.taints || []).some((taint) => serverRoles.includes(taint.key) && ['NoSchedule', 'NoExecute'].includes(taint.effect));
   }
 
diff --git a/shell/pages/c/_cluster/explorer/__tests__/index.test.ts b/shell/pages/c/_cluster/explorer/__tests__/index.test.ts
index abb045ecc..4c7d33f50 100644
--- a/shell/pages/c/_cluster/explorer/__tests__/index.test.ts
+++ b/shell/pages/c/_cluster/explorer/__tests__/index.test.ts
@@ -348,7 +348,9 @@ describe('page: cluster dashboard', () => {
       { id: 'cordoned', usage: { cpu: '50', memory: '100Gi' } },
     ];
 
-    const createWrapper = ({ nodes = [node('counted-1', true), node('counted-2', true), node('cordoned', false, 25)], canListNodes = true, nodesLoaded = true } = {}) => {
+    const createWrapper = ({
+      nodes = [node('counted-1', true), node('counted-2', true), node('cordoned', false, 25)], canListNodes = true, nodesLoaded = true, nodeMetrics = metrics
+    } = {}) => {
       const options = createMountOptions();
       const { getters } = options.global.mocks.$store;
 
@@ -365,7 +367,7 @@ describe('page: cluster dashboard', () => {
           cpu: '2', memory: '4Gi', pods: '20'
         },
       };
-      options.global.mocks.$store.dispatch = jest.fn((action: string, { type }: { type?: string } = {}) => Promise.resolve(action === 'cluster/findAll' && type === METRIC.NODE ? metrics : []));
+      options.global.mocks.$store.dispatch = jest.fn((action: string, { type }: { type?: string } = {}) => Promise.resolve(action === 'cluster/findAll' && type === METRIC.NODE ? nodeMetrics : []));
 
       return shallowMount(Dashboard, options);
     };
@@ -379,6 +381,51 @@ describe('page: cluster dashboard', () => {
       expect([wrapper.vm.ramUsed?.total, wrapper.vm.ramUsed?.useful]).toStrictEqual([16, 2]);
     });
 
+    describe('when a counted node has no metrics', () => {
+      const nodeMetrics = metrics.filter(({ id }) => id !== 'counted-2');
+
+      it('should work out used only out of the capacity of the nodes that have them', async() => {
+        const wrapper = createWrapper({ nodeMetrics });
+
+        await flushPromises();
+
+        expect([wrapper.vm.cpuUsed?.total, wrapper.vm.cpuUsed?.useful]).toStrictEqual([4, 0.5]);
+        expect([wrapper.vm.ramUsed?.total, wrapper.vm.ramUsed?.useful]).toStrictEqual([8, 1]);
+      });
+
+      it('should still work out reserved over every counted node', async() => {
+        const wrapper = createWrapper({ nodeMetrics });
+
+        await flushPromises();
+
+        expect([wrapper.vm.cpuReserved.total, wrapper.vm.cpuReserved.useful]).toStrictEqual([6, 2]);
+      });
+
+      it('should say that used does not cover every node', async() => {
+        const wrapper = createWrapper({ nodeMetrics });
+
+        await flushPromises();
+
+        expect(wrapper.find('[data-testid="capacity-reporting-nodes"]').exists()).toBe(true);
+      });
+    });
+
+    it('should not say that used does not cover every node when they all have metrics', async() => {
+      const wrapper = createWrapper();
+
+      await flushPromises();
+
+      expect(wrapper.find('[data-testid="capacity-reporting-nodes"]').exists()).toBe(false);
+    });
+
+    it('should not show used when no counted node has metrics', async() => {
+      const wrapper = createWrapper({ nodeMetrics: [] });
+
+      await flushPromises();
+
+      expect([wrapper.vm.cpuUsed, wrapper.vm.ramUsed]).toStrictEqual([null, null]);
+    });
+
     it('should work out reserved as the requests of the counted nodes out of their allocatable', async() => {
       const wrapper = createWrapper();
 
diff --git a/shell/pages/c/_cluster/explorer/index.vue b/shell/pages/c/_cluster/explorer/index.vue
index 77da11039..76f15e182 100644
--- a/shell/pages/c/_cluster/explorer/index.vue
+++ b/shell/pages/c/_cluster/explorer/index.vue
@@ -34,7 +34,6 @@ import { allDashboardsExist } from '@shell/utils/grafana';
 import EtcdInfoBanner from '@shell/components/EtcdInfoBanner';
 import metricPoller from '@shell/mixins/metric-poller';
 import HardwareResourceGauge from '@shell/components/HardwareResourceGauge';
-import { isEmpty } from '@shell/utils/object';
 import ConfigBadge from './ConfigBadge';
 import EventsTable from './EventsTable';
 import ResourceStatusCards from './resource-status/ResourceStatusCards.vue';
@@ -320,10 +319,8 @@ export default {
 
     nodeStats() {
       const initialAggregation = {
-        cpuCapacity:    0,
         cpuAllocatable: 0,
         cpuReserved:    0,
-        ramCapacity:    0,
         ramAllocatable: 0,
         ramReserved:    0,
         podAllocatable: 0,
@@ -331,10 +328,8 @@ export default {
       };
 
       return this.countedNodes.reduce((agg, node) => {
-        agg.cpuCapacity += node.cpuCapacity;
         agg.cpuAllocatable += node.cpuAllocatable;
         agg.cpuReserved += node.cpuReserved;
-        agg.ramCapacity += node.ramCapacity;
         agg.ramAllocatable += node.ramAllocatable;
         agg.ramReserved += node.ramReserved;
         agg.podAllocatable += node.podAllocatable;
@@ -385,31 +380,38 @@ export default {
     },
 
     /**
-     * The usage of the counted nodes. Without the nodes the metrics can't be matched to the nodes the cluster's status is summed over,
-     * so there's no usage
+     * The usage of the counted nodes that have metrics, and the capacity of those same nodes, so a node without metrics doesn't make
+     * the others look less used. Without the nodes the metrics can't be matched to the nodes the cluster's status is summed over, so
+     * there's no usage
      */
     metricAggregations() {
       if (!this.haveNodes) {
         return null;
       }
 
-      const metrics = this.nodeMetrics.filter((nodeMetrics) => this.countedNodes.some((node) => node.id === nodeMetrics.id));
-
       const initialAggregation = {
-        cpu:    0,
-        memory: 0
+        cpu:         0,
+        memory:      0,
+        cpuCapacity: 0,
+        ramCapacity: 0,
+        nodes:       0,
       };
 
-      if (isEmpty(metrics)) {
-        return null;
-      }
+      const aggregation = this.countedNodes.reduce((agg, node) => {
+        const metrics = this.nodeMetrics.find((nodeMetrics) => nodeMetrics.id === node.id);
 
-      return metrics.reduce((agg, metric) => {
-        agg.cpu += parseSi(metric.usage.cpu);
-        agg.memory += parseSi(metric.usage.memory);
+        if (metrics) {
+          agg.cpu += parseSi(metrics.usage.cpu);
+          agg.memory += parseSi(metrics.usage.memory);
+          agg.cpuCapacity += node.cpuCapacity;
+          agg.ramCapacity += node.ramCapacity;
+          agg.nodes++;
+        }
 
         return agg;
       }, initialAggregation);
+
+      return aggregation.nodes ? aggregation : null;
     },
 
     /**
@@ -421,7 +423,7 @@ export default {
         return null;
       }
 
-      const total = this.nodeStats.cpuCapacity;
+      const total = this.metricAggregations.cpuCapacity;
 
       return {
         total,
@@ -435,7 +437,7 @@ export default {
         return null;
       }
 
-      return createMemoryValues(this.nodeStats.ramCapacity, this.metricAggregations.memory);
+      return createMemoryValues(this.metricAggregations.ramCapacity, this.metricAggregations.memory);
     },
 
     hasMonitoring() {
@@ -718,6 +720,13 @@ export default {
       >
         {{ t('clusterIndexPage.sections.capacity.countedNodes', { counted: countedNodes.length, total: nodes.length }, true) }}
       </span>
+      <span
+        v-if="metricAggregations && metricAggregations.nodes < countedNodes.length"
+        class="counted-nodes text-muted"
+        data-testid="capacity-reporting-nodes"
+      >
+        {{ t('clusterIndexPage.sections.capacity.reportingNodes', { reporting: metricAggregations.nodes, counted: countedNodes.length }) }}
+      </span>
     </h3>
     <div
       v-if="hasStats"
@@ -731,12 +740,16 @@ export default {
         :name="t('clusterIndexPage.hardwareResourceGauge.cores')"
         :reserved="cpuReserved"
         :used="cpuUsed"
+        :used-tooltip="t('clusterIndexPage.hardwareResourceGauge.usedTooltip')"
+        :reserved-tooltip="t('clusterIndexPage.hardwareResourceGauge.reservedTooltip')"
         :units="cpuReserved.units"
       />
       <HardwareResourceGauge
         :name="t('clusterIndexPage.hardwareResourceGauge.ram')"
         :reserved="ramReserved"
         :used="ramUsed"
+        :used-tooltip="t('clusterIndexPage.hardwareResourceGauge.usedTooltip')"
+        :reserved-tooltip="t('clusterIndexPage.hardwareResourceGauge.reservedTooltip')"
         :units="ramReserved.units"
       />
     </div>