diff --git a/locales/en/public.json b/locales/en/public.json
index 44c2e82d7..9951ad069 100644
--- a/locales/en/public.json
+++ b/locales/en/public.json
@@ -365,7 +365,8 @@
     "DATETIME": "Date and Time"
   },
   "Diagnostics": {
-    "TARGET_THREAD_DUMPS_TAB_TITLE": "Targets"
+    "TARGET_THREAD_DUMPS_TAB_TITLE": "Targets",
+    "TARGET_HEAP_DUMPS_TAB_TITLE": "Targets"
   },
   "DiagnosticsCard": {
     "DIAGNOSTICS_ACTION_FAILURE": "Diagnostics Failure: {{kind}}",
@@ -373,12 +374,24 @@
     "DIAGNOSTICS_CARD_DESCRIPTION_FULL": "Perform diagonstic operations from a list of supported operations on the target.",
     "DIAGNOSTICS_CARD_TITLE": "Diagnostics",
     "DIAGNOSTICS_GC_BUTTON": "Invoke Garbage Collection",
+    "DIAGNOSTICS_HEAP_DUMP_BUTTON": "Invoke Heap Dump",
+    "DIAGNOSTICS_HEAP_REDIRECT_BUTTON": "View collected Heap Dumps",
     "DIAGNOSTICS_THREAD_DUMP_BUTTON": "Invoke Thread Dump",
     "DIAGNOSTICS_THREAD_DUMP_TABLE_TOOLTIP": "View captured Thread Dumps",
     "DIAGONSTICS_THREAD_REDIRECT_BUTTON": "View collected Thread Dumps",
     "KINDS": {
       "GC": "Garbage Collection",
-      "THREAD_DUMP": "Thread Dump"
+      "HEAP_DUMP": "Heap Dump",
+      "THREADS": "Thread Dump"
+    }
+  },
+  "HeapDumps": {
+    "SEARCH_PLACEHOLDER": "Search Heap Dumps",
+    "DELETION_FAILURE_CATEGORY": "Heap Dump Deletion Failure",
+    "DELETION_FAILURE_MESSAGE": "No Heap Dump to delete.",
+    "ARIA_LABELS": {
+      "ROW_ACTION": "heap-dump-action-menu",
+      "SEARCH_INPUT": "heap-dump-search-input"
     }
   },
   "ThreadDumps": {
diff --git a/src/app/Dashboard/Diagnostics/DiagnosticsCard.tsx b/src/app/Dashboard/Diagnostics/DiagnosticsCard.tsx
index 21f7c6326..d22286e4c 100644
--- a/src/app/Dashboard/Diagnostics/DiagnosticsCard.tsx
+++ b/src/app/Dashboard/Diagnostics/DiagnosticsCard.tsx
@@ -58,7 +58,18 @@ export const DiagnosticsCard: DashboardCardFC<DiagnosticsCardProps> = (props) =>
   const notifications = React.useContext(NotificationsContext);
   const addSubscription = useSubscriptions();
   const [running, setRunning] = React.useState(false);
+  const [heapDumpReady, setHeapDumpReady] = React.useState(false);
   const [threadDumpReady, setThreadDumpReady] = React.useState(false);
+  const [controlEnabled, setControlEnabled] = React.useState(false);
+
+  React.useEffect(() => {
+    addSubscription(
+      serviceContext.target.target().subscribe({
+        next: (target) => setControlEnabled(target != null ? target.agent : false),
+        error: () => setControlEnabled(false),
+      }),
+    );
+  }, [addSubscription, serviceContext, setControlEnabled]);
 
   const handleError = React.useCallback(
     (kind, error) => {
@@ -83,6 +94,30 @@ export const DiagnosticsCard: DashboardCardFC<DiagnosticsCardProps> = (props) =>
     );
   }, [addSubscription, serviceContext.api, serviceContext.target, setThreadDumpReady]);
 
+  React.useEffect(() => {
+    addSubscription(
+      serviceContext.target
+        .target()
+        .pipe(
+          filter((target) => !!target),
+          first(),
+          concatMap(() => serviceContext.api.getHeapDumps()),
+        )
+        .subscribe({
+          next: (dumps) => (dumps.length > 0 ? setHeapDumpReady(true) : setHeapDumpReady(false)),
+          error: () => setHeapDumpReady(false),
+        }),
+    );
+  }, [addSubscription, serviceContext.api, serviceContext.target, setHeapDumpReady]);
+
+  React.useEffect(() => {
+    addSubscription(
+      serviceContext.notificationChannel.messages(NotificationCategory.HeapDumpUploaded).subscribe(() => {
+        setHeapDumpReady(true);
+      }),
+    );
+  }, [addSubscription, serviceContext.notificationChannel, setHeapDumpReady]);
+
   React.useEffect(() => {
     addSubscription(
       serviceContext.notificationChannel.messages(NotificationCategory.ThreadDumpSuccess).subscribe(() => {
@@ -114,6 +149,18 @@ export const DiagnosticsCard: DashboardCardFC<DiagnosticsCardProps> = (props) =>
     );
   }, [addSubscription, serviceContext.api, handleError, setRunning, t]);
 
+  const handleHeapDump = React.useCallback(() => {
+    setRunning(true);
+    addSubscription(
+      serviceContext.api.runHeapDump(true).subscribe({
+        error: (err) => handleError(t('DiagnosticsCard.KINDS.HEAP_DUMP'), err),
+        complete: () => {
+          setRunning(false);
+        },
+      }),
+    );
+  }, [addSubscription, serviceContext.api, handleError, setRunning, t]);
+
   const header = React.useMemo(() => {
     return (
       <CardHeader actions={{ actions: <>{...props.actions || []}</>, hasNoOffset: false, className: undefined }}>
@@ -181,6 +228,30 @@ export const DiagnosticsCard: DashboardCardFC<DiagnosticsCardProps> = (props) =>
                       </ActionList>
                     </FeatureFlag>
                   </StackItem>
+                  <StackItem>
+                    <FeatureFlag level={FeatureLevel.BETA}>
+                      <ActionList>
+                        <Button
+                          variant="primary"
+                          onClick={handleHeapDump}
+                          isAriaDisabled={!controlEnabled}
+                          spinnerAriaValueText="Invoke Heap Dump"
+                          spinnerAriaLabel="invoke-heap-dump"
+                          isLoading={running}
+                        >
+                          {t('DiagnosticsCard.DIAGNOSTICS_HEAP_DUMP_BUTTON')}
+                        </Button>
+                        <Tooltip content={t('DiagnosticsCard.DIAGNOSTICS_HEAP_REDIRECT_BUTTON')}>
+                          <Button
+                            variant="primary"
+                            isAriaDisabled={!(heapDumpReady && controlEnabled)}
+                            component={(props) => <CryostatLink {...props} to="/heapdumps" />}
+                            icon={<ListIcon />}
+                          />
+                        </Tooltip>
+                      </ActionList>
+                    </FeatureFlag>
+                  </StackItem>
                 </Stack>
               </EmptyStateFooter>
             </EmptyState>
diff --git a/src/app/Diagnostics/AnalyzeHeapDumps.tsx b/src/app/Diagnostics/AnalyzeHeapDumps.tsx
new file mode 100644
index 000000000..90f2fd094
--- /dev/null
+++ b/src/app/Diagnostics/AnalyzeHeapDumps.tsx
@@ -0,0 +1,94 @@
+/*
+ * Copyright The Cryostat Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BreadcrumbPage } from '@app/BreadcrumbPage/BreadcrumbPage';
+import { NullableTarget } from '@app/Shared/Services/api.types';
+import { ServiceContext } from '@app/Shared/Services/Services';
+import { NoTargetSelected } from '@app/TargetView/NoTargetSelected';
+import { TargetContextSelector } from '@app/TargetView/TargetContextSelector';
+import { useSubscriptions } from '@app/utils/hooks/useSubscriptions';
+import { getActiveTab, switchTab } from '@app/utils/utils';
+import { Card, CardBody, Stack, StackItem, Tab, Tabs, TabTitleText } from '@patternfly/react-core';
+import { t } from 'i18next';
+import * as React from 'react';
+import { useLocation, useNavigate } from 'react-router-dom-v5-compat';
+import { HeapDumpsTable } from './HeapDumpsTable';
+
+export interface AnalyzeHeapDumpsProps {}
+
+enum AnalyzeHeapDumpsTab {
+  HEAP_DUMPS = 'target-heap-dumps',
+}
+
+export const AnalyzeHeapDumps: React.FC<AnalyzeHeapDumpsProps> = ({ ...props }) => {
+  const { search, pathname } = useLocation();
+  const navigate = useNavigate();
+  const context = React.useContext(ServiceContext);
+  const addSubscription = useSubscriptions();
+
+  const [target, setTarget] = React.useState(undefined as NullableTarget);
+
+  React.useEffect(() => {
+    addSubscription(context.target.target().subscribe((t) => setTarget(t)));
+  }, [addSubscription, context.target, setTarget]);
+
+  const activeTab = React.useMemo(() => {
+    return getActiveTab(search, 'tab', Object.values(AnalyzeHeapDumpsTab), AnalyzeHeapDumpsTab.HEAP_DUMPS);
+  }, [search]);
+
+  const onTabSelect = React.useCallback(
+    (_: React.MouseEvent, key: string | number) =>
+      switchTab(navigate, pathname, search, { tabKey: 'tab', tabValue: `${key}` }),
+    [navigate, pathname, search],
+  );
+
+  const cardBody = React.useMemo(
+    () => (
+      <Tabs id="heapDumps" activeKey={activeTab} onSelect={onTabSelect} unmountOnExit>
+        <Tab
+          id="heapDumps"
+          eventKey={AnalyzeHeapDumpsTab.HEAP_DUMPS}
+          title={<TabTitleText>{t('Diagnostics.TARGET_HEAP_DUMPS_TAB_TITLE')}</TabTitleText>}
+          data-quickstart-id="heap-dumps-tab"
+        >
+          <Stack hasGutter>
+            <StackItem>
+              <TargetContextSelector />
+            </StackItem>
+            <StackItem>
+              {target ? (
+                <HeapDumpsTable />
+              ) : (
+                // FIXME this should be an "AllTargetsHeapDumpsTable" like the AllTargetsArchivedRecordingsTable
+                <NoTargetSelected />
+              )}
+            </StackItem>
+          </Stack>
+        </Tab>
+      </Tabs>
+    ),
+    [activeTab, onTabSelect, target],
+  );
+
+  return (
+    <BreadcrumbPage {...props} pageTitle="Heap Dumps">
+      <Card isFullHeight>
+        <CardBody isFilled>{cardBody}</CardBody>
+      </Card>
+    </BreadcrumbPage>
+  );
+};
+
+export default AnalyzeHeapDumps;
diff --git a/src/app/Diagnostics/CaptureDiagnostics.tsx b/src/app/Diagnostics/CaptureDiagnostics.tsx
index 9edf82a6e..3d89eb1ac 100644
--- a/src/app/Diagnostics/CaptureDiagnostics.tsx
+++ b/src/app/Diagnostics/CaptureDiagnostics.tsx
@@ -46,6 +46,17 @@ export const CaptureDiagnostics: React.FC<CaptureDiagnosticsProps> = ({ ...props
   const addSubscription = useSubscriptions();
   const [running, setRunning] = React.useState(false);
   const [threadDumpReady, setThreadDumpReady] = React.useState(false);
+  const [heapDumpReady, setHeapDumpReady] = React.useState(false);
+  const [controlEnabled, setControlEnabled] = React.useState(false);
+
+  React.useEffect(() => {
+    addSubscription(
+      serviceContext.target.target().subscribe({
+        next: (target) => setControlEnabled(target != null ? target.agent : false),
+        error: () => setControlEnabled(false),
+      }),
+    );
+  }, [addSubscription, serviceContext, setControlEnabled]);
 
   const handleError = React.useCallback(
     (kind, error) => {
@@ -71,6 +82,22 @@ export const CaptureDiagnostics: React.FC<CaptureDiagnosticsProps> = ({ ...props
     );
   }, [addSubscription, serviceContext.api, serviceContext.target, setThreadDumpReady]);
 
+  React.useEffect(() => {
+    addSubscription(
+      serviceContext.target
+        .target()
+        .pipe(
+          filter((target) => !!target),
+          first(),
+          concatMap(() => serviceContext.api.getHeapDumps()),
+        )
+        .subscribe({
+          next: (dumps) => (dumps.length > 0 ? setHeapDumpReady(true) : setThreadDumpReady(false)),
+          error: () => setHeapDumpReady(false),
+        }),
+    );
+  }, [addSubscription, serviceContext.api, serviceContext.target, setHeapDumpReady]);
+
   React.useEffect(() => {
     addSubscription(
       serviceContext.notificationChannel.messages(NotificationCategory.ThreadDumpSuccess).subscribe(() => {
@@ -102,6 +129,19 @@ export const CaptureDiagnostics: React.FC<CaptureDiagnosticsProps> = ({ ...props
     );
   }, [addSubscription, serviceContext.api, handleError, setRunning, t]);
 
+  const handleHeapDump = React.useCallback(() => {
+    setRunning(true);
+    addSubscription(
+      serviceContext.api.runHeapDump(true).subscribe({
+        error: (err) => handleError(t('DiagnosticsCard.KINDS.HEAP_DUMP'), err),
+        complete: () => {
+          setRunning(false);
+          setHeapDumpReady(true);
+        },
+      }),
+    );
+  }, [addSubscription, serviceContext.api, handleError, setRunning, t]);
+
   return (
     <TargetView {...props} pageTitle="Diagnostics">
       <Grid hasGutter>
@@ -144,6 +184,28 @@ export const CaptureDiagnostics: React.FC<CaptureDiagnosticsProps> = ({ ...props
                       </Tooltip>
                     </ActionList>
                   </StackItem>
+                  <StackItem>
+                    <ActionList>
+                      <Button
+                        variant="primary"
+                        isAriaDisabled={!controlEnabled}
+                        onClick={handleHeapDump}
+                        spinnerAriaValueText="Invoke Heap Dump"
+                        spinnerAriaLabel="invoke-heap-dump"
+                        isLoading={running}
+                      >
+                        {t('DiagnosticsCard.DIAGNOSTICS_HEAP_DUMP_BUTTON')}
+                      </Button>
+                      <Tooltip content={t('DiagnosticsCard.DIAGNOSTICS_HEAP_REDIRECT_BUTTON')}>
+                        <Button
+                          variant="primary"
+                          isAriaDisabled={!heapDumpReady}
+                          component={(props) => <CryostatLink {...props} to="/heapdumps" />}
+                          icon={<ListIcon />}
+                        />
+                      </Tooltip>
+                    </ActionList>
+                  </StackItem>
                 </Stack>
               </Bullseye>
             </CardBody>
diff --git a/src/app/Diagnostics/HeapDumpsTable.tsx b/src/app/Diagnostics/HeapDumpsTable.tsx
new file mode 100644
index 000000000..07e3814ae
--- /dev/null
+++ b/src/app/Diagnostics/HeapDumpsTable.tsx
@@ -0,0 +1,411 @@
+/*
+ * Copyright The Cryostat Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ErrorView } from '@app/ErrorView/ErrorView';
+import { DeleteWarningModal } from '@app/Modal/DeleteWarningModal';
+import { DeleteOrDisableWarningType } from '@app/Modal/types';
+import { LoadingView } from '@app/Shared/Components/LoadingView';
+import { NotificationCategory, HeapDump } from '@app/Shared/Services/api.types';
+import { NotificationsContext } from '@app/Shared/Services/Notifications.service';
+import { ServiceContext } from '@app/Shared/Services/Services';
+import useDayjs from '@app/utils/hooks/useDayjs';
+import { useSubscriptions } from '@app/utils/hooks/useSubscriptions';
+import { TableColumn, formatBytes, sortResources } from '@app/utils/utils';
+import { useCryostatTranslation } from '@i18n/i18nextUtil';
+import {
+  EmptyState,
+  EmptyStateIcon,
+  Stack,
+  StackItem,
+  Toolbar,
+  ToolbarContent,
+  ToolbarGroup,
+  ToolbarItem,
+  EmptyStateHeader,
+  Dropdown,
+  DropdownItem,
+  DropdownList,
+  MenuToggleElement,
+  MenuToggle,
+  SearchInput,
+  Timestamp,
+  TimestampTooltipVariant,
+  Divider,
+} from '@patternfly/react-core';
+import { SearchIcon, EllipsisVIcon } from '@patternfly/react-icons';
+import {
+  ISortBy,
+  SortByDirection,
+  Table,
+  TableVariant,
+  Tbody,
+  Td,
+  Th,
+  Thead,
+  ThProps,
+  Tr,
+} from '@patternfly/react-table';
+import _ from 'lodash';
+import * as React from 'react';
+
+const tableColumns: TableColumn[] = [
+  {
+    title: 'ID',
+    keyPaths: ['id'],
+    sortable: true,
+  },
+  {
+    title: 'Last Modified',
+    keyPaths: ['lastModified'],
+    sortable: true,
+  },
+  {
+    title: 'Size',
+    keyPaths: ['size'],
+    sortable: true,
+  },
+];
+
+export interface HeapDumpsProps {}
+
+export const HeapDumpsTable: React.FC<HeapDumpsProps> = ({}) => {
+  const context = React.useContext(ServiceContext);
+  const { t } = useCryostatTranslation();
+  const addSubscription = useSubscriptions();
+  const notificationsContext = React.useContext(NotificationsContext);
+
+  const [heapDumps, setHeapDumps] = React.useState<HeapDump[]>([]);
+  const [filteredHeapDumps, setFilteredHeapDumps] = React.useState<HeapDump[]>([]);
+  const [filterText, setFilterText] = React.useState('');
+  const [sortBy, setSortBy] = React.useState<ISortBy>({});
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [errorMessage, setErrorMessage] = React.useState('');
+  const [heapDumpToDelete, setHeapDumpToDelete] = React.useState<HeapDump | undefined>(undefined);
+  const [warningModalOpen, setWarningModalOpen] = React.useState(false);
+  const [dayjs, datetimeContext] = useDayjs();
+
+  const getSortParams = React.useCallback(
+    (columnIndex: number): ThProps['sort'] => ({
+      sortBy: sortBy,
+      onSort: (_event, index, direction) => {
+        setSortBy({
+          index: index,
+          direction: direction,
+        });
+      },
+      columnIndex,
+    }),
+    [sortBy, setSortBy],
+  );
+
+  const handleHeapDumps = React.useCallback(
+    (heapDumps: HeapDump[]) => {
+      setHeapDumps(heapDumps);
+      setIsLoading(false);
+      setErrorMessage('');
+    },
+    [setHeapDumps, setIsLoading, setErrorMessage],
+  );
+
+  const handleError = React.useCallback(
+    (error) => {
+      setIsLoading(false);
+      setErrorMessage(error.message);
+    },
+    [setIsLoading, setErrorMessage],
+  );
+
+  const refreshHeapDumps = React.useCallback(() => {
+    setIsLoading(true);
+    addSubscription(
+      context.api.getHeapDumps().subscribe({
+        next: (value) => handleHeapDumps(value),
+        error: (err) => handleError(err),
+      }),
+    );
+  }, [addSubscription, context.api, setIsLoading, handleHeapDumps, handleError]);
+
+  const handleDelete = React.useCallback(
+    (heapDump: HeapDump) => {
+      addSubscription(
+        context.api.deleteHeapDump(heapDump.heapDumpId).subscribe(() => {
+          // Do nothing, leave it to the notification handler.
+        }),
+      );
+    },
+    [addSubscription, context.api],
+  );
+
+  React.useEffect(() => {
+    addSubscription(
+      context.notificationChannel.messages(NotificationCategory.HeapDumpDeleted).subscribe((msg) => {
+        setHeapDumps((old) => old.filter((t) => t.heapDumpId !== msg.message.heapDumpId));
+      }),
+    );
+  }, [addSubscription, context.notificationChannel, refreshHeapDumps]);
+
+  const handleWarningModalAccept = React.useCallback(() => {
+    if (heapDumpToDelete) {
+      handleDelete(heapDumpToDelete);
+    } else {
+      notificationsContext.warning(t('HeapDumps.DELETION_FAILURE_CATEGORY'), t('HeapDumps.DELETION_FAILURE_MESSAGE'));
+    }
+  }, [handleDelete, notificationsContext, t, heapDumpToDelete]);
+
+  const handleWarningModalClose = React.useCallback(() => {
+    setWarningModalOpen(false);
+  }, [setWarningModalOpen]);
+
+  const handleFilterTextChange = React.useCallback((_, value: string) => setFilterText(value), [setFilterText]);
+
+  React.useEffect(() => {
+    addSubscription(
+      context.notificationChannel.messages(NotificationCategory.HeapDumpUploaded).subscribe(() => {
+        refreshHeapDumps();
+      }),
+    );
+  }, [addSubscription, context.notificationChannel, refreshHeapDumps]);
+
+  React.useEffect(() => {
+    addSubscription(
+      context.target.target().subscribe(() => {
+        setFilterText('');
+        refreshHeapDumps();
+      }),
+    );
+  }, [context.target, addSubscription, refreshHeapDumps]);
+
+  React.useEffect(() => {
+    if (!context.settings.autoRefreshEnabled()) {
+      return;
+    }
+    const id = window.setInterval(
+      () => refreshHeapDumps(),
+      context.settings.autoRefreshPeriod() * context.settings.autoRefreshUnits(),
+    );
+    return () => window.clearInterval(id);
+  }, [context.settings, refreshHeapDumps]);
+
+  React.useEffect(() => {
+    let filtered: HeapDump[];
+    if (!filterText) {
+      filtered = heapDumps;
+    } else {
+      const reg = new RegExp(_.escapeRegExp(filterText), 'i');
+      filtered = heapDumps.filter((t: HeapDump) => reg.test(t.heapDumpId));
+    }
+
+    setFilteredHeapDumps(
+      sortResources(
+        {
+          index: sortBy.index ?? 0,
+          direction: sortBy.direction ?? SortByDirection.asc,
+        },
+        filtered,
+        tableColumns,
+      ),
+    );
+  }, [filterText, heapDumps, sortBy, setFilteredHeapDumps]);
+
+  const handleDeleteAction = React.useCallback(
+    (heapDump: HeapDump) => {
+      if (context.settings.deletionDialogsEnabledFor(DeleteOrDisableWarningType.DeleteHeapDump)) {
+        setHeapDumpToDelete(heapDump);
+        setWarningModalOpen(true);
+      } else {
+        handleDelete(heapDump);
+      }
+    },
+    [context.settings, setWarningModalOpen, setHeapDumpToDelete, handleDelete],
+  );
+
+  const handleDownloadHeapDump = React.useCallback(
+    (heapDump) => {
+      context.api.downloadHeapDump(heapDump);
+    },
+    [context.api],
+  );
+
+  const deleteHeapDumpModal = React.useMemo(() => {
+    return (
+      <DeleteWarningModal
+        warningType={DeleteOrDisableWarningType.DeleteHeapDump}
+        visible={warningModalOpen}
+        onAccept={handleWarningModalAccept}
+        onClose={handleWarningModalClose}
+      />
+    );
+  }, [warningModalOpen, handleWarningModalAccept, handleWarningModalClose]);
+
+  const heapDumpRows = React.useMemo(
+    () =>
+      filteredHeapDumps.map((t: HeapDump, index) => {
+        return (
+          <Tr key={`heap-dump-${index}`}>
+            <Td key={`heap-dump-id-${index}`} dataLabel={tableColumns[0].title}>
+              {t.heapDumpId}
+            </Td>
+            <Td key={`heap-dump-lastModified-${index}`} dataLabel={tableColumns[1].title}>
+              <Timestamp
+                className="heap-dump-table__timestamp"
+                tooltip={{ variant: TimestampTooltipVariant.custom, content: dayjs(t.lastModified).toISOString() }}
+              >
+                {dayjs(t.lastModified).tz(datetimeContext.timeZone.full).format('L LTS z')}
+              </Timestamp>
+            </Td>
+            <Td key={`heap-dump-size-${index}`} dataLabel={tableColumns[2].title}>
+              {formatBytes(t.size ?? 0)}
+            </Td>
+            <Td key={`heap-dump-action-${index}`} isActionCell style={{ paddingRight: '0' }}>
+              <HeapDumpAction heapDump={t} onDelete={handleDeleteAction} onDownload={handleDownloadHeapDump} />
+            </Td>
+          </Tr>
+        );
+      }),
+    [datetimeContext.timeZone.full, dayjs, filteredHeapDumps, handleDeleteAction, handleDownloadHeapDump],
+  );
+
+  if (errorMessage != '') {
+    return <ErrorView title={'Error retrieving heap dumps'} message={`${errorMessage}`} />;
+  } else if (isLoading) {
+    return <LoadingView />;
+  } else {
+    return (
+      <Stack hasGutter style={{ marginTop: '1em' }}>
+        <StackItem>
+          <Toolbar id="heap-dumps-toolbar">
+            <ToolbarContent>
+              <ToolbarGroup variant="filter-group">
+                <ToolbarItem>
+                  <SearchInput
+                    style={{ minWidth: '30ch' }}
+                    name="heapDumpsFilter"
+                    id="heapDumpsFilter"
+                    type="search"
+                    placeholder={t('HeapDumps.SEARCH_PLACEHOLDER')}
+                    aria-label={t('HeapDumps.ARIA_LABELS.SEARCH_INPUT')}
+                    onChange={handleFilterTextChange}
+                    value={filterText}
+                  />
+                </ToolbarItem>
+              </ToolbarGroup>
+              {deleteHeapDumpModal}
+            </ToolbarContent>
+          </Toolbar>
+          {heapDumpRows.length ? (
+            <Table aria-label="Heap Dumps table" variant={TableVariant.compact}>
+              <Thead>
+                <Tr>
+                  {tableColumns.map(({ title, sortable }, index) => (
+                    <Th key={`heap-dump-header-${title}`} sort={sortable ? getSortParams(index) : undefined}>
+                      {title}
+                    </Th>
+                  ))}
+                </Tr>
+              </Thead>
+              <Tbody>{heapDumpRows}</Tbody>
+            </Table>
+          ) : (
+            <EmptyState>
+              <EmptyStateHeader
+                titleText="No Heap Dumps"
+                icon={<EmptyStateIcon icon={SearchIcon} />}
+                headingLevel="h4"
+              />
+            </EmptyState>
+          )}
+        </StackItem>
+      </Stack>
+    );
+  }
+};
+
+export interface HeapDumpActionProps {
+  heapDump: HeapDump;
+  onDownload: (heapDump: HeapDump) => void;
+  onDelete: (heapDump: HeapDump) => void;
+}
+
+export const HeapDumpAction: React.FC<HeapDumpActionProps> = ({ heapDump, onDelete, onDownload }) => {
+  const { t } = useCryostatTranslation();
+  const [isOpen, setIsOpen] = React.useState(false);
+
+  const actionItems = React.useMemo(() => {
+    return [
+      {
+        title: 'Download',
+        key: 'download-heapdump',
+        onClick: () => onDownload(heapDump),
+      },
+      {
+        isSeparator: true,
+      },
+      {
+        key: 'delete-heapdump',
+        title: 'Delete',
+        isDanger: true,
+        onClick: () => onDelete(heapDump),
+      },
+    ];
+  }, [onDelete, onDownload, heapDump]);
+
+  const handleToggle = React.useCallback((_, opened: boolean) => setIsOpen(opened), [setIsOpen]);
+
+  const dropdownItems = React.useMemo(
+    () =>
+      actionItems.map((action, idx) =>
+        action.isSeparator ? (
+          <Divider key={`separator-${idx}`} />
+        ) : (
+          <DropdownItem
+            aria-label={action.key}
+            key={action.key}
+            onClick={() => {
+              setIsOpen(false);
+              action.onClick && action.onClick();
+            }}
+            isDanger={action.isDanger}
+          >
+            {action.title}
+          </DropdownItem>
+        ),
+      ),
+    [actionItems, setIsOpen],
+  );
+
+  return (
+    <Dropdown
+      toggle={(toggleRef: React.Ref<MenuToggleElement>) => (
+        <MenuToggle
+          aria-label={t('HeapDumps.ARIA_LABELS.ROW_ACTION')}
+          variant="plain"
+          ref={toggleRef}
+          onClick={(event) => handleToggle(event, !isOpen)}
+        >
+          <EllipsisVIcon />
+        </MenuToggle>
+      )}
+      onOpenChange={setIsOpen}
+      onOpenChangeKeys={['Escape']}
+      isOpen={isOpen}
+      popperProps={{
+        position: 'right',
+        enableFlip: true,
+      }}
+    >
+      <DropdownList>{dropdownItems}</DropdownList>
+    </Dropdown>
+  );
+};
diff --git a/src/app/Modal/types.ts b/src/app/Modal/types.ts
index 316bad010..118ca61ac 100644
--- a/src/app/Modal/types.ts
+++ b/src/app/Modal/types.ts
@@ -20,6 +20,7 @@ export enum DeleteOrDisableWarningType {
   DisableAutomatedRules = 'DisableAutomatedRules',
   DeleteEventTemplates = 'DeleteEventTemplates',
   DeleteProbeTemplates = 'DeleteProbeTemplates',
+  DeleteHeapDump = 'DeleteHeapDump',
   DeleteThreadDump = 'DeleteThreadDump',
   DeleteActiveProbes = 'DeleteActiveProbes',
   DeleteCredentials = 'DeleteCredentials',
@@ -93,6 +94,14 @@ export const DeleteActiveProbes: DeleteOrDisableWarning = {
   ariaLabel: 'Active probes remove warning',
 };
 
+export const DeleteHeapDump: DeleteOrDisableWarning = {
+  id: DeleteOrDisableWarningType.DeleteHeapDump,
+  title: 'Permanently delete your archived heap dump?',
+  label: 'Delete Heap Dump',
+  description: `If you click Delete, your heap dump will be lost.`,
+  ariaLabel: 'Heap Dump delete warning',
+};
+
 export const DeleteThreadDump: DeleteOrDisableWarning = {
   id: DeleteOrDisableWarningType.DeleteThreadDump,
   title: 'Permanently delete your archived thread dump?',
@@ -151,6 +160,7 @@ export const DeleteWarningKinds: DeleteOrDisableWarning[] = [
   DeleteActiveProbes,
   DeleteThreadDump,
   DeleteCredentials,
+  DeleteHeapDump,
   DeleteCustomTargets,
   DeleteDashboardLayout,
   DeleteLayoutTemplate,
diff --git a/src/app/Shared/Services/Api.service.tsx b/src/app/Shared/Services/Api.service.tsx
index 8d0816360..6b2ebdba3 100644
--- a/src/app/Shared/Services/Api.service.tsx
+++ b/src/app/Shared/Services/Api.service.tsx
@@ -68,6 +68,7 @@ import {
   MBeanMetricsResponse,
   BuildInfo,
   AggregateReport,
+  HeapDump,
   ThreadDump,
 } from './api.types';
 import {
@@ -690,6 +691,26 @@ export class ApiService {
     );
   }
 
+  runHeapDump(suppressNotifications = false): Observable<string> {
+    return this.target.target().pipe(
+      concatMap((target) =>
+        this.sendRequest(
+          'beta',
+          `diagnostics/targets/${target?.id}/heapdump`,
+          {
+            method: 'POST',
+          },
+          undefined,
+          suppressNotifications,
+        ).pipe(
+          concatMap((resp) => resp.text()),
+          first(),
+        ),
+      ),
+      first(),
+    );
+  }
+
   deleteThreadDump(threaddumpname: string, suppressNotifications = false): Observable<boolean> {
     return this.target.target().pipe(
       concatMap((target) =>
@@ -710,6 +731,26 @@ export class ApiService {
     );
   }
 
+  deleteHeapDump(heapdumpname: string, suppressNotifications = false): Observable<boolean> {
+    return this.target.target().pipe(
+      concatMap((target) =>
+        this.sendRequest(
+          'beta',
+          `diagnostics/targets/${target?.id}/heapdump/${heapdumpname}`,
+          {
+            method: 'DELETE',
+          },
+          undefined,
+          suppressNotifications,
+        ).pipe(
+          map((resp) => resp.ok),
+          first(),
+        ),
+      ),
+      first(),
+    );
+  }
+
   getThreadDumps(suppressNotifications = false): Observable<ThreadDump[]> {
     return this.target.target().pipe(
       filter((t) => !!t),
@@ -731,6 +772,27 @@ export class ApiService {
     );
   }
 
+  getHeapDumps(suppressNotifications = false): Observable<HeapDump[]> {
+    return this.target.target().pipe(
+      filter((t) => !!t),
+      concatMap((target) =>
+        this.sendRequest(
+          'beta',
+          `diagnostics/targets/${target!.id}/heapdump`,
+          {
+            method: 'GET',
+          },
+          undefined,
+          suppressNotifications,
+        ).pipe(
+          concatMap((resp) => resp.json()),
+          first(),
+        ),
+      ),
+      first(),
+    );
+  }
+
   insertProbes(templateName: string): Observable<boolean> {
     return this.target.target().pipe(
       filter((t) => !!t),
@@ -1109,6 +1171,20 @@ export class ApiService {
     });
   }
 
+  downloadHeapDump(heapDump: HeapDump): void {
+    this.ctx.url(heapDump.downloadUrl).subscribe((resourceUrl) => {
+      let filename = this.target.target().pipe(
+        filter((t) => !!t),
+        map(() => `${heapDump.heapDumpId}`),
+        first(),
+      );
+      filename.subscribe((name) => {
+        resourceUrl += `?filename=${name}`;
+        this.downloadFile(resourceUrl, name);
+      });
+    });
+  }
+
   downloadTemplate(template: EventTemplate): void {
     let url: Observable<string> | undefined;
     switch (template.type) {
diff --git a/src/app/Shared/Services/api.types.ts b/src/app/Shared/Services/api.types.ts
index 0ad429d4c..52622235d 100644
--- a/src/app/Shared/Services/api.types.ts
+++ b/src/app/Shared/Services/api.types.ts
@@ -267,6 +267,14 @@ export interface ActiveRecording extends Recording {
   remoteId: number;
 }
 
+export interface HeapDump {
+  downloadUrl: string;
+  heapDumpId: string;
+  jvmId?: string;
+  lastModified?: number;
+  size?: number;
+}
+
 export interface ActiveRecordingsFilterInput {
   name?: string;
   state?: string;
@@ -555,6 +563,10 @@ export enum NotificationCategory {
   LayoutTemplateCreated = 'LayoutTemplateCreated', // generated client-side
   TargetCredentialsStored = 'TargetCredentialsStored',
   TargetCredentialsDeleted = 'TargetCredentialsDeleted',
+  HeapDumpSuccess = 'HeapDumpSuccess',
+  HeapDumpUploaded = 'HeapDumpUploaded',
+  HeapDumpFailure = 'HeapDumpFailure',
+  HeapDumpDeleted = 'HeapDumpDeleted',
   ThreadDumpSuccess = 'ThreadDumpSuccess',
   ThreadDumpFailure = 'ThreadDumpFailure',
   ThreadDumpDeleted = 'ThreadDumpDeleted',
diff --git a/src/app/Shared/Services/api.utils.ts b/src/app/Shared/Services/api.utils.ts
index c8946a9b2..f3a8f0dfe 100644
--- a/src/app/Shared/Services/api.utils.ts
+++ b/src/app/Shared/Services/api.utils.ts
@@ -390,6 +390,38 @@ export const messageKeys = new Map([
       body: (evt) => `Credentials deleted for target: ${evt.message.target}`,
     } as NotificationMessageMapper,
   ],
+  [
+    NotificationCategory.HeapDumpSuccess,
+    {
+      variant: AlertVariant.success,
+      title: 'Heap Dump Succeeded',
+      body: (evt) => `Heap Dump requested for target: ${evt.message.targetAlias}. Job ID: ${evt.message.jobId}`,
+    } as NotificationMessageMapper,
+  ],
+  [
+    NotificationCategory.HeapDumpFailure,
+    {
+      variant: AlertVariant.danger,
+      title: 'Heap Dump Failed',
+      body: (evt) => `Failed to create Heap Dump with JobID: ${evt.message.jobId}`,
+    } as NotificationMessageMapper,
+  ],
+  [
+    NotificationCategory.HeapDumpDeleted,
+    {
+      variant: AlertVariant.success,
+      title: 'Heap Dump Deleted',
+      body: (evt) => `${evt.message.heapDumpId} was deleted`,
+    } as NotificationMessageMapper,
+  ],
+  [
+    NotificationCategory.HeapDumpUploaded,
+    {
+      variant: AlertVariant.success,
+      title: 'Heap Dump Uploaded',
+      body: (evt) => `${evt.message.filename} was uploaded`,
+    } as NotificationMessageMapper,
+  ],
   [
     NotificationCategory.ThreadDumpSuccess,
     {
diff --git a/src/app/routes.tsx b/src/app/routes.tsx
index 0740cf24e..b166e6ede 100644
--- a/src/app/routes.tsx
+++ b/src/app/routes.tsx
@@ -21,6 +21,7 @@ import Archives from './Archives/Archives';
 import CreateRecording from './CreateRecording/CreateRecording';
 import Dashboard from './Dashboard/Dashboard';
 import DashboardSolo from './Dashboard/DashboardSolo';
+import { AnalyzeHeapDumps } from './Diagnostics/AnalyzeHeapDumps';
 import AnalyzeThreadDumps from './Diagnostics/AnalyzeThreadDumps';
 import CaptureDiagnostics from './Diagnostics/CaptureDiagnostics';
 import Events from './Events/Events';
@@ -189,6 +190,16 @@ const diagnosticsRoutes: IAppRoute[] = [
     navSubgroup: ANALYZE,
     featureLevel: FeatureLevel.BETA,
   },
+  {
+    component: AnalyzeHeapDumps,
+    label: 'Heap Dumps',
+    path: toPath('/heapdumps'),
+    title: 'Heap Dumps',
+    description: 'Create and view heap dumps on single target JVMs.',
+    navGroup: DIAGNOSTICS,
+    navSubgroup: ANALYZE,
+    featureLevel: FeatureLevel.BETA,
+  },
 ];
 
 const consoleRoutes: IAppRoute[] = [
diff --git a/src/test/Diagnostics/HeapDumpsTable.test.tsx b/src/test/Diagnostics/HeapDumpsTable.test.tsx
new file mode 100644
index 000000000..e4a1a36f1
--- /dev/null
+++ b/src/test/Diagnostics/HeapDumpsTable.test.tsx
@@ -0,0 +1,151 @@
+/*
+ * Copyright The Cryostat Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HeapDumpsTable } from '@app/Diagnostics/HeapDumpsTable';
+import { DeleteHeapDump } from '@app/Modal/types';
+import {
+  MessageMeta,
+  MessageType,
+  NotificationCategory,
+  NotificationMessage,
+  HeapDump,
+} from '@app/Shared/Services/api.types';
+import { defaultServices } from '@app/Shared/Services/Services';
+import '@testing-library/jest-dom';
+import { defaultDatetimeFormat } from '@i18n/datetime';
+import { cleanup, screen, within, act } from '@testing-library/react';
+import { of } from 'rxjs';
+import { render, testT } from '../utils';
+
+const mockMessageType = { type: 'application', subtype: 'json' } as MessageType;
+
+const mockHeapDump: HeapDump = {
+  downloadUrl: 'someDownloadUrl',
+  heapDumpId: 'someUuid',
+  jvmId: 'someJvmId',
+};
+
+const mockConnectUrl = 'service:jmx:rmi://someUrl';
+const mockTarget = {
+  agent: false,
+  connectUrl: mockConnectUrl,
+  alias: 'fooTarget',
+  jvmId: 'foo',
+  labels: [],
+  annotations: { cryostat: [], platform: [] },
+};
+
+const mockHeapDumpNotification = {
+  meta: {
+    category: NotificationCategory.HeapDumpUploaded,
+    type: mockMessageType,
+  } as MessageMeta,
+  message: {
+    targetId: mockHeapDump.jvmId,
+  },
+} as NotificationMessage;
+
+jest.spyOn(defaultServices.settings, 'deletionDialogsEnabledFor').mockReturnValue(true);
+jest.spyOn(defaultServices.settings, 'datetimeFormat').mockReturnValue(of(defaultDatetimeFormat));
+
+jest.spyOn(defaultServices.api, 'getHeapDumps').mockReturnValue(of([mockHeapDump]));
+
+jest.spyOn(defaultServices.target, 'target').mockReturnValue(of(mockTarget));
+
+jest
+  .spyOn(defaultServices.notificationChannel, 'messages')
+  .mockReturnValueOnce(of(mockHeapDumpNotification))
+  .mockReturnValue(of());
+
+describe('<HeapDumpsTable />', () => {
+  afterEach(cleanup);
+
+  it('should add a Heap Dump after receiving a notification', async () => {
+    render({ routerConfigs: { routes: [{ path: '/heapdumps', element: <HeapDumpsTable /> }] } });
+
+    const addTemplateName = screen.getByText('someUuid');
+    expect(addTemplateName).toBeInTheDocument();
+    expect(addTemplateName).toBeVisible();
+  });
+
+  it('should display the column header fields', async () => {
+    render({ routerConfigs: { routes: [{ path: '/heapdumps', element: <HeapDumpsTable /> }] } });
+
+    const nameHeader = screen.getByText('ID');
+    expect(nameHeader).toBeInTheDocument();
+    expect(nameHeader).toBeVisible();
+
+    const modifiedHeader = screen.getByText('Last Modified');
+    expect(modifiedHeader).toBeInTheDocument();
+    expect(modifiedHeader).toBeVisible();
+
+    const sizeHeader = screen.getByText('Size');
+    expect(sizeHeader).toBeInTheDocument();
+    expect(sizeHeader).toBeVisible();
+  });
+
+  it('should show warning modal and delete a Heap Dump when confirmed', async () => {
+    const deleteRequestSpy = jest.spyOn(defaultServices.api, 'deleteHeapDump').mockReturnValue(of(true));
+    const { user } = render({
+      routerConfigs: { routes: [{ path: '/heapdumps', element: <HeapDumpsTable /> }] },
+    });
+
+    await act(async () => {
+      await user.click(screen.getByLabelText(testT('HeapDumps.ARIA_LABELS.ROW_ACTION')));
+
+      const deleteButton = await screen.findByText('Delete');
+      expect(deleteButton).toBeInTheDocument();
+      expect(deleteButton).toBeVisible();
+
+      await user.click(deleteButton);
+
+      const warningModal = await screen.findByRole('dialog');
+      expect(warningModal).toBeInTheDocument();
+      expect(warningModal).toBeVisible();
+
+      const modalTitle = within(warningModal).getByText(DeleteHeapDump.title);
+      expect(modalTitle).toBeInTheDocument();
+      expect(modalTitle).toBeVisible();
+
+      const confirmButton = within(warningModal).getByText('Delete');
+      expect(confirmButton).toBeInTheDocument();
+      expect(confirmButton).toBeVisible();
+
+      await user.click(confirmButton);
+    });
+
+    expect(deleteRequestSpy).toHaveBeenCalledTimes(1);
+    expect(deleteRequestSpy).toHaveBeenCalledWith('someUuid');
+  });
+
+  it('should shown empty state when table is empty', async () => {
+    const { user } = render({
+      routerConfigs: { routes: [{ path: '/heapdumps', element: <HeapDumpsTable /> }] },
+    });
+
+    const filterInput = screen.getByLabelText(testT('HeapDumps.ARIA_LABELS.SEARCH_INPUT'));
+    expect(filterInput).toBeInTheDocument();
+    expect(filterInput).toBeVisible();
+
+    await user.type(filterInput, 'someveryoddname');
+
+    expect(screen.queryByText('someHeapDump')).not.toBeInTheDocument();
+
+    const hintText = screen.getByText('No Heap Dumps');
+    expect(hintText).toBeInTheDocument();
+    expect(hintText).toBeVisible();
+  });
+});
diff --git a/src/test/Diagnostics/ThreadDumpsTable.test.tsx b/src/test/Diagnostics/ThreadDumpsTable.test.tsx
index a5d68ed2b..350fe21b4 100644
--- a/src/test/Diagnostics/ThreadDumpsTable.test.tsx
+++ b/src/test/Diagnostics/ThreadDumpsTable.test.tsx
@@ -74,7 +74,7 @@ describe('<ThreadDumpsTable />', () => {
   afterEach(cleanup);
 
   it('should add a Thread Dump after receiving a notification', async () => {
-    render({ routerConfigs: { routes: [{ path: '/diagnostics', element: <ThreadDumpsTable /> }] } });
+    render({ routerConfigs: { routes: [{ path: '/threaddumps', element: <ThreadDumpsTable /> }] } });
 
     const addTemplateName = screen.getByText('someUuid');
     expect(addTemplateName).toBeInTheDocument();
@@ -82,7 +82,7 @@ describe('<ThreadDumpsTable />', () => {
   });
 
   it('should display the column header fields', async () => {
-    render({ routerConfigs: { routes: [{ path: '/diagnostics', element: <ThreadDumpsTable /> }] } });
+    render({ routerConfigs: { routes: [{ path: '/threaddumps', element: <ThreadDumpsTable /> }] } });
 
     const nameHeader = screen.getByText('ID');
     expect(nameHeader).toBeInTheDocument();
@@ -96,7 +96,7 @@ describe('<ThreadDumpsTable />', () => {
   it('should show warning modal and delete a Thread Dump when confirmed', async () => {
     const deleteRequestSpy = jest.spyOn(defaultServices.api, 'deleteThreadDump').mockReturnValue(of(true));
     const { user } = render({
-      routerConfigs: { routes: [{ path: '/diagnostics', element: <ThreadDumpsTable /> }] },
+      routerConfigs: { routes: [{ path: '/threaddumps', element: <ThreadDumpsTable /> }] },
     });
 
     await act(async () => {
@@ -129,7 +129,7 @@ describe('<ThreadDumpsTable />', () => {
 
   it('should shown empty state when table is empty', async () => {
     const { user } = render({
-      routerConfigs: { routes: [{ path: '/diagnostics', element: <ThreadDumpsTable /> }] },
+      routerConfigs: { routes: [{ path: '/threaddumps', element: <ThreadDumpsTable /> }] },
     });
 
     const filterInput = screen.getByLabelText(testT('ThreadDumps.ARIA_LABELS.SEARCH_INPUT'));
diff --git a/src/test/Settings/__snapshots__/DeletionDialogControl.test.tsx.snap b/src/test/Settings/__snapshots__/DeletionDialogControl.test.tsx.snap
index eb7d55475..939860cac 100644
--- a/src/test/Settings/__snapshots__/DeletionDialogControl.test.tsx.snap
+++ b/src/test/Settings/__snapshots__/DeletionDialogControl.test.tsx.snap
@@ -351,6 +351,45 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
             data-ouia-component-id="OUIA-Generated-Switch-8"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
+            htmlFor="DeleteHeapDump"
+          >
+            <input
+              aria-label=""
+              aria-labelledby="DeleteHeapDump-on"
+              checked={true}
+              className="pf-v5-c-switch__input"
+              disabled={false}
+              id="DeleteHeapDump"
+              onChange={[Function]}
+              type="checkbox"
+            />
+            <span
+              className="pf-v5-c-switch__toggle"
+            />
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-on"
+              id="DeleteHeapDump-on"
+            >
+              Delete Heap Dump
+            </span>
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-off"
+              id="DeleteHeapDump-off"
+            >
+              Delete Heap Dump
+            </span>
+          </label>
+        </div>
+        <div
+          className="pf-v5-l-stack__item"
+        >
+          <label
+            className="pf-v5-c-switch"
+            data-ouia-component-id="OUIA-Generated-Switch-9"
+            data-ouia-component-type="PF5/Switch"
+            data-ouia-safe={true}
             htmlFor="DeleteThreadDump"
           >
             <input
@@ -387,7 +426,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-9"
+            data-ouia-component-id="OUIA-Generated-Switch-10"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="DeleteActiveProbes"
@@ -426,7 +465,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-10"
+            data-ouia-component-id="OUIA-Generated-Switch-11"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="DeleteCredentials"
@@ -465,7 +504,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-11"
+            data-ouia-component-id="OUIA-Generated-Switch-12"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="DeleteCustomTargets"
@@ -504,7 +543,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-12"
+            data-ouia-component-id="OUIA-Generated-Switch-13"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="DeleteDashboardLayout"
@@ -543,7 +582,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-13"
+            data-ouia-component-id="OUIA-Generated-Switch-14"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="DeleteLayoutTemplate"
@@ -582,7 +621,7 @@ exports[`<DeletionDialogControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-14"
+            data-ouia-component-id="OUIA-Generated-Switch-15"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="ClearDashboardLayout"
diff --git a/src/test/Settings/__snapshots__/NotificationControl.test.tsx.snap b/src/test/Settings/__snapshots__/NotificationControl.test.tsx.snap
index 4d63b6f28..00fcc52a1 100644
--- a/src/test/Settings/__snapshots__/NotificationControl.test.tsx.snap
+++ b/src/test/Settings/__snapshots__/NotificationControl.test.tsx.snap
@@ -1258,6 +1258,162 @@ exports[`<NotificationControl/> renders correctly 1`] = `
             data-ouia-component-id="OUIA-Generated-Switch-28"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
+            htmlFor="HeapDumpSuccess"
+          >
+            <input
+              aria-label=""
+              aria-labelledby="HeapDumpSuccess-on"
+              checked={true}
+              className="pf-v5-c-switch__input"
+              disabled={false}
+              id="HeapDumpSuccess"
+              onChange={[Function]}
+              type="checkbox"
+            />
+            <span
+              className="pf-v5-c-switch__toggle"
+            />
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-on"
+              id="HeapDumpSuccess-on"
+            >
+              Heap Dump Succeeded
+            </span>
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-off"
+              id="HeapDumpSuccess-off"
+            >
+              Heap Dump Succeeded
+            </span>
+          </label>
+        </div>
+        <div
+          className="pf-v5-l-stack__item"
+        >
+          <label
+            className="pf-v5-c-switch"
+            data-ouia-component-id="OUIA-Generated-Switch-29"
+            data-ouia-component-type="PF5/Switch"
+            data-ouia-safe={true}
+            htmlFor="HeapDumpUploaded"
+          >
+            <input
+              aria-label=""
+              aria-labelledby="HeapDumpUploaded-on"
+              checked={true}
+              className="pf-v5-c-switch__input"
+              disabled={false}
+              id="HeapDumpUploaded"
+              onChange={[Function]}
+              type="checkbox"
+            />
+            <span
+              className="pf-v5-c-switch__toggle"
+            />
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-on"
+              id="HeapDumpUploaded-on"
+            >
+              Heap Dump Uploaded
+            </span>
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-off"
+              id="HeapDumpUploaded-off"
+            >
+              Heap Dump Uploaded
+            </span>
+          </label>
+        </div>
+        <div
+          className="pf-v5-l-stack__item"
+        >
+          <label
+            className="pf-v5-c-switch"
+            data-ouia-component-id="OUIA-Generated-Switch-30"
+            data-ouia-component-type="PF5/Switch"
+            data-ouia-safe={true}
+            htmlFor="HeapDumpFailure"
+          >
+            <input
+              aria-label=""
+              aria-labelledby="HeapDumpFailure-on"
+              checked={true}
+              className="pf-v5-c-switch__input"
+              disabled={false}
+              id="HeapDumpFailure"
+              onChange={[Function]}
+              type="checkbox"
+            />
+            <span
+              className="pf-v5-c-switch__toggle"
+            />
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-on"
+              id="HeapDumpFailure-on"
+            >
+              Heap Dump Failed
+            </span>
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-off"
+              id="HeapDumpFailure-off"
+            >
+              Heap Dump Failed
+            </span>
+          </label>
+        </div>
+        <div
+          className="pf-v5-l-stack__item"
+        >
+          <label
+            className="pf-v5-c-switch"
+            data-ouia-component-id="OUIA-Generated-Switch-31"
+            data-ouia-component-type="PF5/Switch"
+            data-ouia-safe={true}
+            htmlFor="HeapDumpDeleted"
+          >
+            <input
+              aria-label=""
+              aria-labelledby="HeapDumpDeleted-on"
+              checked={true}
+              className="pf-v5-c-switch__input"
+              disabled={false}
+              id="HeapDumpDeleted"
+              onChange={[Function]}
+              type="checkbox"
+            />
+            <span
+              className="pf-v5-c-switch__toggle"
+            />
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-on"
+              id="HeapDumpDeleted-on"
+            >
+              Heap Dump Deleted
+            </span>
+            <span
+              aria-hidden="true"
+              className="pf-v5-c-switch__label pf-m-off"
+              id="HeapDumpDeleted-off"
+            >
+              Heap Dump Deleted
+            </span>
+          </label>
+        </div>
+        <div
+          className="pf-v5-l-stack__item"
+        >
+          <label
+            className="pf-v5-c-switch"
+            data-ouia-component-id="OUIA-Generated-Switch-32"
+            data-ouia-component-type="PF5/Switch"
+            data-ouia-safe={true}
             htmlFor="ThreadDumpSuccess"
           >
             <input
@@ -1294,7 +1450,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-29"
+            data-ouia-component-id="OUIA-Generated-Switch-33"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="ThreadDumpFailure"
@@ -1333,7 +1489,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-30"
+            data-ouia-component-id="OUIA-Generated-Switch-34"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="ThreadDumpDeleted"
@@ -1372,7 +1528,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-31"
+            data-ouia-component-id="OUIA-Generated-Switch-35"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="CredentialsStored"
@@ -1411,7 +1567,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-32"
+            data-ouia-component-id="OUIA-Generated-Switch-36"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="CredentialsDeleted"
@@ -1450,7 +1606,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-33"
+            data-ouia-component-id="OUIA-Generated-Switch-37"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="ReportSuccess"
@@ -1489,7 +1645,7 @@ exports[`<NotificationControl/> renders correctly 1`] = `
         >
           <label
             className="pf-v5-c-switch"
-            data-ouia-component-id="OUIA-Generated-Switch-34"
+            data-ouia-component-id="OUIA-Generated-Switch-38"
             data-ouia-component-type="PF5/Switch"
             data-ouia-safe={true}
             htmlFor="ReportFailure"