diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 7c5e7eba54df..9906338d2c1c 100644
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -9108,6 +9108,7 @@ const CONST = {
                 MORE_DROPDOWN: 'WorkspaceMembers-MoreDropdown',
             },
             CATEGORIES: {
+                ROW: 'WorkspaceCategories-Row',
                 ADD_BUTTON: 'WorkspaceCategories-AddButton',
                 MORE_DROPDOWN: 'WorkspaceCategories-MoreDropdown',
                 BULK_ACTIONS_DROPDOWN: 'WorkspaceCategories-BulkActionsDropdown',
diff --git a/src/components/Table/Table.tsx b/src/components/Table/Table.tsx
index 53d7b10e997d..89d86d71f8a8 100644
--- a/src/components/Table/Table.tsx
+++ b/src/components/Table/Table.tsx
@@ -1,12 +1,20 @@
 import type {FlashListRef} from '@shopify/flash-list';
 import React, {useImperativeHandle, useRef} from 'react';
+import MenuItem from '@components/MenuItem';
+import Modal from '@components/Modal';
+import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
+import useLocalize from '@hooks/useLocalize';
+import useMobileSelectionMode from '@hooks/useMobileSelectionMode';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import {turnOnMobileSelectionMode} from '@libs/actions/MobileSelectionMode';
+import CONST from '@src/CONST';
 import useFiltering from './middlewares/filtering';
 import useSearching from './middlewares/searching';
+import useSelection from './middlewares/selection';
 import useSorting from './middlewares/sorting';
 import TableContext from './TableContext';
 import type {TableContextValue} from './TableContext';
-import type {TableHandle, TableMethods, TableProps} from './types';
+import type {TableData, TableHandle, TableMethods, TableProps} from './types';
 
 /**
  * A composable table component that provides filtering, search, and sorting functionality.
@@ -32,12 +40,13 @@ import type {TableHandle, TableMethods, TableProps} from './types';
  * 1. **Filtering** - Applies dropdown filter selections
  * 2. **Searching** - Applies search string filtering
  * 3. **Sorting** - Sorts data by the active column
+ * 4. **Selection** - Applies row selection state & provides helpers for selection
  *
  * Each middleware transforms the data array and passes it to the next.
  *
  * ## Generic Type Parameters
  *
- * - `T` - The type of items in your data array
+ * - `DataType` - The type of items in your data array
  * - `ColumnKey` - String literal union of valid column keys (e.g., `'name' | 'date'`)
  * - `FilterKey` - String literal union of valid filter keys
  *
@@ -129,39 +138,51 @@ import type {TableHandle, TableMethods, TableProps} from './types';
  * </Table>
  * ```
  */
-function Table<T, ColumnKey extends string = string, FilterKey extends string = string>({
+function Table<DataType extends TableData, ColumnKey extends string = string, FilterKey extends string = string>({
     ref,
     title,
-    data = [],
     columns,
     filters,
+    data = [],
+    selectedKeys = [],
     compareItems,
     isItemInFilter,
     isItemInSearch,
     initialSortColumn,
     children,
+    selectionEnabled,
+    onRowSelectionChange,
     ...listProps
-}: TableProps<T, ColumnKey, FilterKey>) {
+}: TableProps<DataType, ColumnKey, FilterKey>) {
+    const {translate} = useLocalize();
+    const icons = useMemoizedLazyExpensifyIcons(['CheckSquare']);
+    const isMobileSelectionEnabled = useMobileSelectionMode();
+
     if (!columns || columns.length === 0) {
         throw new Error('Table columns must be provided');
     }
 
     const {shouldUseNarrowLayout, isMediumScreenWidth} = useResponsiveLayout();
 
-    const {middleware: filterMiddleware, currentFilters, methods: filterMethods} = useFiltering<T, FilterKey>({filters, isItemInFilter});
+    const {middleware: filterMiddleware, currentFilters, methods: filterMethods} = useFiltering<DataType, FilterKey>({filters, isItemInFilter});
+    const filteredData = filterMiddleware(data);
 
-    const {middleware: searchMiddleware, activeSearchString, methods: searchMethods} = useSearching<T>({isItemInSearch});
+    const {middleware: searchMiddleware, activeSearchString, methods: searchMethods} = useSearching<DataType>({isItemInSearch});
+    const searchedData = searchMiddleware(filteredData);
 
-    const {middleware: sortMiddleware, activeSorting, methods: sortMethods} = useSorting<T, ColumnKey>({compareItems, initialSortColumn});
+    const {middleware: sortMiddleware, activeSorting, methods: sortMethods} = useSorting<DataType, ColumnKey>({compareItems, initialSortColumn});
+    const sortedData = sortMiddleware(searchedData);
 
-    const processedData = [filterMiddleware, searchMiddleware, sortMiddleware].reduce((acc, middleware) => middleware(acc), data);
+    const {middleware: selectionMiddleware, methods: selectionMethods, mobileSelectionModalRowKey} = useSelection<DataType>({data: sortedData, selectedKeys, onRowSelectionChange});
+    const processedData = selectionMiddleware(sortedData);
 
-    const listRef = useRef<FlashListRef<T>>(null);
+    const listRef = useRef<FlashListRef<DataType>>(null);
 
     const tableMethods: TableMethods<ColumnKey, FilterKey> = {
         ...filterMethods,
         ...sortMethods,
         ...searchMethods,
+        ...selectionMethods,
     };
 
     /**
@@ -179,9 +200,9 @@ function Table<T, ColumnKey extends string = string, FilterKey extends string =
                     return () => processedData;
                 }
 
-                return listRef.current?.[property as keyof FlashListRef<T>];
+                return listRef.current?.[property as keyof FlashListRef<DataType>];
             },
-        }) as TableHandle<T, ColumnKey, FilterKey>;
+        }) as TableHandle<DataType, ColumnKey, FilterKey>;
     });
 
     const originalDataLength = data?.length ?? 0;
@@ -199,8 +220,17 @@ function Table<T, ColumnKey extends string = string, FilterKey extends string =
     const hasSearchString = activeSearchString.trim().length > 0;
     const isEmptyResult = processedData.length === 0 && originalDataLength > 0 && (hasSearchString || hasActiveFilters);
 
+    const handleMobileSelectionPress = () => {
+        turnOnMobileSelectionMode();
+
+        if (mobileSelectionModalRowKey) {
+            tableMethods.handleSingleRowSelection(mobileSelectionModalRowKey);
+            tableMethods.setMobileSelectionModalRowKey(null);
+        }
+    };
+
     // eslint-disable-next-line react/jsx-no-constructed-context-values
-    const contextValue: TableContextValue<T, ColumnKey, FilterKey> = {
+    const contextValue: TableContextValue<DataType, ColumnKey, FilterKey> = {
         title,
         listRef,
         listProps,
@@ -216,9 +246,29 @@ function Table<T, ColumnKey extends string = string, FilterKey extends string =
         hasSearchString,
         isEmptyResult,
         shouldUseNarrowTableLayout,
+        selectionEnabled,
+        isMobileSelectionEnabled,
     };
 
-    return <TableContext.Provider value={contextValue as unknown as TableContextValue<unknown, string>}>{children}</TableContext.Provider>;
+    return (
+        <TableContext.Provider value={contextValue as unknown as TableContextValue<TableData, string, string>}>
+            {children}
+
+            <Modal
+                shouldPreventScrollOnFocus
+                isVisible={!!mobileSelectionModalRowKey}
+                type={CONST.MODAL.MODAL_TYPE.BOTTOM_DOCKED}
+                onClose={() => tableMethods.setMobileSelectionModalRowKey(null)}
+            >
+                <MenuItem
+                    icon={icons.CheckSquare}
+                    title={translate('common.select')}
+                    onPress={handleMobileSelectionPress}
+                    pressableTestID={CONST.SELECTION_LIST_WITH_MODAL_TEST_ID}
+                />
+            </Modal>
+        </TableContext.Provider>
+    );
 }
 
 export default Table;
diff --git a/src/components/Table/TableBody.tsx b/src/components/Table/TableBody.tsx
index acca2f433a54..1ed2c932676d 100644
--- a/src/components/Table/TableBody.tsx
+++ b/src/components/Table/TableBody.tsx
@@ -7,6 +7,7 @@ import useBottomSafeSafeAreaPaddingStyle from '@hooks/useBottomSafeSafeAreaPaddi
 import useDebouncedAccessibilityAnnouncement from '@hooks/useDebouncedAccessibilityAnnouncement';
 import useLocalize from '@hooks/useLocalize';
 import useThemeStyles from '@hooks/useThemeStyles';
+import type {TableData} from '.';
 import {useTableContext} from './TableContext';
 
 /**
@@ -45,10 +46,19 @@ type TableBodyProps = ViewProps & {
  * </Table>
  * ```
  */
-function TableBody<T>({contentContainerStyle, style, ...props}: TableBodyProps) {
+function TableBody<DataType extends TableData>({contentContainerStyle, style, ...props}: TableBodyProps) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
-    const {processedData: filteredAndSortedData, activeSearchString, listProps, listRef, shouldUseNarrowTableLayout, hasActiveFilters, hasSearchString, isEmptyResult} = useTableContext<T>();
+    const {
+        processedData: filteredAndSortedData,
+        activeSearchString,
+        listProps,
+        listRef,
+        shouldUseNarrowTableLayout,
+        hasActiveFilters,
+        hasSearchString,
+        isEmptyResult,
+    } = useTableContext<DataType>();
     const {ListEmptyComponent, contentContainerStyle: listContentContainerStyle, ...restListProps} = listProps ?? {};
 
     const tableBodyContentContainerStyle = useBottomSafeSafeAreaPaddingStyle({
@@ -88,7 +98,7 @@ function TableBody<T>({contentContainerStyle, style, ...props}: TableBodyProps)
             style={[styles.flex1, styles.mnh0, style]}
             {...props}
         >
-            <FlashList<T>
+            <FlashList<DataType>
                 ref={listRef}
                 data={filteredAndSortedData}
                 style={[styles.flex1, styles.mnh0]}
diff --git a/src/components/Table/TableContext.tsx b/src/components/Table/TableContext.tsx
index 6d83062e2716..61ce34cbc338 100644
--- a/src/components/Table/TableContext.tsx
+++ b/src/components/Table/TableContext.tsx
@@ -2,27 +2,30 @@ import type {FlashListRef} from '@shopify/flash-list';
 import React, {createContext, useContext} from 'react';
 import type {FilterConfig} from './middlewares/filtering';
 import type {ActiveSorting} from './middlewares/sorting';
-import type {SharedListProps, TableColumn, TableMethods} from './types';
+import type {SharedListProps, TableColumn, TableData, TableMethods, TableRow} from './types';
 
 /**
  * The shape of the Table context value.
  * This context is provided by the `<Table>` component and consumed by its sub-components.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  * @template ColumnKey - A string literal type representing the valid column keys.
  */
-type TableContextValue<T, ColumnKey extends string = string, FilterKey extends string = string> = {
+type TableContextValue<DataType extends TableData, ColumnKey extends string = string, FilterKey extends string = string> = {
     /** The title of the table when shown on smaller screens. */
     title?: string;
 
     /** Reference to the underlying FlashList for programmatic control. */
-    listRef: React.RefObject<FlashListRef<T> | null>;
+    listRef: React.RefObject<FlashListRef<DataType> | null>;
 
     /** FlashList props passed through from the Table component. */
-    listProps: SharedListProps<T>;
+    listProps: SharedListProps<DataType>;
+
+    /** Whether or not selection is enabled for the table */
+    selectionEnabled?: boolean;
 
     /** The data array after filtering, searching, and sorting have been applied. */
-    processedData: T[];
+    processedData: Array<TableRow<DataType>>;
 
     /** The original length of the data array before any processing. */
     originalDataLength: number;
@@ -54,11 +57,14 @@ type TableContextValue<T, ColumnKey extends string = string, FilterKey extends s
     /** Whether the table has an empty result caused by search or filters. */
     isEmptyResult: boolean;
 
+    /** Whether or not table selection is enabled on mobile */
+    isMobileSelectionEnabled: boolean;
+
     /** Whether to use a narrow layout (e.g. on mobile screens). */
     shouldUseNarrowTableLayout: boolean;
 };
 
-const defaultTableContextValue: TableContextValue<unknown, string> = {
+const defaultTableContextValue: TableContextValue<TableData, string> = {
     listRef: React.createRef(),
     processedData: [],
     originalDataLength: 0,
@@ -71,11 +77,12 @@ const defaultTableContextValue: TableContextValue<unknown, string> = {
     activeSearchString: '',
     tableMethods: {} as TableMethods<string, string>,
     filterConfig: undefined,
-    listProps: {} as SharedListProps<unknown>,
+    listProps: {} as SharedListProps<TableData>,
     hasActiveFilters: false,
     hasSearchString: false,
     isEmptyResult: false,
     shouldUseNarrowTableLayout: false,
+    isMobileSelectionEnabled: false,
 };
 
 const TableContext = createContext(defaultTableContextValue);
@@ -97,14 +104,14 @@ const TableContext = createContext(defaultTableContextValue);
  * }
  * ```
  */
-function useTableContext<T, ColumnKey extends string = string>() {
+function useTableContext<DataType extends TableData, ColumnKey extends string = string>() {
     const context = useContext(TableContext);
 
     if (context === defaultTableContextValue && context.activeFilters === undefined) {
         throw new Error('useTableContext must be used within a Table provider');
     }
 
-    return context as unknown as TableContextValue<T, ColumnKey>;
+    return context as unknown as TableContextValue<DataType, ColumnKey>;
 }
 
 export default TableContext;
diff --git a/src/components/Table/TableHeader.tsx b/src/components/Table/TableHeader.tsx
index dcaec3a1b032..1e8a54d5dac1 100644
--- a/src/components/Table/TableHeader.tsx
+++ b/src/components/Table/TableHeader.tsx
@@ -1,16 +1,19 @@
 import React, {useRef} from 'react';
 import {View} from 'react-native';
 import type {ViewProps} from 'react-native';
+import Checkbox from '@components/Checkbox';
 import Icon from '@components/Icon';
 import {PressableWithFeedback} from '@components/Pressable';
 import Text from '@components/Text';
 import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
+import useLocalize from '@hooks/useLocalize';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
 import {useTableContext} from './TableContext';
-import type {TableColumn} from './types';
+import type {TableColumn, TableData} from './types';
 
 /**
  * Number of times a column can be toggled before sorting is reset.
@@ -30,7 +33,7 @@ type TableHeaderProps = ViewProps;
  * Clicking a column header toggles sorting: ascending -> descending -> reset.
  * The currently sorted column displays an arrow icon indicating sort direction.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  * @template ColumnKey - A string literal type representing the valid column keys.
  *
  * @example
@@ -46,10 +49,13 @@ type TableHeaderProps = ViewProps;
  * </Table>
  * ```
  */
-function TableHeader<T, ColumnKey extends string = string>({style, ...props}: TableHeaderProps) {
+function TableHeader<DataType extends TableData, ColumnKey extends string = string>({style, ...props}: TableHeaderProps) {
     const theme = useTheme();
     const styles = useThemeStyles();
-    const {columns, isEmptyResult, title, processedData, shouldUseNarrowTableLayout} = useTableContext<T, ColumnKey>();
+    const {translate} = useLocalize();
+    const {shouldUseNarrowLayout} = useResponsiveLayout();
+    const {columns, isEmptyResult, title, shouldUseNarrowTableLayout, tableMethods, selectionEnabled, processedData, isMobileSelectionEnabled} = useTableContext<DataType, ColumnKey>();
+    const isSelectionCheckboxVisible = selectionEnabled && (isMobileSelectionEnabled || !shouldUseNarrowLayout);
 
     if (shouldUseNarrowTableLayout && !title) {
         return null;
@@ -59,7 +65,24 @@ function TableHeader<T, ColumnKey extends string = string>({style, ...props}: Ta
         return null;
     }
 
-    const gridTemplateColumns = columns.map((column) => (column.width ? `${column.width}px` : '1fr')).join(' ');
+    const gridTemplateColumns = columns.map((column) => (column.width ? `${column.width}px` : '1fr'));
+
+    if (isSelectionCheckboxVisible) {
+        gridTemplateColumns.unshift(`${variables.tableCheckboxColumnWidth}px`);
+    }
+
+    const selectableRows = processedData.filter((row) => !row.disabled);
+    let isSelectionIndeterminate = false;
+    let isEverySelectableRowSelected = selectableRows.length > 0;
+
+    // We exclude disabled rows from the 'select all' behavior, so if a disabled row is not selected, we still
+    // consider all active rows to be selected
+    if (isSelectionCheckboxVisible) {
+        for (const row of selectableRows) {
+            isSelectionIndeterminate = row.selected || isSelectionIndeterminate;
+            isEverySelectableRowSelected = row.selected && isEverySelectableRowSelected;
+        }
+    }
 
     return (
         <View
@@ -77,13 +100,24 @@ function TableHeader<T, ColumnKey extends string = string>({style, ...props}: Ta
                 styles.gap3,
                 // Use Grid on web when available (will override flex if supported)
                 styles.dGrid,
-                !shouldUseNarrowTableLayout && {gridTemplateColumns},
+                !shouldUseNarrowTableLayout && {gridTemplateColumns: gridTemplateColumns.join(' ')},
                 style,
             ]}
             {...props}
         >
             {shouldUseNarrowTableLayout && (
-                <View style={[styles.flexRow, styles.alignItemsCenter, styles.tableHeaderContentHeight]}>
+                <View style={[styles.flexRow, styles.alignItemsCenter, styles.tableHeaderContentHeight, styles.gap3]}>
+                    {!!isSelectionCheckboxVisible && (
+                        <Checkbox
+                            containerStyle={styles.m0}
+                            isChecked={isEverySelectableRowSelected}
+                            isIndeterminate={isSelectionIndeterminate && !isEverySelectableRowSelected}
+                            onPress={tableMethods.handleSelectAll}
+                            accessibilityLabel={translate('workspace.common.selectAll')}
+                            style={styles.pl1}
+                        />
+                    )}
+
                     <Text
                         numberOfLines={1}
                         color={theme.textSupporting}
@@ -94,15 +128,27 @@ function TableHeader<T, ColumnKey extends string = string>({style, ...props}: Ta
                 </View>
             )}
 
-            {!shouldUseNarrowTableLayout &&
-                columns.map((column) => {
-                    return (
-                        <TableHeaderColumn
-                            column={column}
-                            key={column.key}
+            {!shouldUseNarrowTableLayout && (
+                <>
+                    {!!selectionEnabled && (
+                        <Checkbox
+                            isChecked={isEverySelectableRowSelected}
+                            isIndeterminate={isSelectionIndeterminate && !isEverySelectableRowSelected}
+                            onPress={tableMethods.handleSelectAll}
+                            accessibilityLabel={translate('workspace.common.selectAll')}
                         />
-                    );
-                })}
+                    )}
+
+                    {columns.map((column) => {
+                        return (
+                            <TableHeaderColumn
+                                column={column}
+                                key={column.key}
+                            />
+                        );
+                    })}
+                </>
+            )}
         </View>
     );
 }
@@ -110,23 +156,23 @@ function TableHeader<T, ColumnKey extends string = string>({style, ...props}: Ta
 /**
  * Renders a single sortable column header.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  * @template ColumnKey - A string literal type representing the valid column keys.
  */
-function TableHeaderColumn<T, ColumnKey extends string = string>({column}: {column: TableColumn<ColumnKey>}) {
+function TableHeaderColumn<DataType extends TableData, ColumnKey extends string = string>({column}: {column: TableColumn<ColumnKey>}) {
     const theme = useTheme();
+    const toggleCount = useRef(0);
     const styles = useThemeStyles();
     const expensifyIcons = useMemoizedLazyExpensifyIcons(['ArrowUpLong', 'ArrowDownLong']);
 
     const {
         activeSorting,
         tableMethods: {updateSorting, toggleColumnSorting},
-    } = useTableContext<T, ColumnKey>();
+    } = useTableContext<DataType, ColumnKey>();
+
     const isSortingByColumn = column.key === activeSorting.columnKey;
     const sortIcon = activeSorting.order === 'asc' ? expensifyIcons.ArrowUpLong : expensifyIcons.ArrowDownLong;
 
-    const toggleCount = useRef(0);
-
     /**
      * Handles column header press for sorting.
      * Cycles through: first toggle (asc), second toggle (desc), third toggle (reset).
@@ -156,15 +202,15 @@ function TableHeaderColumn<T, ColumnKey extends string = string>({column}: {colu
             accessible
             accessibilityLabel={column.label}
             accessibilityRole="button"
+            disabled={!column.sortable}
             sentryLabel={CONST.SENTRY_LABEL.TABLE_HEADER.SORTABLE_COLUMN}
             style={tableHeaderStyles}
-            disabled={!column.sortable}
             onPress={() => toggleSorting(column.key)}
         >
             <Text
                 numberOfLines={1}
                 color={theme.textSupporting}
-                style={[styles.lh16, isSortingByColumn ? styles.textMicroBoldSupporting : [styles.textMicroSupporting, styles.pr1, styles.tableHeaderIconSpacing]]}
+                style={[styles.lh16, isSortingByColumn ? styles.textMicroBoldSupporting : styles.textMicroSupporting]}
             >
                 {column.label}
             </Text>
diff --git a/src/components/Table/TableRow.tsx b/src/components/Table/TableRow.tsx
index 92c36aaea220..7421699b5fcb 100644
--- a/src/components/Table/TableRow.tsx
+++ b/src/components/Table/TableRow.tsx
@@ -1,7 +1,8 @@
 import React from 'react';
-import type {PressableStateCallbackType} from 'react-native';
+import type {GestureResponderEvent, PressableStateCallbackType} from 'react-native';
 import {View} from 'react-native';
 import Animated from 'react-native-reanimated';
+import Checkbox from '@components/Checkbox';
 import ErrorMessageRow from '@components/ErrorMessageRow';
 import type {OfflineWithFeedbackProps} from '@components/OfflineWithFeedback';
 import OfflineWithFeedback from '@components/OfflineWithFeedback';
@@ -9,6 +10,8 @@ import type {PressableWithFeedbackProps} from '@components/Pressable/PressableWi
 import PressableWithFeedback from '@components/Pressable/PressableWithFeedback';
 import SkeletonViewContentLoader from '@components/SkeletonViewContentLoader';
 import useAnimatedHighlightStyle from '@hooks/useAnimatedHighlightStyle';
+import useLocalize from '@hooks/useLocalize';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
 import type {SkeletonSpanReasonAttributes} from '@libs/telemetry/useSkeletonSpan';
@@ -24,6 +27,9 @@ type TableRowProps = Omit<PressableWithFeedbackProps, 'accessible'> & {
     /** Whether or not the table row is pressable or not */
     interactive: boolean;
 
+    /** Whether or not the table row should be disabled */
+    disabled?: boolean;
+
     /** The index of the row in the table */
     rowIndex: number;
 
@@ -47,6 +53,7 @@ export default function TableRow({
     children,
     accessible,
     rowIndex,
+    disabled,
     sentryLabel,
     interactive,
     isLoading,
@@ -61,13 +68,21 @@ export default function TableRow({
 
     const theme = useTheme();
     const styles = useThemeStyles();
-    const {processedData, columns, shouldUseNarrowTableLayout} = useTableContext();
+    const {translate} = useLocalize();
+    const {shouldUseNarrowLayout} = useResponsiveLayout();
+    const {processedData, columns, shouldUseNarrowTableLayout, tableMethods, selectionEnabled, isMobileSelectionEnabled} = useTableContext();
 
+    const item = processedData.at(rowIndex);
     const rowCount = processedData.length;
     const isFirstRow = rowIndex === 0;
     const isLastRow = rowIndex === rowCount - 1;
-    const isInteractive = interactive && !isLoading;
-    const gridTemplateColumns = columns.map((column) => (column.width ? `${column.width}px` : '1fr')).join(' ');
+    const isDisabled = !!disabled || !!isLoading;
+    const gridTemplateColumns = columns.map((column) => (column.width ? `${column.width}px` : '1fr'));
+    const isSelectionCheckboxVisible = selectionEnabled && (isMobileSelectionEnabled || !shouldUseNarrowLayout);
+
+    if (selectionEnabled && isSelectionCheckboxVisible) {
+        gridTemplateColumns.unshift(`${variables.tableCheckboxColumnWidth}px`);
+    }
 
     const animatedHighlightStyle = useAnimatedHighlightStyle({
         shouldHighlight: !!shouldAnimateInHighlight,
@@ -75,12 +90,17 @@ export default function TableRow({
         backgroundColor: theme.transparent,
     });
 
+    if (!item) {
+        return null;
+    }
+
     const tableRowPressableStyles = [
         styles.mh5,
         styles.highlightBG,
-        isInteractive && styles.userSelectNone,
+        styles.userSelectNone,
         !isFirstRow && styles.borderTop,
         isLastRow && styles.tableBottomRadius,
+        item.selected && [styles.activeComponentBG, {borderColor: theme.buttonHoveredBG}],
         shouldUseNarrowTableLayout ? styles.tableRowHeightCompact : styles.tableRowHeight,
     ];
 
@@ -102,9 +122,19 @@ export default function TableRow({
         styles.gap3,
         styles.dFlex,
         // Use Grid on web when available (will override flex if supported)
-        !shouldUseNarrowTableLayout && [styles.dGrid, {gridTemplateColumns}],
+        !shouldUseNarrowTableLayout && [styles.dGrid, {gridTemplateColumns: gridTemplateColumns.join(' ')}],
     ];
 
+    const tableRowPressableHoverStyle = (() => {
+        if (isDisabled || !interactive) {
+            return undefined;
+        }
+        if (item.selected) {
+            return styles.activeComponentBG;
+        }
+        return styles.hoveredComponentBG;
+    })();
+
     const renderChildren = (state: PressableStateCallbackType) => {
         if (typeof children === 'function') {
             return children(state);
@@ -113,6 +143,36 @@ export default function TableRow({
         return children;
     };
 
+    const handleCheckboxPress = (event?: GestureResponderEvent | KeyboardEvent | undefined) => {
+        if (event && 'shiftKey' in event && event.shiftKey) {
+            tableMethods.handleMultipleRowSelection(item.keyForList);
+            return;
+        }
+
+        tableMethods.handleSingleRowSelection(item.keyForList);
+    };
+
+    const handleRowPress = (event?: GestureResponderEvent | KeyboardEvent | undefined) => {
+        if (isDisabled || !interactive) {
+            return;
+        }
+
+        if (shouldUseNarrowLayout && isMobileSelectionEnabled) {
+            handleCheckboxPress(event);
+            return;
+        }
+
+        onPress?.();
+    };
+
+    const handleRowLongPress = () => {
+        if (isDisabled || !selectionEnabled || isMobileSelectionEnabled || !shouldUseNarrowLayout || !interactive) {
+            return;
+        }
+
+        tableMethods.setMobileSelectionModalRowKey(item.keyForList);
+    };
+
     return (
         <OfflineWithFeedback
             {...offlineWithFeedback}
@@ -123,11 +183,13 @@ export default function TableRow({
                 accessibilityLabel="row"
                 style={tableRowPressableStyles}
                 sentryLabel={sentryLabel}
-                interactive={isInteractive}
-                pressDimmingValue={isInteractive ? undefined : 1}
-                hoverStyle={isInteractive && styles.hoveredComponentBG}
-                role={isInteractive ? CONST.ROLE.BUTTON : CONST.ROLE.PRESENTATION}
-                onPress={onPress}
+                interactive={interactive}
+                disabled={isDisabled}
+                hoverStyle={tableRowPressableHoverStyle}
+                pressDimmingValue={!interactive ? undefined : 1}
+                role={interactive ? CONST.ROLE.BUTTON : CONST.ROLE.PRESENTATION}
+                onPress={(event) => handleRowPress(event)}
+                onLongPress={handleRowLongPress}
                 {...props}
             >
                 {(state) => (
@@ -144,7 +206,20 @@ export default function TableRow({
                                 </SkeletonViewContentLoader>
                             </View>
                         ) : (
-                            <View style={tableRowContentStyles}>{renderChildren(state)}</View>
+                            <View style={tableRowContentStyles}>
+                                {!!isSelectionCheckboxVisible && (
+                                    <Checkbox
+                                        shouldStopMouseDownPropagation
+                                        containerStyle={styles.m0}
+                                        style={styles.flex1}
+                                        disabled={item.disabled}
+                                        isChecked={!!item.selected}
+                                        accessibilityLabel={translate('common.select')}
+                                        onPress={(event) => handleCheckboxPress(event)}
+                                    />
+                                )}
+                                {renderChildren(state)}
+                            </View>
                         )}
 
                         {!!offlineWithFeedback?.errors && (
diff --git a/src/components/Table/middlewares/filtering.ts b/src/components/Table/middlewares/filtering.ts
index 84a01bbd77e4..aaefcb8d0f95 100644
--- a/src/components/Table/middlewares/filtering.ts
+++ b/src/components/Table/middlewares/filtering.ts
@@ -1,4 +1,5 @@
 import {useState} from 'react';
+import type {TableData} from '@components/Table/types';
 import type {Middleware, MiddlewareHookResult} from './types';
 
 /**
@@ -23,12 +24,12 @@ type FilterConfig<FilterKey extends string = string> = Record<FilterKey, FilterC
 /**
  * Callback to check if an item matches a filter.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @param item - The item to check.
  * @param filters - The filters to check against.
  * @returns True if the item matches the filters, false otherwise.
  */
-type IsItemInFilterCallback<T> = (item: T, filters: string[]) => boolean;
+type IsItemInFilterCallback<DataType extends TableData> = (item: DataType, filters: string[]) => boolean;
 
 /**
  * Methods exposed by the table to control filtering.
@@ -46,34 +47,37 @@ type FilteringMethods<FilterKey extends string = string> = {
 /**
  * Props for the filtering middleware.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @template FilterKey - The type of filter keys.
  */
-type UseFilteringProps<T, FilterKey extends string = string> = {
+type UseFilteringProps<DataType extends TableData, FilterKey extends string = string> = {
     filters?: FilterConfig<FilterKey>;
-    isItemInFilter?: IsItemInFilterCallback<T>;
+    isItemInFilter?: IsItemInFilterCallback<DataType>;
 };
 
 /**
  * Result returned by the filtering middleware.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @template FilterKey - The type of filter keys.
  */
-type UseFilteringResult<T, FilterKey extends string = string> = MiddlewareHookResult<T, FilteringMethods<FilterKey>> & {
+type UseFilteringResult<DataType extends TableData, FilterKey extends string = string> = MiddlewareHookResult<DataType, FilteringMethods<FilterKey>> & {
     currentFilters: Record<FilterKey, unknown>;
 };
 
 /**
  * Provides functionality to filter table data.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @template FilterKey - The type of filter keys.
  * @param filters - The filters to use.
  * @param isItemInFilter - The callback to check if an item matches a filter.
  * @returns The result of the filtering middleware.
  */
-function useFiltering<T, FilterKey extends string = string>({filters, isItemInFilter}: UseFilteringProps<T, FilterKey>): UseFilteringResult<T, FilterKey> {
+function useFiltering<DataType extends TableData, FilterKey extends string = string>({
+    filters,
+    isItemInFilter,
+}: UseFilteringProps<DataType, FilterKey>): UseFilteringResult<DataType, FilterKey> {
     const [currentFilters, setCurrentFilters] = useState<Record<FilterKey, unknown>>(() => {
         const initialFilters = {} as Record<FilterKey, unknown>;
 
@@ -97,7 +101,7 @@ function useFiltering<T, FilterKey extends string = string>({filters, isItemInFi
         return currentFilters;
     };
 
-    const middleware: Middleware<T> = (data) => filter({data, filters, currentFilters, isItemInFilter});
+    const middleware: Middleware<DataType> = (data) => filter({data, filters, currentFilters, isItemInFilter});
 
     const methods: FilteringMethods<FilterKey> = {
         updateFilter,
@@ -110,20 +114,20 @@ function useFiltering<T, FilterKey extends string = string>({filters, isItemInFi
 /**
  * Parameters for the filtering middleware.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @template FilterKey - The type of filter keys.
  */
-type FilteringMiddlewareParams<T, FilterKey extends string = string> = {
-    data: T[];
+type FilteringMiddlewareParams<DataType extends TableData, FilterKey extends string = string> = {
+    data: DataType[];
     filters?: FilterConfig<FilterKey>;
     currentFilters: Record<FilterKey, unknown>;
-    isItemInFilter?: IsItemInFilterCallback<T>;
+    isItemInFilter?: IsItemInFilterCallback<DataType>;
 };
 
 /**
  * Filters table data based on the current filters.
  *
- * @template T - The type of items in the data array.
+ * @template DataType - The type of items in the data array.
  * @template FilterKey - The type of filter keys.
  * @param data - The data to filter.
  * @param filters - The filters to use.
@@ -131,7 +135,7 @@ type FilteringMiddlewareParams<T, FilterKey extends string = string> = {
  * @param isItemInFilter - The callback to check if an item matches a filter.
  * @returns The filtered data.
  */
-function filter<T, FilterKey extends string = string>({data, filters, currentFilters, isItemInFilter}: FilteringMiddlewareParams<T, FilterKey>): T[] {
+function filter<DataType extends TableData, FilterKey extends string = string>({data, filters, currentFilters, isItemInFilter}: FilteringMiddlewareParams<DataType, FilterKey>): DataType[] {
     if (!filters) {
         // No filters configured, return original data.
         return data;
diff --git a/src/components/Table/middlewares/selection.ts b/src/components/Table/middlewares/selection.ts
new file mode 100644
index 000000000000..3bfefd6efff1
--- /dev/null
+++ b/src/components/Table/middlewares/selection.ts
@@ -0,0 +1,188 @@
+import type {Dispatch, SetStateAction} from 'react';
+import {useEffect, useRef, useState} from 'react';
+import type {TableData, TableRow} from '@components/Table/types';
+import useMobileSelectionMode from '@hooks/useMobileSelectionMode';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import {turnOffMobileSelectionMode, turnOnMobileSelectionMode} from '@libs/actions/MobileSelectionMode';
+import type {MiddlewareHookResult} from './types';
+
+type UseSelectionProps<DataType extends TableData> = {
+    /** The data being used in the table */
+    data: DataType[];
+
+    /** The list of selected keys */
+    selectedKeys: string[];
+
+    /** Callback that is fired when the selection of rows in the table changes */
+    onRowSelectionChange?: (selectedRowKeys: string[]) => void;
+};
+
+type SelectionMethods = {
+    /** Callback to either select or unselect all rows in the table */
+    handleSelectAll: () => void;
+
+    /** Callback to select multiple rows in the table, while holding shift and clicking on a row */
+    handleMultipleRowSelection: (keyForList: string) => void;
+
+    /** Callback to select a single row in the table */
+    handleSingleRowSelection: (keyForList: string) => void;
+
+    /** Clear all of the currently selected rows in the table */
+    clearSelection: () => void;
+
+    /** Set whether or not the mobile selection modal is visible */
+    setMobileSelectionModalRowKey: Dispatch<SetStateAction<string | null>>;
+};
+
+type UseSelectionResult<DataType extends TableData> = MiddlewareHookResult<DataType, SelectionMethods, TableRow<DataType>> & {
+    /** Whether or not the mobile selection modal is visible */
+    mobileSelectionModalRowKey: string | null;
+};
+
+export default function useSelection<DataType extends TableData>({data, selectedKeys, onRowSelectionChange}: UseSelectionProps<DataType>): UseSelectionResult<DataType> {
+    const {shouldUseNarrowLayout} = useResponsiveLayout();
+    const isSelectionModeEnabled = useMobileSelectionMode();
+    const lastSelectedRowKeyRef = useRef<string | null>(null);
+    const lastSelectedRowIsSelectedRef = useRef<boolean>(false);
+
+    // When a user long-presses a row on mobile, store the key of the row that will be selected if
+    // the user confirms the selection
+    const [mobileSelectionModalRowKey, setMobileSelectionModalRowKey] = useState<string | null>(null);
+
+    const selectableKeys = data.filter((item) => !item.disabled).map((item) => item.keyForList);
+    const tableRowData: Array<TableRow<DataType>> = data.map((item) => ({...item, selected: selectedKeys.includes(item.keyForList)}));
+
+    // Automatically disable selection mode when switching to desktop, or enable it when switching to mobile if there are selected rows
+    useEffect(() => {
+        if (shouldUseNarrowLayout && !isSelectionModeEnabled && selectedKeys.length) {
+            turnOnMobileSelectionMode();
+        } else if (!shouldUseNarrowLayout && isSelectionModeEnabled && !selectedKeys.length) {
+            turnOffMobileSelectionMode();
+        }
+    }, [shouldUseNarrowLayout, isSelectionModeEnabled, selectedKeys.length]);
+
+    // When there are no more items to be selected, turn off selection mode on mobile
+    useEffect(() => {
+        if (selectableKeys.length || !isSelectionModeEnabled) {
+            return;
+        }
+
+        turnOffMobileSelectionMode();
+    }, [selectableKeys.length, isSelectionModeEnabled]);
+
+    /**
+     * Clear all of the currently selected keys
+     */
+    const clearSelection = () => {
+        onRowSelectionChange?.([]);
+    };
+
+    /**
+     * When the select all checkbox is toggled, select or deselect all of the
+     * rows in the table
+     */
+    const handleSelectAll = () => {
+        const areAllSelectableRowsSelected = selectableKeys.every((key) => selectedKeys.includes(key));
+
+        const isSelectionEmpty = selectedKeys.length === 0;
+        const isSelectionFull = areAllSelectableRowsSelected;
+        const isSelectionIndeterminate = selectedKeys.length > 0 && !areAllSelectableRowsSelected;
+
+        if (isSelectionEmpty) {
+            onRowSelectionChange?.(selectableKeys);
+        } else if (isSelectionFull || isSelectionIndeterminate) {
+            onRowSelectionChange?.([]);
+        }
+    };
+
+    /**
+     * When a single row is selected in the table, update the selection state to toggle the selection either
+     * on or off
+     */
+    const handleSingleRowSelection = (keyForList: string) => {
+        const keyIndex = selectedKeys.indexOf(keyForList);
+        const isCurrentlySelected = keyIndex !== -1;
+
+        lastSelectedRowKeyRef.current = keyForList;
+        lastSelectedRowIsSelectedRef.current = !isCurrentlySelected;
+
+        if (isCurrentlySelected) {
+            onRowSelectionChange?.([...selectedKeys.slice(0, keyIndex), ...selectedKeys.slice(keyIndex + 1)]);
+            return;
+        }
+
+        onRowSelectionChange?.([...selectedKeys, keyForList]);
+    };
+
+    /**
+     * When a row is selected, while holding shift, select all of the rows in-between
+     * the last selected row and the current row
+     */
+    const handleMultipleRowSelection = (keyForList: string) => {
+        const keyForListExists = selectableKeys.includes(keyForList);
+
+        if (!keyForListExists) {
+            return;
+        }
+
+        const lastSelectedRowKey = lastSelectedRowKeyRef.current;
+        const lastSelectedRowIsSelected = lastSelectedRowIsSelectedRef.current;
+
+        if (!lastSelectedRowKey) {
+            handleSingleRowSelection(keyForList);
+            return;
+        }
+
+        const currentSelectedRowIndex = selectableKeys.indexOf(keyForList);
+        const lastSelectedRowIndex = selectableKeys.indexOf(lastSelectedRowKey);
+
+        if (currentSelectedRowIndex === -1 || lastSelectedRowIndex === -1) {
+            handleSingleRowSelection(keyForList);
+            return;
+        }
+
+        const endIndex = Math.max(currentSelectedRowIndex, lastSelectedRowIndex);
+        const startIndex = Math.min(currentSelectedRowIndex, lastSelectedRowIndex);
+
+        const newSelectedKeys = [...selectedKeys];
+
+        for (let i = startIndex; i <= endIndex; i++) {
+            const key = selectableKeys.at(i);
+
+            if (!key) {
+                continue;
+            }
+
+            if (lastSelectedRowIsSelected) {
+                if (!newSelectedKeys.includes(key)) {
+                    newSelectedKeys.push(key);
+                }
+            } else {
+                const index = newSelectedKeys.indexOf(key);
+                if (index !== -1) {
+                    newSelectedKeys.splice(index, 1);
+                }
+            }
+        }
+
+        onRowSelectionChange?.(newSelectedKeys);
+    };
+
+    const middleware = () => {
+        return tableRowData;
+    };
+
+    return {
+        middleware,
+        mobileSelectionModalRowKey,
+        methods: {
+            handleSelectAll,
+            handleMultipleRowSelection,
+            handleSingleRowSelection,
+            clearSelection,
+            setMobileSelectionModalRowKey,
+        },
+    };
+}
+
+export type {SelectionMethods, UseSelectionProps, UseSelectionResult};
diff --git a/src/components/Table/middlewares/types.ts b/src/components/Table/middlewares/types.ts
index af4af5589929..80c0922936b9 100644
--- a/src/components/Table/middlewares/types.ts
+++ b/src/components/Table/middlewares/types.ts
@@ -3,19 +3,15 @@
  *
  * Middlewares are pure functions that receive data and return transformed data.
  * They are chained together in a pipeline: filter → search → sort.
- *
- * @template T - The type of items in the data array.
  */
-type Middleware<T> = (data: T[]) => T[];
+type Middleware<InputDataType, OutputDataType = InputDataType> = (data: InputDataType[]) => OutputDataType[];
 
 /**
  * Result returned by a middleware hook.
- *
- * @template T - The type of items in the data array.
  */
-type MiddlewareHookResult<T, Methods> = {
+type MiddlewareHookResult<InputDataType, Methods, OutputDataType = InputDataType> = {
     /** The middleware function to apply to data. */
-    middleware: Middleware<T>;
+    middleware: Middleware<InputDataType, OutputDataType>;
 
     /** Optional methods exposed by the middleware for external control. */
     methods: Methods;
diff --git a/src/components/Table/types.ts b/src/components/Table/types.ts
index 4944fc870bfc..834fad6a2ed9 100644
--- a/src/components/Table/types.ts
+++ b/src/components/Table/types.ts
@@ -3,8 +3,20 @@ import type {PropsWithChildren} from 'react';
 import type {StyleProp, TextStyle, ViewStyle} from 'react-native';
 import type {FilterConfig, FilteringMethods, IsItemInFilterCallback} from './middlewares/filtering';
 import type {IsItemInSearchCallback, SearchingMethods} from './middlewares/searching';
+import type {SelectionMethods} from './middlewares/selection';
 import type {ActiveSorting, CompareItemsCallback, SortingMethods} from './middlewares/sorting';
 
+/**
+ * Defines the required minimum shape for each row of data in the table
+ */
+type TableData = {
+    /** A unique identifier for the row */
+    keyForList: string;
+
+    /** Whether or not the row is disabled. Prevents row selection when the row is disabled */
+    disabled?: boolean;
+};
+
 /**
  * Styling options for a table column.
  */
@@ -31,46 +43,50 @@ type TableColumn<ColumnKey extends string = string> = {
     /** Display label shown in the table header. */
     label: string;
 
-    /** Optional fixed width in pixels. When set, the column uses this width instead of an equal-share `1fr` track. */
-    width?: number;
+    /** Whether the column is sortable or not */
+    sortable: boolean;
+
+    /** Optional fixed width for the column */
+    width?: number | string;
 
     /** Optional styling configuration for the column. */
     styling?: TableColumnStyling;
+};
 
-    /** Whether or not the column is sortable */
-    sortable: boolean;
+type TableRow<DataType extends TableData> = DataType & {
+    /** Whether or not the row is selected or not */
+    selected: boolean;
 };
 
 /**
  * Methods exposed by the Table component for programmatic control.
  * Combines sorting, filtering, and searching capabilities.
  *
- * @template T - The type of items in the table's data array (unused in methods, kept for consistency).
  * @template ColumnKey - A string literal type representing the valid column keys.
  * @template FilterKey - A string literal type representing the valid filter keys.
  */
-type TableMethods<ColumnKey extends string = string, FilterKey extends string = string> = SortingMethods<ColumnKey> & FilteringMethods<FilterKey> & SearchingMethods;
+type TableMethods<ColumnKey extends string = string, FilterKey extends string = string> = SortingMethods<ColumnKey> & FilteringMethods<FilterKey> & SearchingMethods & SelectionMethods;
 
 /**
  * The ref handle type for the Table component.
  * Provides access to both FlashList methods and custom table control methods.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  * @template ColumnKey - A string literal type representing the valid column keys.
  * @template FilterKey - A string literal type representing the valid filter keys.
  */
-type TableHandle<T, ColumnKey extends string = string, FilterKey extends string = string> = FlashListRef<T> &
+type TableHandle<DataType extends TableData, ColumnKey extends string = string, FilterKey extends string = string> = FlashListRef<DataType> &
     TableMethods<ColumnKey, FilterKey> & {
         /** Method to get all of the processed data after filtering, searching, and sorting have been applied. */
-        getProcessedData: () => T[];
+        getProcessedData: () => Array<TableRow<DataType>>;
     };
 
 /**
  * FlashList props with the 'data' prop omitted, as the Table manages data internally.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  */
-type SharedListProps<T> = Omit<FlashListProps<T>, 'data'>;
+type SharedListProps<DataType extends TableData> = Omit<FlashListProps<DataType>, 'data'>;
 
 /**
  * Props for the Table component.
@@ -79,7 +95,7 @@ type SharedListProps<T> = Omit<FlashListProps<T>, 'data'>;
  * state and provides context, while child components (`<Table.Header>`, `<Table.Body>`,
  * `<Table.SearchBar>`, `<Table.FilterButtons>`) consume that context to render UI.
  *
- * @template T - The type of items in the table's data array.
+ * @template DataType - The type of items in the table's data array.
  * @template ColumnKey - A string literal type representing the valid column keys.
  * @template FilterKey - A string literal type representing the valid filter keys.
  *
@@ -99,13 +115,16 @@ type SharedListProps<T> = Omit<FlashListProps<T>, 'data'>;
  * </Table>
  * ```
  */
-type TableProps<T, ColumnKey extends string = string, FilterKey extends string = string> = SharedListProps<T> &
+type TableProps<DataType extends TableData, ColumnKey extends string = string, FilterKey extends string = string> = SharedListProps<DataType> &
     PropsWithChildren<{
         /** The title for the table when shown on smaller screens */
         title?: string;
 
         /** Array of data items to display in the table. */
-        data: T[] | undefined;
+        data: DataType[] | undefined;
+
+        /** Whether multi selection is enabled */
+        selectionEnabled?: boolean;
 
         /** Column configuration defining what columns to display and how. */
         columns: Array<TableColumn<ColumnKey>>;
@@ -122,27 +141,46 @@ type TableProps<T, ColumnKey extends string = string, FilterKey extends string =
         /** Optional initial search string to apply on mount. */
         initialSearchString?: string;
 
+        /** The list of selected keys for the table, if selection is enabled */
+        selectedKeys?: string[];
+
         /**
          * Comparison function for sorting items.
          * Receives two items and the current sorting configuration, returns a number
          * indicating sort order (negative = a before b, positive = b before a, 0 = equal).
          */
-        compareItems?: CompareItemsCallback<T, ColumnKey>;
+        compareItems?: CompareItemsCallback<DataType, ColumnKey>;
 
         /**
          * Predicate function to determine if an item matches the active filters.
          * Receives an item and an array of active filter values.
          */
-        isItemInFilter?: IsItemInFilterCallback<T>;
+        isItemInFilter?: IsItemInFilterCallback<DataType>;
 
         /**
          * Predicate function to determine if an item matches the search string.
          * Receives an item and the current search string.
          */
-        isItemInSearch?: IsItemInSearchCallback<T>;
+        isItemInSearch?: IsItemInSearchCallback<DataType>;
 
         /** Ref to access table methods programmatically. */
-        ref?: React.Ref<TableHandle<T, ColumnKey, FilterKey>>;
+        ref?: React.Ref<TableHandle<DataType, ColumnKey, FilterKey>>;
+
+        /** Callback when an option is selected */
+        onRowSelectionChange?: (selectedRowKeys: string[]) => void;
     }>;
 
-export type {TableColumn, TableMethods, TableHandle, TableProps, SharedListProps, CompareItemsCallback, IsItemInFilterCallback, IsItemInSearchCallback, FilterConfig, ActiveSorting};
+export type {
+    TableData,
+    TableRow,
+    TableColumn,
+    TableMethods,
+    TableHandle,
+    TableProps,
+    SharedListProps,
+    CompareItemsCallback,
+    IsItemInFilterCallback,
+    IsItemInSearchCallback,
+    FilterConfig,
+    ActiveSorting,
+};
diff --git a/src/components/Tables/DomainListTable/index.tsx b/src/components/Tables/DomainListTable/index.tsx
index 4bc1f5c692a7..796a9686d5e9 100644
--- a/src/components/Tables/DomainListTable/index.tsx
+++ b/src/components/Tables/DomainListTable/index.tsx
@@ -15,6 +15,7 @@ import DomainListTableRow from './DomainListTableRow';
 type DomainTableColumnKey = 'domains' | 'actions';
 
 type DomainRowData = {
+    keyForList: string;
     domainAccountID: number;
     title: string;
     disabled: boolean;
@@ -38,8 +39,18 @@ export default function DomainListTable({domains}: DomainListTableProps) {
     const shouldUseNarrowTableLayout = shouldUseNarrowLayout || isMediumScreenWidth;
 
     const domainTableColumns: Array<TableColumn<DomainTableColumnKey>> = [
-        {key: 'domains', label: translate('common.domains'), sortable: true},
-        {key: 'actions', width: variables.domainTableActionColumnWidth, label: '', styling: {containerStyles: [styles.justifyContentEnd, styles.pr3]}, sortable: false},
+        {
+            sortable: true,
+            key: 'domains',
+            label: translate('common.domains'),
+        },
+        {
+            sortable: false,
+            key: 'actions',
+            width: variables.domainTableActionColumnWidth,
+            label: '',
+            styling: {containerStyles: [styles.justifyContentEnd, styles.pr3]},
+        },
     ];
 
     const compareTableItems: CompareItemsCallback<DomainRowData> = (item1, item2, activeSorting) => {
diff --git a/src/components/Tables/WorkspaceCategoriesTable/WorkspaceCategoriesTableRow.tsx b/src/components/Tables/WorkspaceCategoriesTable/WorkspaceCategoriesTableRow.tsx
new file mode 100644
index 000000000000..e4e656a80eed
--- /dev/null
+++ b/src/components/Tables/WorkspaceCategoriesTable/WorkspaceCategoriesTableRow.tsx
@@ -0,0 +1,125 @@
+import React from 'react';
+import {View} from 'react-native';
+import Avatar from '@components/Avatar';
+import Icon from '@components/Icon';
+import Switch from '@components/Switch';
+import Table from '@components/Table';
+import TextWithTooltip from '@components/TextWithTooltip';
+import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
+import useLocalize from '@hooks/useLocalize';
+import useTheme from '@hooks/useTheme';
+import useThemeStyles from '@hooks/useThemeStyles';
+import variables from '@styles/variables';
+import CONST from '@src/CONST';
+import type {WorkspaceCategoryTableRowData} from '.';
+
+type WorkspaceCategoriesTableRowProps = {
+    /** Data about the category */
+    item: WorkspaceCategoryTableRowData;
+
+    /** The index of the row relative to all other rows */
+    rowIndex: number;
+
+    /** Whether to use narrow table row layout */
+    shouldUseNarrowTableLayout: boolean;
+
+    /** Whether the GL Code column is visible on web screens or not */
+    shouldShowGLCodeColumn: boolean;
+
+    /** Whether the approver column is visible on web screens or not */
+    shouldShowApproverColumn: boolean;
+};
+
+export default function WorkspaceCategoriesTableRow({rowIndex, shouldUseNarrowTableLayout, shouldShowGLCodeColumn, shouldShowApproverColumn, item}: WorkspaceCategoriesTableRowProps) {
+    const theme = useTheme();
+    const styles = useThemeStyles();
+    const {translate} = useLocalize();
+    const icons = useMemoizedLazyExpensifyIcons(['ArrowRight']);
+
+    const accessibilityLabel = [
+        item.name,
+        item.enabled ? translate('common.enabled') : translate('common.disabled'),
+        shouldShowGLCodeColumn && item.glCode ? `${translate('workspace.categories.glCode')}: ${item.glCode}` : null,
+        shouldShowApproverColumn && item.approverDisplayName ? `${translate('common.approver')}: ${item.approverDisplayName}` : null,
+    ]
+        .filter(Boolean)
+        .join(', ');
+
+    return (
+        <Table.Row
+            interactive
+            rowIndex={rowIndex}
+            disabled={item.disabled}
+            accessibilityLabel={accessibilityLabel}
+            skeletonReasonAttributes={{context: 'categoriesTableRow'}}
+            sentryLabel={CONST.SENTRY_LABEL.WORKSPACE.CATEGORIES.ROW}
+            onPress={item.action}
+            offlineWithFeedback={{
+                errors: item.errors,
+                pendingAction: item.pendingAction,
+                shouldHideOnDelete: false,
+                dismissError: item.dismissError,
+            }}
+        >
+            {({hovered}) => (
+                <>
+                    <View style={[styles.flex1, styles.flexRow, styles.alignItemsCenter]}>
+                        <TextWithTooltip
+                            shouldShowTooltip
+                            numberOfLines={1}
+                            text={item.name}
+                        />
+                    </View>
+
+                    {!shouldUseNarrowTableLayout && shouldShowGLCodeColumn && (
+                        <View style={[styles.flex1, styles.flexRow, styles.alignItemsCenter]}>
+                            <TextWithTooltip
+                                shouldShowTooltip
+                                numberOfLines={1}
+                                text={item.glCode ?? ''}
+                            />
+                        </View>
+                    )}
+
+                    {!shouldUseNarrowTableLayout && shouldShowApproverColumn && (
+                        <View style={[styles.flex1, styles.flexRow, styles.gap2, styles.alignItemsCenter]}>
+                            {!!item.approverDisplayName && !!item.approverAccountID && (
+                                <>
+                                    <Avatar
+                                        name={item.approverDisplayName}
+                                        source={item.approverAvatar}
+                                        type={CONST.ICON_TYPE_AVATAR}
+                                        size={CONST.AVATAR_SIZE.MID_SUBSCRIPT}
+                                    />
+                                    <TextWithTooltip
+                                        shouldShowTooltip
+                                        numberOfLines={1}
+                                        text={item.approverDisplayName ?? ''}
+                                    />
+                                </>
+                            )}
+                        </View>
+                    )}
+
+                    <View style={[styles.justifyContentCenter, styles.alignItemsEnd]}>
+                        <Switch
+                            isOn={item.enabled}
+                            showLockIcon={item.isLocked}
+                            disabled={item.disabled}
+                            accessibilityLabel={`${translate('workspace.categories.enableCategory')}: ${item.name}`}
+                            onToggle={item.onToggleEnabled}
+                        />
+                    </View>
+
+                    <Icon
+                        src={icons.ArrowRight}
+                        fill={theme.icon}
+                        additionalStyles={[styles.justifyContentCenter, styles.alignItemsCenter, (!hovered || item.disabled) && styles.opacitySemiTransparent]}
+                        width={variables.iconSizeNormal}
+                        height={variables.iconSizeNormal}
+                    />
+                </>
+            )}
+        </Table.Row>
+    );
+}
diff --git a/src/components/Tables/WorkspaceCategoriesTable/index.tsx b/src/components/Tables/WorkspaceCategoriesTable/index.tsx
new file mode 100644
index 000000000000..8309fcda77f2
--- /dev/null
+++ b/src/components/Tables/WorkspaceCategoriesTable/index.tsx
@@ -0,0 +1,168 @@
+import type {ListRenderItemInfo} from '@shopify/flash-list';
+import React from 'react';
+import type {CompareItemsCallback, IsItemInSearchCallback, TableColumn, TableData, TableHandle} from '@components/Table';
+import Table from '@components/Table';
+import useLocalize from '@hooks/useLocalize';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import tokenizedSearch from '@libs/tokenizedSearch';
+import type {AvatarSource} from '@libs/UserAvatarUtils';
+import variables from '@styles/variables';
+import CONST from '@src/CONST';
+import type * as OnyxCommon from '@src/types/onyx/OnyxCommon';
+import WorkspaceCategoriesTableRow from './WorkspaceCategoriesTableRow';
+
+type WorkspaceCategoryTableColumnKey = 'name' | 'glCode' | 'approver' | 'enabled' | 'actions';
+
+type WorkspaceCategoryTableRowData = TableData & {
+    name: string;
+    glCode?: string;
+    enabled: boolean;
+    approverAvatar?: AvatarSource;
+    approverAccountID?: number;
+    approverDisplayName?: string;
+    disabled: boolean;
+    errors?: OnyxCommon.Errors;
+    pendingAction?: OnyxCommon.PendingAction;
+    isLocked: boolean;
+    action: () => void;
+    dismissError: () => void;
+    onToggleEnabled: (enabled: boolean) => void;
+};
+
+type WorkspaceCategoriesTableProps = {
+    ref?: React.Ref<TableHandle<WorkspaceCategoryTableRowData, WorkspaceCategoryTableColumnKey, string>> | undefined;
+    categories: WorkspaceCategoryTableRowData[];
+    selectionEnabled: boolean;
+    shouldShowGLCodeColumn: boolean;
+    shouldShowApproverColumn: boolean;
+    selectedKeys: string[];
+    onRowSelectionChange: (selectedRowKeys: string[]) => void;
+    EmptyStateComponent: React.ReactElement;
+};
+
+export default function WorkspaceCategoriesTable({
+    ref,
+    categories,
+    selectedKeys,
+    selectionEnabled,
+    shouldShowGLCodeColumn,
+    shouldShowApproverColumn,
+    onRowSelectionChange,
+    EmptyStateComponent,
+}: WorkspaceCategoriesTableProps) {
+    const styles = useThemeStyles();
+    const {translate, localeCompare} = useLocalize();
+    const {shouldUseNarrowLayout, isMediumScreenWidth} = useResponsiveLayout();
+
+    const categoryTableColumns: Array<TableColumn<WorkspaceCategoryTableColumnKey>> = [
+        {
+            key: 'name',
+            label: translate('common.name'),
+            sortable: true,
+        },
+        ...(shouldShowGLCodeColumn
+            ? [
+                  {
+                      key: 'glCode' as const,
+                      label: translate('workspace.categories.glCode'),
+                      sortable: true,
+                  },
+              ]
+            : []),
+        ...(shouldShowApproverColumn
+            ? [
+                  {
+                      key: 'approver' as const,
+                      label: translate('common.approver'),
+                      sortable: true,
+                  },
+              ]
+            : []),
+        {
+            key: 'enabled',
+            label: translate('common.enabled'),
+            sortable: true,
+            width: variables.tableSwitchColumnWidth,
+            styling: {
+                containerStyles: [styles.justifyContentEnd],
+            },
+        },
+        {
+            key: 'actions',
+            label: '',
+            sortable: false,
+            width: variables.tableCaretColumnWidth,
+        },
+    ];
+
+    const compareItems: CompareItemsCallback<WorkspaceCategoryTableRowData> = (item1, item2, activeSorting) => {
+        const orderMultiplier = activeSorting.order === 'asc' ? 1 : -1;
+
+        if (activeSorting.columnKey === 'approver') {
+            const approver1 = item1.approverDisplayName ?? '';
+            const approver2 = item2.approverDisplayName ?? '';
+            return localeCompare(approver1, approver2) * orderMultiplier;
+        }
+
+        if (activeSorting.columnKey === 'enabled') {
+            const enabled1 = item1.enabled ? 1 : 0;
+            const enabled2 = item2.enabled ? 1 : 0;
+            return (enabled1 - enabled2) * orderMultiplier;
+        }
+
+        if (activeSorting.columnKey === 'glCode') {
+            const glCode1 = item1.glCode ?? '';
+            const glCode2 = item2.glCode ?? '';
+            return localeCompare(glCode1, glCode2) * orderMultiplier;
+        }
+
+        return localeCompare(item1.name, item2.name) * orderMultiplier;
+    };
+
+    const isItemInSearch: IsItemInSearchCallback<WorkspaceCategoryTableRowData> = (item, searchValue) => {
+        const searchLower = searchValue.toLowerCase();
+        const results = tokenizedSearch([item], searchLower, (option) => [option.name, option.glCode ?? '']);
+        return results.length > 0;
+    };
+
+    const renderCategoryItem = ({item, index}: ListRenderItemInfo<WorkspaceCategoryTableRowData>) => (
+        <WorkspaceCategoriesTableRow
+            item={item}
+            rowIndex={index}
+            shouldShowGLCodeColumn={shouldShowGLCodeColumn}
+            shouldShowApproverColumn={shouldShowApproverColumn}
+            shouldUseNarrowTableLayout={shouldUseNarrowLayout || isMediumScreenWidth}
+        />
+    );
+
+    const isEmpty = categories.length === 0;
+
+    return (
+        <Table
+            ref={ref}
+            data={categories}
+            initialSortColumn="name"
+            selectionEnabled={selectionEnabled}
+            title={translate('workspace.common.categories')}
+            columns={categoryTableColumns}
+            compareItems={compareItems}
+            isItemInSearch={isItemInSearch}
+            renderItem={renderCategoryItem}
+            selectedKeys={selectedKeys}
+            keyExtractor={(category) => category.keyForList}
+            onRowSelectionChange={onRowSelectionChange}
+        >
+            {isEmpty && EmptyStateComponent}
+            {!isEmpty && (
+                <>
+                    {categories.length >= CONST.STANDARD_LIST_ITEM_LIMIT && <Table.SearchBar label={translate('workspace.categories.findCategory')} />}
+                    <Table.Header />
+                    <Table.Body />
+                </>
+            )}
+        </Table>
+    );
+}
+
+export type {WorkspaceCategoryTableRowData, WorkspaceCategoryTableColumnKey};
diff --git a/src/components/Tables/WorkspaceCompanyCardsTable/WorkspaceCompanyCardsTableRow.tsx b/src/components/Tables/WorkspaceCompanyCardsTable/WorkspaceCompanyCardsTableRow.tsx
index 2f7c2bedf281..05ce37a59527 100644
--- a/src/components/Tables/WorkspaceCompanyCardsTable/WorkspaceCompanyCardsTableRow.tsx
+++ b/src/components/Tables/WorkspaceCompanyCardsTable/WorkspaceCompanyCardsTableRow.tsx
@@ -4,6 +4,7 @@ import {View} from 'react-native';
 import Button from '@components/Button';
 import Icon from '@components/Icon';
 import ReportActionAvatars from '@components/ReportActionAvatars';
+import type {TableData} from '@components/Table';
 import Table from '@components/Table';
 import Text from '@components/Text';
 import TextWithTooltip from '@components/TextWithTooltip';
@@ -22,19 +23,20 @@ import type {Card, CompanyCardFeed, CompanyCardFeedWithDomainID} from '@src/type
 import type {CardAssignmentData} from '@src/types/onyx/Card';
 import WorkspaceCompanyCardsTableSkeleton from './WorkspaceCompanyCardsTableSkeleton';
 
-type WorkspaceCompanyCardTableRowData = CardAssignmentData & {
-    /** Whether the card is deleted */
-    isCardDeleted: boolean;
+type WorkspaceCompanyCardTableRowData = TableData &
+    CardAssignmentData & {
+        /** Whether the card is deleted */
+        isCardDeleted: boolean;
 
-    /** Whether the card is assigned */
-    isAssigned: boolean;
+        /** Whether the card is assigned */
+        isAssigned: boolean;
 
-    /** Assigned card */
-    assignedCard?: Card;
+        /** Assigned card */
+        assignedCard?: Card;
 
-    /** On dismiss error callback */
-    onDismissError?: () => void;
-};
+        /** On dismiss error callback */
+        onDismissError?: () => void;
+    };
 
 type WorkspaceCompanyCardTableRowProps = {
     /** The workspace company card table item */
diff --git a/src/components/Tables/WorkspaceCompanyCardsTable/index.tsx b/src/components/Tables/WorkspaceCompanyCardsTable/index.tsx
index b56af8ba7bc5..f7cb8d672a3c 100644
--- a/src/components/Tables/WorkspaceCompanyCardsTable/index.tsx
+++ b/src/components/Tables/WorkspaceCompanyCardsTable/index.tsx
@@ -181,6 +181,7 @@ function WorkspaceCompanyCardsTable({
 
               return {
                   cardName,
+                  keyForList: `${cardName}_${assignedCard?.cardID ?? 'unassigned'}_${encryptedCardNumber}`,
                   encryptedCardNumber,
                   customCardName: assignedCard?.cardID && customCardNames?.[assignedCard.cardID] ? customCardNames?.[assignedCard.cardID] : getDefaultCardName(cardholder?.displayName ?? ''),
                   isCardDeleted: assignedCard?.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
diff --git a/src/components/Tables/WorkspaceListTable/index.tsx b/src/components/Tables/WorkspaceListTable/index.tsx
index 4345c94fe14c..d373a159359c 100644
--- a/src/components/Tables/WorkspaceListTable/index.tsx
+++ b/src/components/Tables/WorkspaceListTable/index.tsx
@@ -2,7 +2,7 @@ import type {ListRenderItemInfo} from '@shopify/flash-list';
 import React from 'react';
 import type {ValueOf} from 'type-fest';
 import type {PopoverMenuItem} from '@components/PopoverMenu';
-import type {CompareItemsCallback, IsItemInSearchCallback, TableColumn, TableHandle} from '@components/Table';
+import type {CompareItemsCallback, IsItemInSearchCallback, TableColumn, TableData, TableHandle} from '@components/Table';
 import Table from '@components/Table';
 import useLocalize from '@hooks/useLocalize';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
@@ -18,10 +18,9 @@ import WorkspaceRow from './WorkspaceTableRow';
 
 type WorkspaceTableColumnKey = 'workspaces' | 'owner' | 'type' | 'actions';
 
-type WorkspaceRowData = {
+type WorkspaceRowData = TableData & {
     title: string;
     icon: AvatarSource;
-    disabled: boolean;
     isDefault: boolean;
     isDeleted: boolean;
     isLoadingBill: boolean;
@@ -56,10 +55,28 @@ export default function WorkspaceListTable({ref, workspaces}: WorkspaceListTable
     const shouldUseNarrowTableLayout = shouldUseNarrowLayout || isMediumScreenWidth;
 
     const workspaceTableColumns: Array<TableColumn<WorkspaceTableColumnKey>> = [
-        {key: 'workspaces', label: translate('common.workspaces'), sortable: true},
-        {key: 'owner', label: translate('common.owner'), sortable: true},
-        {key: 'type', label: translate('workspace.common.workspaceType'), sortable: true},
-        {key: 'actions', width: variables.workspaceTableActionColumnWidth, label: '', styling: {containerStyles: [styles.justifyContentEnd, styles.pr3]}, sortable: false},
+        {
+            sortable: true,
+            key: 'workspaces',
+            label: translate('common.workspaces'),
+        },
+        {
+            sortable: true,
+            key: 'owner',
+            label: translate('common.owner'),
+        },
+        {
+            sortable: true,
+            key: 'type',
+            label: translate('workspace.common.workspaceType'),
+        },
+        {
+            sortable: false,
+            key: 'actions',
+            width: variables.workspaceTableActionColumnWidth,
+            label: '',
+            styling: {containerStyles: [styles.justifyContentEnd, styles.pr3]},
+        },
     ];
 
     const compareTableItems: CompareItemsCallback<WorkspaceRowData, WorkspaceTableColumnKey> = (item1, item2, activeSorting) => {
diff --git a/src/components/Tables/WorkspaceRoomsTable/WorkspaceRoomsTableRow.tsx b/src/components/Tables/WorkspaceRoomsTable/WorkspaceRoomsTableRow.tsx
index 8015b76a04a3..aac049417db3 100644
--- a/src/components/Tables/WorkspaceRoomsTable/WorkspaceRoomsTableRow.tsx
+++ b/src/components/Tables/WorkspaceRoomsTable/WorkspaceRoomsTableRow.tsx
@@ -3,6 +3,7 @@ import {View} from 'react-native';
 import Avatar from '@components/Avatar';
 import Icon from '@components/Icon';
 import ReportActionAvatars from '@components/ReportActionAvatars';
+import type {TableData} from '@components/Table';
 import Table from '@components/Table';
 import Text from '@components/Text';
 import TextWithTooltip from '@components/TextWithTooltip';
@@ -14,7 +15,7 @@ import type {AvatarSource} from '@libs/UserUtils';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
 
-type WorkspaceRoomRowData = {
+type WorkspaceRoomRowData = TableData & {
     /** The room reportID */
     reportID: string;
 
diff --git a/src/pages/domain/DomainsListPage.tsx b/src/pages/domain/DomainsListPage.tsx
index e05a8c9cc67d..8277dc1963c4 100644
--- a/src/pages/domain/DomainsListPage.tsx
+++ b/src/pages/domain/DomainsListPage.tsx
@@ -57,6 +57,7 @@ function DomainsListPage() {
             const domainErrors = allDomainErrors?.[`${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domain.accountID}`];
 
             domainRows.push({
+                keyForList: String(domain.accountID),
                 isAdmin: isDomainAdmin,
                 isValidated: domain.validated,
                 domainAccountID: domain.accountID,
diff --git a/src/pages/workspace/WorkspacesListPage.tsx b/src/pages/workspace/WorkspacesListPage.tsx
index 30565a36bd78..0d06bb10dabc 100755
--- a/src/pages/workspace/WorkspacesListPage.tsx
+++ b/src/pages/workspace/WorkspacesListPage.tsx
@@ -578,6 +578,7 @@ function WorkspacesListPage() {
                 const ownerDetails = policyOwnerAccountID && getPersonalDetailsByIDs({accountIDs: [policyOwnerAccountID], currentUserAccountID: currentUserPersonalDetails.accountID}).at(0);
 
                 const pendingWorkspaceRow: WorkspaceRowData = {
+                    keyForList: policyID,
                     policyID,
                     disabled: true,
                     errors: undefined,
@@ -607,6 +608,7 @@ function WorkspacesListPage() {
                 const ownerDetails = policyOwnerAccountID && getPersonalDetailsByIDs({accountIDs: [policyOwnerAccountID], currentUserAccountID: currentUserPersonalDetails.accountID}).at(0);
 
                 const workspaceRow: WorkspaceRowData = {
+                    keyForList: policy.id,
                     policyID: policy.id,
                     disabled: policy.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
                     errors: policy.errors,
diff --git a/src/pages/workspace/categories/WorkspaceCategoriesPage.tsx b/src/pages/workspace/categories/WorkspaceCategoriesPage.tsx
index 8eed58012ccc..3e5e4626d8a8 100644
--- a/src/pages/workspace/categories/WorkspaceCategoriesPage.tsx
+++ b/src/pages/workspace/categories/WorkspaceCategoriesPage.tsx
@@ -1,7 +1,6 @@
 import React, {useCallback, useEffect, useMemo, useState} from 'react';
 import {View} from 'react-native';
 import ActivityIndicator from '@components/ActivityIndicator';
-import Avatar from '@components/Avatar';
 import Button from '@components/Button';
 import ButtonWithDropdownMenu from '@components/ButtonWithDropdownMenu';
 import type {DropdownOption} from '@components/ButtonWithDropdownMenu/types';
@@ -13,14 +12,9 @@ import {ModalActions} from '@components/Modal/Global/ModalContext';
 import RenderHTML from '@components/RenderHTML';
 import ScreenWrapper from '@components/ScreenWrapper';
 import ScrollView from '@components/ScrollView';
-import SearchBar from '@components/SearchBar';
-import TableListItem from '@components/SelectionList/ListItem/TableListItem';
-import type {ListItem} from '@components/SelectionList/types';
-import SelectionListWithModal from '@components/SelectionListWithModal';
-import CustomListHeader from '@components/SelectionListWithModal/CustomListHeader';
-import Switch from '@components/Switch';
+import type {WorkspaceCategoryTableRowData} from '@components/Tables/WorkspaceCategoriesTable';
+import WorkspaceCategoriesTable from '@components/Tables/WorkspaceCategoriesTable';
 import Text from '@components/Text';
-import useAutoTurnSelectionModeOffWhenHasNoActiveOption from '@hooks/useAutoTurnSelectionModeOffWhenHasNoActiveOption';
 import useCleanupSelectedOptions from '@hooks/useCleanupSelectedOptions';
 import useConfirmModal from '@hooks/useConfirmModal';
 import useCurrentUserPersonalDetails from '@hooks/useCurrentUserPersonalDetails';
@@ -36,15 +30,12 @@ import usePolicyData from '@hooks/usePolicyData';
 import usePolicyFeatureWriteAccess from '@hooks/usePolicyFeatureWriteAccess';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useSearchBackPress from '@hooks/useSearchBackPress';
-import useSearchResults from '@hooks/useSearchResults';
 import useShouldDisplayButtonsInSeparateLine from '@hooks/useShouldDisplayButtonsInSeparateLine';
-import useStyleUtils from '@hooks/useStyleUtils';
 import useThemeStyles from '@hooks/useThemeStyles';
 import useWorkspaceDocumentTitle from '@hooks/useWorkspaceDocumentTitle';
 import {isConnectionInProgress, isConnectionUnverified} from '@libs/actions/connections';
 import {turnOffMobileSelectionMode} from '@libs/actions/MobileSelectionMode';
 import {getCategoryApproverRule, getDecodedCategoryName} from '@libs/CategoryUtils';
-import {canUseTouchScreen} from '@libs/DeviceCapabilities';
 import {formatPhoneNumber} from '@libs/LocalePhoneNumber';
 import createDynamicRoute from '@libs/Navigation/helpers/dynamicRoutesUtils/createDynamicRoute';
 import Navigation from '@libs/Navigation/Navigation';
@@ -54,15 +45,14 @@ import {isDisablingOrDeletingLastEnabledCategory} from '@libs/OptionsListUtils';
 import {getPersonalDetailByEmail} from '@libs/PersonalDetailsUtils';
 import {getConnectedIntegration, getCurrentConnectionName, hasAccountingConnections, hasTags, isControlPolicy, shouldShowSyncError} from '@libs/PolicyUtils';
 import type {SkeletonSpanReasonAttributes} from '@libs/telemetry/useSkeletonSpan';
-import tokenizedSearch from '@libs/tokenizedSearch';
 import AccessOrNotFoundWrapper from '@pages/workspace/AccessOrNotFoundWrapper';
-import variables from '@styles/variables';
 import {close} from '@userActions/Modal';
 import {clearCategoryErrors, deleteWorkspaceCategories, downloadCategoriesCSV, openPolicyCategoriesPage, setWorkspaceCategoryEnabled} from '@userActions/Policy/Category';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES, {DYNAMIC_ROUTES} from '@src/ROUTES';
 import SCREENS from '@src/SCREENS';
+import type {PolicyCategories} from '@src/types/onyx';
 import type DeepValueOf from '@src/types/utils/DeepValueOf';
 
 type WorkspaceCategoriesPageProps =
@@ -74,8 +64,7 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
     // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
     const {shouldUseNarrowLayout, isSmallScreenWidth} = useResponsiveLayout();
     const styles = useThemeStyles();
-    const StyleUtils = useStyleUtils();
-    const {translate, localeCompare} = useLocalize();
+    const {translate} = useLocalize();
     const [isDownloadFailureModalVisible, setIsDownloadFailureModalVisible] = useState(false);
     const {showConfirmModal} = useConfirmModal();
     const {environmentURL} = useEnvironment();
@@ -93,12 +82,11 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
     const currentConnectionName = getCurrentConnectionName(policy);
     const isQuickSettingsFlow = route.name === SCREENS.SETTINGS_CATEGORIES.SETTINGS_CATEGORIES_ROOT;
     const currentUserPersonalDetails = useCurrentUserPersonalDetails();
-    const {canWrite: canWriteCategories, showReadOnlyModal, withReadOnlyFallback} = usePolicyFeatureWriteAccess(policy, CONST.POLICY.POLICY_FEATURE.CATEGORIES);
+    const {canWrite: canWriteCategories, showReadOnlyModal} = usePolicyFeatureWriteAccess(policy, CONST.POLICY.POLICY_FEATURE.CATEGORIES);
 
-    const [selectedCategories, setSelectedCategories] = useState<string[]>([]);
+    const [selectedCategoryKeys, setSelectedCategoryKeys] = useState<string[]>([]);
     const canSelectMultiple = canWriteCategories && (isSmallScreenWidth ? isMobileSelectionModeEnabled : true);
     const isControlPolicyWithWideLayout = !shouldUseNarrowLayout && isControlPolicy(policy);
-    const shouldShowApproverColumn = isControlPolicyWithWideLayout && !!policy?.areRulesEnabled;
     const icons = useMemoizedLazyExpensifyIcons(['Checkmark', 'Close', 'Download', 'Gear', 'Plus', 'Table', 'Trashcan']);
     const illustrations = useMemoizedLazyIllustrations(['FolderOpen']);
     const genericIllustration = useGenericEmptyStateIllustration();
@@ -134,15 +122,18 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
 
-    const cleanupSelectedOption = useCallback(() => setSelectedCategories([]), []);
-    useCleanupSelectedOptions(cleanupSelectedOption);
+    const clearTableSelection = useCallback(() => {
+        setSelectedCategoryKeys((prevSelectedCategoryKeys) => (prevSelectedCategoryKeys.length > 0 ? [] : prevSelectedCategoryKeys));
+    }, []);
+
+    useCleanupSelectedOptions(clearTableSelection);
 
     useEffect(() => {
-        if (selectedCategories.length === 0 || !canSelectMultiple) {
+        if (selectedCategoryKeys.length === 0 || !canSelectMultiple) {
             return;
         }
 
-        setSelectedCategories((prevSelectedCategories) => {
+        setSelectedCategoryKeys((prevSelectedCategories) => {
             const newSelectedCategories = [];
 
             for (const categoryName of prevSelectedCategories) {
@@ -166,7 +157,7 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
     }, [policyCategories]);
 
     useSearchBackPress({
-        onClearSelection: () => setSelectedCategories([]),
+        onClearSelection: clearTableSelection,
         onNavigationCallBack: () => Navigation.goBack(backTo),
     });
 
@@ -222,204 +213,85 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
         ],
     );
 
-    const glCodeContainerStyle = useMemo(() => [styles.flex1], [styles.flex1]);
-    const glCodeTextStyle = useMemo(() => [styles.alignSelfStart], [styles.alignSelfStart]);
-    const switchContainerStyle = useMemo(() => [StyleUtils.getMinimumWidth(variables.w72)], [StyleUtils]);
+    const navigateToCategory = useCallback(
+        (category: PolicyCategories[string]) => {
+            const path = isQuickSettingsFlow
+                ? ROUTES.SETTINGS_CATEGORY_SETTINGS.getRoute(policyId, category.name, backTo)
+                : createDynamicRoute(DYNAMIC_ROUTES.WORKSPACE_CATEGORY_SETTINGS.getRoute(category.name));
 
-    const categoryList = useMemo<ListItem[]>(() => {
-        const categories = Object.values(policyCategories ?? {});
-        return categories.reduce<ListItem[]>((acc, value) => {
-            const isDisabled = value.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE;
+            Navigation.navigate(path);
+        },
+        [backTo, isQuickSettingsFlow, policyId],
+    );
 
-            if (!isOffline && isDisabled) {
-                return acc;
+    const handleCategoryToggle = useCallback(
+        (enabled: boolean, category: PolicyCategories[string]) => {
+            if (!canWriteCategories) {
+                showReadOnlyModal();
+                return;
             }
 
-            const approverEmail = shouldShowApproverColumn ? (getCategoryApproverRule(policy?.rules?.approvalRules ?? [], value.name)?.approver ?? '') : '';
-            const approverPersonalDetail = getPersonalDetailByEmail(approverEmail);
-            const {avatar, displayName = approverEmail, accountID} = approverPersonalDetail ?? {};
-            const approverDisplayName = displayName ? formatPhoneNumber(displayName) : '';
-
-            acc.push({
-                text: getDecodedCategoryName(value.name),
-                keyForList: value.name,
-                isDisabled,
-                pendingAction: value.pendingAction,
-                errors: value.errors ?? undefined,
-                rightElement: isControlPolicyWithWideLayout ? (
-                    <>
-                        <View style={glCodeContainerStyle}>
-                            <Text
-                                numberOfLines={1}
-                                style={glCodeTextStyle}
-                            >
-                                {value['GL Code']}
-                            </Text>
-                        </View>
-                        {shouldShowApproverColumn && (
-                            <View style={[glCodeContainerStyle, styles.flexRow, styles.alignItemsCenter]}>
-                                {approverDisplayName ? (
-                                    <>
-                                        <Avatar
-                                            source={avatar}
-                                            name={approverDisplayName}
-                                            avatarID={accountID}
-                                            type={CONST.ICON_TYPE_AVATAR}
-                                            size={CONST.AVATAR_SIZE.SUBSCRIPT}
-                                            containerStyles={[styles.mr3]}
-                                        />
-                                        <Text
-                                            numberOfLines={1}
-                                            style={glCodeTextStyle}
-                                        >
-                                            {approverDisplayName}
-                                        </Text>
-                                    </>
-                                ) : null}
-                            </View>
-                        )}
-                        <View style={switchContainerStyle}>
-                            <Switch
-                                isOn={value.enabled}
-                                disabled={isDisabled || !canWriteCategories}
-                                disabledAction={withReadOnlyFallback()}
-                                accessibilityLabel={`${translate('workspace.categories.enableCategory')}: ${getDecodedCategoryName(value.name)}`}
-                                onToggle={(newValue: boolean) => {
-                                    if (isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [value])) {
-                                        showCannotDeleteOrDisableLastCategoryModal();
-                                        return;
-                                    }
-                                    updateWorkspaceCategoryEnabled(newValue, value.name);
-                                }}
-                                showLockIcon={!canWriteCategories || isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [value])}
-                            />
-                        </View>
-                    </>
-                ) : (
-                    <Switch
-                        isOn={value.enabled}
-                        disabled={isDisabled || !canWriteCategories}
-                        disabledAction={withReadOnlyFallback()}
-                        accessibilityLabel={`${translate('workspace.categories.enableCategory')}: ${getDecodedCategoryName(value.name)}`}
-                        onToggle={(newValue: boolean) => {
-                            if (isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [value])) {
-                                showCannotDeleteOrDisableLastCategoryModal();
-                                return;
-                            }
-                            updateWorkspaceCategoryEnabled(newValue, value.name);
-                        }}
-                        showLockIcon={!canWriteCategories || isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [value])}
-                    />
-                ),
-            });
-
-            return acc;
-        }, []);
-    }, [
-        showCannotDeleteOrDisableLastCategoryModal,
-        policyCategories,
-        isOffline,
-        translate,
-        updateWorkspaceCategoryEnabled,
-        policy,
-        isControlPolicyWithWideLayout,
-        glCodeContainerStyle,
-        glCodeTextStyle,
-        switchContainerStyle,
-        shouldShowApproverColumn,
-        canWriteCategories,
-        withReadOnlyFallback,
-        styles.alignItemsCenter,
-        styles.flexRow,
-        styles.mr3,
-    ]);
+            if (isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [category])) {
+                showCannotDeleteOrDisableLastCategoryModal();
+                return;
+            }
 
-    const filterCategory = useCallback((categoryOption: ListItem, searchInput: string) => {
-        const results = tokenizedSearch([categoryOption], searchInput, (option) => [option.text ?? '', option.alternateText ?? '']);
-        return results.length > 0;
-    }, []);
-    const sortCategories = useCallback(
-        (data: ListItem[]) => {
-            return data.sort((a, b) => localeCompare(a.text ?? '', b?.text ?? ''));
+            updateWorkspaceCategoryEnabled(enabled, category.name);
         },
-        [localeCompare],
+        [canWriteCategories, policy, policyCategories, showCannotDeleteOrDisableLastCategoryModal, showReadOnlyModal, updateWorkspaceCategoryEnabled],
     );
-    const [inputValue, setInputValue, filteredCategoryList] = useSearchResults(categoryList, filterCategory, sortCategories);
 
-    useAutoTurnSelectionModeOffWhenHasNoActiveOption(categoryList);
+    const categories = Object.values(policyCategories ?? {});
 
-    const toggleCategory = useCallback(
-        (category: ListItem) => {
-            setSelectedCategories((prev) => {
-                if (prev.includes(category.keyForList)) {
-                    return prev.filter((key) => key !== category.keyForList);
-                }
-                return [...prev, category.keyForList];
-            });
-        },
-        [setSelectedCategories],
-    );
+    const categoryApproverEmails = useMemo(() => {
+        const approverEmails: Record<string, string> = {};
 
-    const toggleAllCategories = () => {
-        const availableCategories = filteredCategoryList.filter((category) => category.pendingAction !== CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE);
-        const someSelected = availableCategories.some((category) => selectedCategories.includes(category.keyForList));
-        setSelectedCategories(someSelected ? [] : availableCategories.map((item) => item.keyForList));
-    };
+        for (const category of categories) {
+            const approverEmail = getCategoryApproverRule(policy?.rules?.approvalRules ?? [], category.name)?.approver;
 
-    const getCustomListHeader = () => {
-        if (filteredCategoryList.length === 0) {
-            return null;
+            if (approverEmail) {
+                approverEmails[category.name] = approverEmail;
+            }
         }
+        return approverEmails;
+    }, [categories, policy?.rules?.approvalRules]);
 
-        // Show GL Code column only on wide screens for control policies. Approver column additionally requires rules to be enabled
-        if (isControlPolicyWithWideLayout) {
-            const header = (
-                <View style={[styles.flex1, styles.flexRow, styles.justifyContentBetween, canSelectMultiple && styles.pl3]}>
-                    <View style={[styles.flex1, StyleUtils.getPaddingRight(variables.w52 + variables.w12)]}>
-                        <Text style={[styles.textMicroSupporting, styles.alignSelfStart]}>{translate('common.name')}</Text>
-                    </View>
-                    <View style={[styles.flex1, styles.pr16]}>
-                        <Text style={[styles.textMicroSupporting, styles.alignSelfStart]}>{translate('workspace.categories.glCode')}</Text>
-                    </View>
-                    {shouldShowApproverColumn && (
-                        <View style={[styles.flex1, styles.pr16]}>
-                            <Text style={[styles.textMicroSupporting, styles.alignSelfStart]}>{translate('common.approver')}</Text>
-                        </View>
-                    )}
-                    <View style={[StyleUtils.getMinimumWidth(variables.w72), styles.mr5]}>
-                        <Text style={[styles.textMicroSupporting, styles.alignSelfStart]}>{translate('common.enabled')}</Text>
-                    </View>
-                </View>
-            );
+    const shouldShowGLCodeColumn = Object.values(policyCategories ?? {}).some((category) => !!category['GL Code']) && isControlPolicyWithWideLayout;
+    const shouldShowApproverColumn = isControlPolicyWithWideLayout && !!policy?.areRulesEnabled && Object.keys(categoryApproverEmails).length > 0;
+
+    const categoryRows = useMemo<WorkspaceCategoryTableRowData[]>(() => {
+        return categories.reduce<WorkspaceCategoryTableRowData[]>((acc, value) => {
+            const isDisabled = value.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE;
 
-            if (canSelectMultiple) {
-                return header;
+            if (!isOffline && isDisabled) {
+                return acc;
             }
 
-            return <View style={[styles.flexRow, styles.baseListHeaderWrapperStyle]}>{header}</View>;
-        }
+            const approverEmail = shouldShowApproverColumn ? categoryApproverEmails[value.name] : undefined;
+            const approverPersonalDetail = getPersonalDetailByEmail(approverEmail);
+            const {avatar: approverAvatar, displayName = approverEmail, accountID: approverAccountID} = approverPersonalDetail ?? {};
+            const approverDisplayName = displayName ? formatPhoneNumber(displayName) : '';
 
-        return (
-            <CustomListHeader
-                canSelectMultiple={canSelectMultiple}
-                leftHeaderText={translate('common.name')}
-                rightHeaderText={translate('common.enabled')}
-                shouldShowRightCaret
-            />
-        );
-    };
+            acc.push({
+                keyForList: value.name,
+                name: getDecodedCategoryName(value.name),
+                glCode: value['GL Code'],
+                disabled: isDisabled,
+                approverAvatar,
+                approverAccountID,
+                approverDisplayName,
+                enabled: value.enabled,
+                errors: value.errors ?? undefined,
+                pendingAction: value.pendingAction,
+                isLocked: isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, [value]) || !canWriteCategories || isDisabled,
+                action: () => navigateToCategory(value),
+                onToggleEnabled: (enabled: boolean) => handleCategoryToggle(enabled, value),
+                dismissError: () => clearCategoryErrors(policyId, value.name, policyCategories),
+            });
 
-    const navigateToCategorySettings = (category: ListItem) => {
-        if (canWriteCategories && isSmallScreenWidth && isMobileSelectionModeEnabled) {
-            toggleCategory(category);
-            return;
-        }
-        Navigation.navigate(
-            isQuickSettingsFlow
-                ? ROUTES.SETTINGS_CATEGORY_SETTINGS.getRoute(policyId, category.keyForList, backTo)
-                : createDynamicRoute(DYNAMIC_ROUTES.WORKSPACE_CATEGORY_SETTINGS.getRoute(category.keyForList)),
-        );
-    };
+            return acc;
+        }, []);
+    }, [categories, isOffline, shouldShowApproverColumn, categoryApproverEmails, canWriteCategories, policy, policyCategories, navigateToCategory, handleCategoryToggle, policyId]);
 
     const navigateToCategoriesSettings = useCallback(() => {
         Navigation.navigate(createDynamicRoute(isQuickSettingsFlow ? DYNAMIC_ROUTES.SETTINGS_CATEGORIES_SETTINGS.path : DYNAMIC_ROUTES.WORKSPACE_CATEGORIES_SETTINGS.path));
@@ -429,15 +301,11 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
         Navigation.navigate(createDynamicRoute(isQuickSettingsFlow ? DYNAMIC_ROUTES.SETTINGS_CATEGORY_CREATE.path : DYNAMIC_ROUTES.WORKSPACE_CATEGORY_CREATE.path));
     };
 
-    const dismissError = (item: ListItem) => {
-        clearCategoryErrors(policyId, item.keyForList, policyCategories);
-    };
-
     const handleDeleteCategories = () => {
-        if (selectedCategories.length > 0) {
+        if (selectedCategoryKeys.length > 0) {
             deleteWorkspaceCategories(
                 policyData,
-                selectedCategories,
+                selectedCategoryKeys,
                 isSetupCategoryTaskParentReportArchived,
                 setupCategoryTaskReport,
                 setupCategoryTaskParentReport,
@@ -447,9 +315,10 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
             );
         }
 
-        setSelectedCategories([]);
+        clearTableSelection();
     };
-    const hasVisibleCategories = categoryList.some((category) => category.pendingAction !== CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE || isOffline);
+
+    const hasVisibleCategories = categoryRows.some((category) => category.pendingAction !== CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE || isOffline);
 
     const policyHasAccountingConnections = hasAccountingConnections(policy);
 
@@ -542,13 +411,13 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
 
         const options: Array<DropdownOption<DeepValueOf<typeof CONST.POLICY.BULK_ACTION_TYPES>>> = [];
         const isThereAnyAccountingConnection = Object.keys(policy?.connections ?? {}).length !== 0;
-        const selectedCategoriesObject = selectedCategories.map((key) => policyCategories?.[key]);
+        const selectedCategoriesObject = selectedCategoryKeys.map((key) => policyCategories?.[key]);
 
-        if (canWriteCategories && (isSmallScreenWidth ? canSelectMultiple : selectedCategories.length > 0)) {
+        if (canWriteCategories && (isSmallScreenWidth ? canSelectMultiple : selectedCategoryKeys.length > 0)) {
             if (!isThereAnyAccountingConnection) {
                 options.push({
                     icon: icons.Trashcan,
-                    text: translate(selectedCategories.length === 1 ? 'workspace.categories.deleteCategory' : 'workspace.categories.deleteCategories'),
+                    text: translate(selectedCategoryKeys.length === 1 ? 'workspace.categories.deleteCategory' : 'workspace.categories.deleteCategories'),
                     value: CONST.POLICY.BULK_ACTION_TYPES.DELETE,
                     onSelected: async () => {
                         if (isDisablingOrDeletingLastEnabledCategory(policy, policyCategories, selectedCategoriesObject)) {
@@ -557,8 +426,8 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                         }
 
                         const {action} = await showConfirmModal({
-                            title: translate(selectedCategories.length === 1 ? 'workspace.categories.deleteCategory' : 'workspace.categories.deleteCategories'),
-                            prompt: translate(selectedCategories.length === 1 ? 'workspace.categories.deleteCategoryPrompt' : 'workspace.categories.deleteCategoriesPrompt'),
+                            title: translate(selectedCategoryKeys.length === 1 ? 'workspace.categories.deleteCategory' : 'workspace.categories.deleteCategories'),
+                            prompt: translate(selectedCategoryKeys.length === 1 ? 'workspace.categories.deleteCategoryPrompt' : 'workspace.categories.deleteCategoriesPrompt'),
                             confirmText: translate('common.delete'),
                             cancelText: translate('common.cancel'),
                             danger: true,
@@ -570,9 +439,9 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                 });
             }
 
-            const enabledCategories = selectedCategories.filter((categoryName) => policyCategories?.[categoryName]?.enabled);
+            const enabledCategories = selectedCategoryKeys.filter((categoryName) => policyCategories?.[categoryName]?.enabled);
             if (enabledCategories.length > 0) {
-                const categoriesToDisable = selectedCategories
+                const categoriesToDisable = selectedCategoryKeys
                     .filter((categoryName) => policyCategories?.[categoryName]?.enabled)
                     .reduce<Record<string, {name: string; enabled: boolean}>>((acc, categoryName) => {
                         acc[categoryName] = {
@@ -590,7 +459,7 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                             showCannotDeleteOrDisableLastCategoryModal();
                             return;
                         }
-                        setSelectedCategories([]);
+                        clearTableSelection();
                         setWorkspaceCategoryEnabled({
                             policyData,
                             categoriesToUpdate: categoriesToDisable,
@@ -611,9 +480,9 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                 });
             }
 
-            const disabledCategories = selectedCategories.filter((categoryName) => !policyCategories?.[categoryName]?.enabled);
+            const disabledCategories = selectedCategoryKeys.filter((categoryName) => !policyCategories?.[categoryName]?.enabled);
             if (disabledCategories.length > 0) {
-                const categoriesToEnable = selectedCategories
+                const categoriesToEnable = selectedCategoryKeys
                     .filter((categoryName) => !policyCategories?.[categoryName]?.enabled)
                     .reduce<Record<string, {name: string; enabled: boolean}>>((acc, categoryName) => {
                         acc[categoryName] = {
@@ -627,7 +496,7 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                     text: translate(disabledCategories.length === 1 ? 'workspace.categories.enableCategory' : 'workspace.categories.enableCategories'),
                     value: CONST.POLICY.BULK_ACTION_TYPES.ENABLE,
                     onSelected: () => {
-                        setSelectedCategories([]);
+                        clearTableSelection();
                         setWorkspaceCategoryEnabled({
                             policyData,
                             categoriesToUpdate: categoriesToEnable,
@@ -653,11 +522,11 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                     onPress={() => null}
                     shouldAlwaysShowDropdownMenu
                     buttonSize={CONST.DROPDOWN_BUTTON_SIZE.MEDIUM}
-                    customText={translate('workspace.common.selected', {count: selectedCategories.length})}
+                    customText={translate('workspace.common.selected', {count: selectedCategoryKeys.length})}
                     options={options}
                     isSplitButton={false}
                     style={[shouldDisplayButtonsInSeparateLine && styles.flexGrow1, shouldDisplayButtonsInSeparateLine && styles.mb3]}
-                    isDisabled={!selectedCategories.length}
+                    isDisabled={!selectedCategoryKeys.length}
                     sentryLabel={CONST.SENTRY_LABEL.WORKSPACE.CATEGORIES.BULK_ACTIONS_DROPDOWN}
                     testID="WorkspaceCategoriesPage-header-dropdown-menu-button"
                 />
@@ -700,35 +569,26 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
             return;
         }
 
-        setSelectedCategories([]);
-    }, [setSelectedCategories, isMobileSelectionModeEnabled]);
+        clearTableSelection();
+    }, [clearTableSelection, isMobileSelectionModeEnabled]);
 
     const selectionModeHeader = isMobileSelectionModeEnabled && shouldUseNarrowLayout;
 
     const headerContent = (
-        <>
-            <View style={[styles.ph5, styles.pb5, styles.pt3, shouldUseNarrowLayout ? styles.workspaceSectionMobile : styles.workspaceSection]}>
-                {!hasSyncError && isConnectionVerified && currentConnectionName ? (
-                    <ImportedFromAccountingSoftware
-                        policyID={policyId}
-                        currentConnectionName={currentConnectionName}
-                        connectedIntegration={connectedIntegration}
-                        translatedText={translate('workspace.categories.importedFromAccountingSoftware')}
-                    />
-                ) : (
-                    <Text style={[styles.textNormal, styles.colorMuted]}>{translate('workspace.categories.subtitle')}</Text>
-                )}
-            </View>
-            {categoryList.length >= CONST.STANDARD_LIST_ITEM_LIMIT && (
-                <SearchBar
-                    label={translate('workspace.categories.findCategory')}
-                    inputValue={inputValue}
-                    onChangeText={setInputValue}
-                    shouldShowEmptyState={hasVisibleCategories && !isLoading && filteredCategoryList.length === 0}
+        <View style={[styles.ph5, styles.pb5, styles.pt3, shouldUseNarrowLayout ? styles.workspaceSectionMobile : styles.workspaceSection]}>
+            {!hasSyncError && isConnectionVerified && currentConnectionName ? (
+                <ImportedFromAccountingSoftware
+                    policyID={policyId}
+                    currentConnectionName={currentConnectionName}
+                    connectedIntegration={connectedIntegration}
+                    translatedText={translate('workspace.categories.importedFromAccountingSoftware')}
                 />
+            ) : (
+                <Text style={[styles.textNormal, styles.colorMuted]}>{translate('workspace.categories.subtitle')}</Text>
             )}
-        </>
+        </View>
     );
+
     const subtitleText = useMemo(() => {
         if (!policyHasAccountingConnections) {
             return <Text style={[styles.textAlignCenter, styles.textSupporting, styles.textNormal]}>{translate('workspace.categories.emptyCategories.subtitle')}</Text>;
@@ -752,6 +612,35 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
         policyId,
         canWriteCategories,
     ]);
+
+    const emptyStateContent = (
+        <ScrollView contentContainerStyle={[styles.flexGrow1, styles.flexShrink0]}>
+            <GenericEmptyStateComponent
+                {...genericIllustration}
+                title={translate('workspace.categories.emptyCategories.title')}
+                subtitleText={subtitleText}
+                headerStyles={styles.emptyStateCardIllustrationContainer}
+                buttons={
+                    !policyHasAccountingConnections
+                        ? [
+                              {
+                                  icon: icons.Table,
+                                  buttonText: translate('common.import'),
+                                  buttonAction: navigateToImportSpreadsheet,
+                              },
+                              {
+                                  icon: icons.Plus,
+                                  buttonText: translate('workspace.categories.addCategory'),
+                                  buttonAction: navigateToCreateCategoryPage,
+                                  success: true,
+                              },
+                          ]
+                        : undefined
+                }
+            />
+        </ScrollView>
+    );
+
     return (
         <AccessOrNotFoundWrapper
             accessVariants={[CONST.POLICY.ACCESS_VARIANTS.ADMIN, CONST.POLICY.ACCESS_VARIANTS.PAID]}
@@ -775,7 +664,7 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                     shouldDisplayHelpButton
                     onBackButtonPress={() => {
                         if (isMobileSelectionModeEnabled) {
-                            setSelectedCategories([]);
+                            clearTableSelection();
                             turnOffMobileSelectionMode();
                             return;
                         }
@@ -791,7 +680,9 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                     {!shouldDisplayButtonsInSeparateLine && getHeaderButtons()}
                 </HeaderWithBackButton>
                 {shouldDisplayButtonsInSeparateLine && !!getHeaderButtons() && <View style={[styles.pl5, styles.pr5]}>{getHeaderButtons()}</View>}
+
                 {(!hasVisibleCategories || isLoading) && headerContent}
+
                 {isLoading && (
                     <ActivityIndicator
                         size={CONST.ACTIVITY_INDICATOR_SIZE.LARGE}
@@ -799,54 +690,34 @@ function WorkspaceCategoriesPage({route}: WorkspaceCategoriesPageProps) {
                         reasonAttributes={reasonAttributes}
                     />
                 )}
-                {hasVisibleCategories && !isLoading && (
-                    <SelectionListWithModal
-                        data={filteredCategoryList}
-                        ListItem={TableListItem}
-                        onSelectionButtonPress={toggleCategory}
-                        selectedItems={selectedCategories}
-                        onSelectRow={navigateToCategorySettings}
-                        onTurnOnSelectionMode={(item) => item && canWriteCategories && toggleCategory(item)}
-                        onSelectAll={canWriteCategories && filteredCategoryList.length > 0 ? toggleAllCategories : undefined}
-                        shouldPreventDefaultFocusOnSelectRow={!canUseTouchScreen()}
-                        turnOnSelectionModeOnLongPress={canWriteCategories && isSmallScreenWidth}
-                        customListHeader={getCustomListHeader()}
-                        customListHeaderContent={headerContent}
-                        canSelectMultiple={canSelectMultiple}
-                        selectAllAccessibilityLabel={translate('accessibilityHints.selectAllCategories')}
-                        shouldShowListEmptyContent={false}
-                        onDismissError={dismissError}
-                        showScrollIndicator={false}
-                        shouldHeaderBeInsideList
-                        shouldShowRightCaret
-                    />
-                )}
-                {!hasVisibleCategories && !isLoading && inputValue.length === 0 && (
-                    <ScrollView contentContainerStyle={[styles.flexGrow1, styles.flexShrink0]}>
-                        <GenericEmptyStateComponent
-                            {...genericIllustration}
-                            title={translate('workspace.categories.emptyCategories.title')}
-                            subtitleText={subtitleText}
-                            headerStyles={styles.emptyStateCardIllustrationContainer}
-                            buttons={
-                                !policyHasAccountingConnections
-                                    ? [
-                                          {
-                                              icon: icons.Table,
-                                              buttonText: translate('common.import'),
-                                              buttonAction: navigateToImportSpreadsheet,
-                                          },
-                                          {
-                                              icon: icons.Plus,
-                                              buttonText: translate('workspace.categories.addCategory'),
-                                              buttonAction: navigateToCreateCategoryPage,
-                                              success: true,
-                                          },
-                                      ]
-                                    : undefined
-                            }
+
+                {!isLoading && (
+                    <>
+                        {hasVisibleCategories && (
+                            <View style={[styles.ph5, styles.pb5, styles.pt3, shouldUseNarrowLayout ? styles.workspaceSectionMobile : styles.workspaceSection]}>
+                                {!hasSyncError && isConnectionVerified && currentConnectionName ? (
+                                    <ImportedFromAccountingSoftware
+                                        policyID={policyId}
+                                        currentConnectionName={currentConnectionName}
+                                        connectedIntegration={connectedIntegration}
+                                        translatedText={translate('workspace.categories.importedFromAccountingSoftware')}
+                                    />
+                                ) : (
+                                    <Text style={[styles.textNormal, styles.colorMuted]}>{translate('workspace.categories.subtitle')}</Text>
+                                )}
+                            </View>
+                        )}
+
+                        <WorkspaceCategoriesTable
+                            categories={categoryRows}
+                            selectionEnabled={canWriteCategories}
+                            selectedKeys={selectedCategoryKeys}
+                            shouldShowGLCodeColumn={shouldShowGLCodeColumn}
+                            shouldShowApproverColumn={shouldShowApproverColumn}
+                            onRowSelectionChange={(selectedRowKeys) => setSelectedCategoryKeys(selectedRowKeys)}
+                            EmptyStateComponent={emptyStateContent}
                         />
-                    </ScrollView>
+                    </>
                 )}
                 <DecisionModal
                     title={translate('common.downloadFailedTitle')}
diff --git a/src/pages/workspace/rooms/WorkspaceRoomsPage.tsx b/src/pages/workspace/rooms/WorkspaceRoomsPage.tsx
index b4b1b912f814..faa9e387813f 100644
--- a/src/pages/workspace/rooms/WorkspaceRoomsPage.tsx
+++ b/src/pages/workspace/rooms/WorkspaceRoomsPage.tsx
@@ -64,6 +64,7 @@ function WorkspaceRoomsPage({route}: WorkspaceRoomsPageProps) {
     const rooms: WorkspaceRoomRowData[] = (policyReports ?? []).map((report) => {
         const ownerDetails = report.ownerAccountID ? personalDetails?.[report.ownerAccountID] : undefined;
         return {
+            keyForList: report.reportID,
             reportID: report.reportID,
             name: getReportName(report, reportAttributes),
             ownerAccountID: report.ownerAccountID,
diff --git a/src/styles/index.ts b/src/styles/index.ts
index aef9a7f57128..2d434a7a6f2c 100644
--- a/src/styles/index.ts
+++ b/src/styles/index.ts
@@ -3142,7 +3142,6 @@ const staticStyles = (theme: ThemeColors) =>
             height: 28,
             justifyContent: 'center',
             borderRadius: 20,
-            padding: 15,
         },
 
         switchThumb: {
diff --git a/src/styles/variables.ts b/src/styles/variables.ts
index f78b02fa7ded..0e9eaee8ec44 100644
--- a/src/styles/variables.ts
+++ b/src/styles/variables.ts
@@ -128,12 +128,15 @@ export default {
     optionRowHeightCompact: 52,
     tableHeaderContentHeight: 20,
     tableRowHeight: 56,
-    tableRowHeightCompact: 72,
+    tableRowHeightCompact: 60,
     tableRowPaddingVertical: 8,
     tableRowPaddingHorizontal: 12,
     tableGroupRowPaddingVertical: 4,
     tableGroupRowHeight: 36,
     tableSkeletonHeight: 32,
+    tableCheckboxColumnWidth: 20,
+    tableSwitchColumnWidth: 58,
+    tableCaretColumnWidth: 20,
     domainTableActionColumnWidth: 64,
     workspaceTableActionColumnWidth: 64,
     sectionMenuItemHeight: 52,
diff --git a/tests/ui/TableTest.tsx b/tests/ui/TableTest.tsx
index 9781fcb50f57..903982d44407 100644
--- a/tests/ui/TableTest.tsx
+++ b/tests/ui/TableTest.tsx
@@ -135,6 +135,7 @@ jest.mock('@components/Pressable', () => ({
 
 // Sample data types for testing
 type TestItem = {
+    keyForList: string;
     id: string;
     name: string;
     category: string;
@@ -145,11 +146,11 @@ type TestColumnKey = 'name' | 'category' | 'value';
 
 // Sample test data
 const mockData: TestItem[] = [
-    {id: '1', name: 'Apple', category: 'fruit', value: 100},
-    {id: '2', name: 'Banana', category: 'fruit', value: 200},
-    {id: '3', name: 'Carrot', category: 'vegetable', value: 50},
-    {id: '4', name: 'Date', category: 'fruit', value: 150},
-    {id: '5', name: 'Eggplant', category: 'vegetable', value: 75},
+    {keyForList: '1', id: '1', name: 'Apple', category: 'fruit', value: 100},
+    {keyForList: '2', id: '2', name: 'Banana', category: 'fruit', value: 200},
+    {keyForList: '3', id: '3', name: 'Carrot', category: 'vegetable', value: 50},
+    {keyForList: '4', id: '4', name: 'Date', category: 'fruit', value: 150},
+    {keyForList: '5', id: '5', name: 'Eggplant', category: 'vegetable', value: 75},
 ];
 
 const mockColumns: Array<TableColumn<TestColumnKey>> = [
@@ -824,6 +825,7 @@ describe('Table', () => {
     describe('performance and edge cases', () => {
         it('should handle large datasets', () => {
             const largeData: TestItem[] = Array.from({length: 100}, (_, i) => ({
+                keyForList: String(i + 1),
                 id: String(i + 1),
                 name: `Item ${i + 1}`,
                 category: i % 2 === 0 ? 'fruit' : 'vegetable',
diff --git a/tests/ui/WorkspaceCategoriesTest.tsx b/tests/ui/WorkspaceCategoriesTest.tsx
index fc1b6566d71f..d89b6d00c69d 100644
--- a/tests/ui/WorkspaceCategoriesTest.tsx
+++ b/tests/ui/WorkspaceCategoriesTest.tsx
@@ -138,9 +138,8 @@ describe('WorkspaceCategories', () => {
             expect(screen.getByText(SECOND_CATEGORY)).toBeOnTheScreen();
         });
 
-        // Select categories to delete by clicking their checkboxes
-        fireEvent.press(screen.getByTestId(`${CONST.SELECTION_BUTTON_TEST_ID}${FIRST_CATEGORY}`));
-        fireEvent.press(screen.getByTestId(`${CONST.SELECTION_BUTTON_TEST_ID}${SECOND_CATEGORY}`));
+        // Select categories to delete
+        fireEvent.press(screen.getByLabelText(TestHelper.translateLocal('workspace.common.selectAll')));
 
         const dropdownMenuButtonTestID = 'WorkspaceCategoriesPage-header-dropdown-menu-button';
 
@@ -244,9 +243,8 @@ describe('WorkspaceCategories', () => {
             expect(screen.getByText(SECOND_CATEGORY)).toBeOnTheScreen();
         });
 
-        // Select categories to disable by clicking their checkboxes
-        fireEvent.press(screen.getByTestId(`${CONST.SELECTION_BUTTON_TEST_ID}${FIRST_CATEGORY}`));
-        fireEvent.press(screen.getByTestId(`${CONST.SELECTION_BUTTON_TEST_ID}${SECOND_CATEGORY}`));
+        // Select categories to disable
+        fireEvent.press(screen.getByLabelText(TestHelper.translateLocal('workspace.common.selectAll')));
 
         const dropdownMenuButtonTestID = 'WorkspaceCategoriesPage-header-dropdown-menu-button';