diff --git a/change/@ni-nimble-components-df1cc26c-9976-477a-8fa0-f9b72492eaa0.json b/change/@ni-nimble-components-df1cc26c-9976-477a-8fa0-f9b72492eaa0.json
new file mode 100644
index 0000000000..362e0db3b6
--- /dev/null
+++ b/change/@ni-nimble-components-df1cc26c-9976-477a-8fa0-f9b72492eaa0.json
@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "Add keyboard navigation functionality to the table component",
+  "packageName": "@ni/nimble-components",
+  "email": "20709258+msmithNI@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}
diff --git a/packages/nimble-components/src/table-column/anchor/cell-view/index.ts b/packages/nimble-components/src/table-column/anchor/cell-view/index.ts
index 9f97ac797a..b124fff803 100644
--- a/packages/nimble-components/src/table-column/anchor/cell-view/index.ts
+++ b/packages/nimble-components/src/table-column/anchor/cell-view/index.ts
@@ -54,9 +54,22 @@ TableColumnAnchorColumnConfig
         return '';
     }
 
+    /** @internal */
+    @volatile
+    public get showAnchor(): boolean {
+        return typeof this.cellRecord?.href === 'string';
+    }
+
     public override focusedRecycleCallback(): void {
         this.anchor?.blur();
     }
+
+    public override get tabbableChildren(): HTMLElement[] {
+        if (this.showAnchor) {
+            return [this.anchor!];
+        }
+        return [];
+    }
 }
 
 const anchorCellView = TableColumnAnchorCellView.compose({
diff --git a/packages/nimble-components/src/table-column/anchor/cell-view/template.ts b/packages/nimble-components/src/table-column/anchor/cell-view/template.ts
index d369615412..5d09e866d8 100644
--- a/packages/nimble-components/src/table-column/anchor/cell-view/template.ts
+++ b/packages/nimble-components/src/table-column/anchor/cell-view/template.ts
@@ -15,10 +15,12 @@ export const template = html<TableColumnAnchorCellView>`
         }}"
         class="${x => (x.isPlaceholder ? 'placeholder' : '')}"
     >
-        ${when(x => typeof x.cellRecord?.href === 'string', html<TableColumnAnchorCellView>`
+        ${when(x => x.showAnchor, html<TableColumnAnchorCellView>`
             <${anchorTag}
                 ${ref('anchor')}
                 ${overflow('hasOverflow')}
+                ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                tabindex="-1"
                 href="${x => x.cellRecord?.href}"
                 hreflang="${x => x.columnConfig?.hreflang}"
                 ping="${x => x.columnConfig?.ping}"
@@ -33,7 +35,7 @@ export const template = html<TableColumnAnchorCellView>`
             >
                 ${x => x.text}
             </${anchorTag}>`)}
-        ${when(x => typeof x.cellRecord?.href !== 'string', html<TableColumnAnchorCellView>`
+        ${when(x => !x.showAnchor, html<TableColumnAnchorCellView>`
             <span
                 ${overflow('hasOverflow')}
                 title=${x => (x.hasOverflow ? x.text : null)}
diff --git a/packages/nimble-components/src/table-column/anchor/tests/table-column-anchor.spec.ts b/packages/nimble-components/src/table-column/anchor/tests/table-column-anchor.spec.ts
index 27b6c2dc5a..205fdfb5a8 100644
--- a/packages/nimble-components/src/table-column/anchor/tests/table-column-anchor.spec.ts
+++ b/packages/nimble-components/src/table-column/anchor/tests/table-column-anchor.spec.ts
@@ -1,5 +1,6 @@
 import { html, ref } from '@microsoft/fast-element';
 import { parameterizeSpec } from '@ni/jasmine-parameterized';
+import { keyArrowDown, keyEscape, keyTab } from '@microsoft/fast-web-utilities';
 import { tableTag, type Table } from '../../../table';
 import { TableColumnAnchor, tableColumnAnchorTag } from '..';
 import { waitForUpdatesAsync } from '../../../testing/async-helpers';
@@ -8,6 +9,7 @@ import { TableColumnSortDirection, TableRecord } from '../../../table/types';
 import { TablePageObject } from '../../../table/testing/table.pageobject';
 import { wackyStrings } from '../../../utilities/tests/wacky-strings';
 import type { Anchor } from '../../../anchor';
+import { sendKeyDownEvent } from '../../../utilities/tests/component';
 
 interface SimpleTableRecord extends TableRecord {
     label?: string | null;
@@ -164,6 +166,16 @@ describe('TableColumnAnchor', () => {
             expect(pageObject.getCellTitle(0, 0)).toBe('');
         });
 
+        it('cell view tabbableChildren is an empty array', async () => {
+            const cellContents = 'value';
+            await table.setData([{ label: cellContents }]);
+            await connect();
+            await waitForUpdatesAsync();
+
+            const cellView = pageObject.getRenderedCellView(0, 0);
+            expect(cellView.tabbableChildren).toEqual([]);
+        });
+
         describe('various string values render as expected', () => {
             parameterizeSpec(wackyStrings, (spec, name) => {
                 spec(`data "${name}" renders correctly`, async () => {
@@ -247,6 +259,16 @@ describe('TableColumnAnchor', () => {
             ).toBeFalse();
         });
 
+        it('cell view tabbableChildren returns the anchor', async () => {
+            await table.setData([{ link: 'foo' }]);
+            await connect();
+            await waitForUpdatesAsync();
+
+            const cellView = pageObject.getRenderedCellView(0, 0);
+            const anchor = pageObject.getRenderedCellAnchor(0, 0);
+            expect(cellView.tabbableChildren).toEqual([anchor]);
+        });
+
         const linkOptionData = [
             { name: 'hreflang', accessor: (x: Anchor) => x.hreflang },
             { name: 'ping', accessor: (x: Anchor) => x.ping },
@@ -616,5 +638,61 @@ describe('TableColumnAnchor', () => {
                 placeholder
             );
         });
+
+        it('for cells with placeholder, cellView tabbableChildren is an empty array', async () => {
+            await initializeColumnAndTable([{}], 'placeholder');
+
+            const cellView = pageObject.getRenderedCellView(0, 0);
+            expect(cellView.tabbableChildren).toEqual([]);
+        });
+    });
+
+    describe('keyboard navigation', () => {
+        beforeEach(async () => {
+            const tableData = [
+                {
+                    id: '1',
+                    label: 'Link 1a',
+                    link: 'http://www.ni.com/a1'
+                }
+            ];
+            await table.setData(tableData);
+            column.groupIndex = null;
+            await connect();
+            await waitForUpdatesAsync();
+            table.focus();
+            await waitForUpdatesAsync();
+        });
+
+        afterEach(async () => {
+            await disconnect();
+        });
+
+        function isAnchorFocused(anchor: Anchor): boolean {
+            return anchor.shadowRoot?.activeElement !== null;
+        }
+
+        describe('with cell[0, 0] focused,', () => {
+            beforeEach(async () => {
+                await sendKeyDownEvent(table, keyArrowDown);
+            });
+
+            it('anchors in cells are reachable via Tab', async () => {
+                await sendKeyDownEvent(table, keyTab);
+
+                expect(
+                    isAnchorFocused(pageObject.getRenderedCellAnchor(0, 0))
+                ).toBe(true);
+            });
+
+            it('when an anchor is focused, pressing Esc will blur the anchor', async () => {
+                await sendKeyDownEvent(table, keyTab);
+                await sendKeyDownEvent(table, keyEscape);
+
+                expect(
+                    isAnchorFocused(pageObject.getRenderedCellAnchor(0, 0))
+                ).toBe(false);
+            });
+        });
     });
 });
diff --git a/packages/nimble-components/src/table-column/base/cell-view/index.ts b/packages/nimble-components/src/table-column/base/cell-view/index.ts
index fcae105db2..37e67d6e05 100644
--- a/packages/nimble-components/src/table-column/base/cell-view/index.ts
+++ b/packages/nimble-components/src/table-column/base/cell-view/index.ts
@@ -29,6 +29,14 @@ export abstract class TableCellView<
     @observable
     public recordId?: string;
 
+    /**
+     * Gets the child elements in this cell view that should be able to be reached via Tab/ Shift-Tab,
+     * if any.
+     */
+    public get tabbableChildren(): HTMLElement[] {
+        return [];
+    }
+
     private delegatedEvents: readonly string[] = [];
 
     /**
diff --git a/packages/nimble-components/src/table/components/cell/index.ts b/packages/nimble-components/src/table/components/cell/index.ts
index 20c215cc81..c2bc7aa0b4 100644
--- a/packages/nimble-components/src/table/components/cell/index.ts
+++ b/packages/nimble-components/src/table/components/cell/index.ts
@@ -9,6 +9,7 @@ import type {
 } from '../../../table-column/base/types';
 import { styles } from './styles';
 import { template } from './template';
+import type { TableCellView } from '../../../table-column/base/cell-view';
 
 declare global {
     interface HTMLElementTagNameMap {
@@ -47,11 +48,21 @@ export class TableCell<
     @observable
     public cellViewTemplate?: ViewTemplate<TableCell>;
 
+    /** @internal */
+    @observable
+    public cellViewContainer!: HTMLElement;
+
     @observable
     public nestingLevel = 0;
 
     public readonly actionMenuButton?: MenuButton;
 
+    /** @internal */
+    public get cellView(): TableCellView<TCellRecord> {
+        return this.cellViewContainer
+            .firstElementChild as TableCellView<TCellRecord>;
+    }
+
     public onActionMenuBeforeToggle(
         event: CustomEvent<MenuButtonToggleEventDetail>
     ): void {
@@ -64,6 +75,22 @@ export class TableCell<
         this.menuOpen = event.detail.newState;
         this.$emit('cell-action-menu-toggle', event.detail);
     }
+
+    public onActionMenuBlur(): void {
+        this.$emit('cell-action-menu-blur', this);
+    }
+
+    public onCellViewFocusIn(): void {
+        this.$emit('cell-view-focus-in', this);
+    }
+
+    public onCellFocusIn(): void {
+        this.$emit('cell-focus-in', this);
+    }
+
+    public onCellBlur(): void {
+        this.$emit('cell-blur', this);
+    }
 }
 
 const nimbleTableCell = TableCell.compose({
diff --git a/packages/nimble-components/src/table/components/cell/styles.ts b/packages/nimble-components/src/table/components/cell/styles.ts
index 55c05ed6a4..7fcb88c73d 100644
--- a/packages/nimble-components/src/table/components/cell/styles.ts
+++ b/packages/nimble-components/src/table/components/cell/styles.ts
@@ -1,10 +1,13 @@
 import { css } from '@microsoft/fast-element';
 import { display } from '../../../utilities/style/display';
 import {
+    borderHoverColor,
+    borderWidth,
     controlHeight,
     controlSlimHeight,
     mediumPadding
 } from '../../../theme-provider/design-tokens';
+import { focusVisible } from '../../../utilities/style/focus';
 
 export const styles = css`
     ${display('flex')}
@@ -22,6 +25,15 @@ export const styles = css`
         --ni-private-table-cell-action-menu-display: block;
     }
 
+    :host(${focusVisible}) {
+        outline: calc(2 * ${borderWidth}) solid ${borderHoverColor};
+        outline-offset: -2px;
+    }
+
+    .cell-view-container {
+        display: contents;
+    }
+
     .cell-view {
         overflow: hidden;
     }
@@ -34,4 +46,11 @@ export const styles = css`
         height: ${controlSlimHeight};
         align-self: center;
     }
+
+    ${
+        /* This CSS class is applied dynamically by KeyboardNavigationManager */ ''
+    }
+    .action-menu.cell-action-menu-focused {
+        display: block;
+    }
 `;
diff --git a/packages/nimble-components/src/table/components/cell/template.ts b/packages/nimble-components/src/table/components/cell/template.ts
index b3a30a4cdd..85b65ab13a 100644
--- a/packages/nimble-components/src/table/components/cell/template.ts
+++ b/packages/nimble-components/src/table/components/cell/template.ts
@@ -10,15 +10,23 @@ import { tableCellActionMenuLabel } from '../../../label-provider/table/label-to
 
 // prettier-ignore
 export const template = html<TableCell>`
-    <template role="cell" style="--ni-private-table-cell-nesting-level: ${x => x.nestingLevel}">
-        ${x => x.cellViewTemplate}
+    <template role="cell" style="--ni-private-table-cell-nesting-level: ${x => x.nestingLevel}"
+        @focusin="${x => x.onCellFocusIn()}"
+        @blur="${x => x.onCellBlur()}"
+    >
+        <div ${ref('cellViewContainer')} class="cell-view-container" @focusin="${x => x.onCellViewFocusIn()}">
+            ${x => x.cellViewTemplate}
+        </div>
         ${when(x => x.hasActionMenu, html<TableCell>`
             <${menuButtonTag} ${ref('actionMenuButton')}
                 content-hidden
                 appearance="${ButtonAppearance.ghost}"
+                ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                tabindex="-1"
                 @beforetoggle="${(x, c) => x.onActionMenuBeforeToggle(c.event as CustomEvent<MenuButtonToggleEventDetail>)}"
                 @toggle="${(x, c) => x.onActionMenuToggle(c.event as CustomEvent<MenuButtonToggleEventDetail>)}"
                 @click="${(_, c) => c.event.stopPropagation()}"
+                @blur="${x => x.onActionMenuBlur()}"
                 class="action-menu"
                 title="${x => (x.actionMenuLabel ? x.actionMenuLabel : tableCellActionMenuLabel.getValueFor(x))}"
             >
diff --git a/packages/nimble-components/src/table/components/cell/tests/table-cell.pageobject.ts b/packages/nimble-components/src/table/components/cell/tests/table-cell.pageobject.ts
index 01912a5499..d7b152b2a0 100644
--- a/packages/nimble-components/src/table/components/cell/tests/table-cell.pageobject.ts
+++ b/packages/nimble-components/src/table/components/cell/tests/table-cell.pageobject.ts
@@ -10,7 +10,7 @@ export class TableCellPageObject<T extends TableCellRecord = TableCellRecord> {
     public constructor(private readonly tableCellElement: TableCell<T>) {}
 
     public getRenderedCellView(): TableCellView {
-        const cellView = this.tableCellElement.shadowRoot!.firstElementChild;
+        const cellView = this.tableCellElement.cellViewContainer.firstElementChild;
         if (!(cellView instanceof TableCellView)) {
             throw new Error(
                 'Cell view not found in cell - ensure cellViewTag is set for column'
diff --git a/packages/nimble-components/src/table/components/cell/tests/table-cell.spec.ts b/packages/nimble-components/src/table/components/cell/tests/table-cell.spec.ts
index cdef2e59f9..e292a8d3ae 100644
--- a/packages/nimble-components/src/table/components/cell/tests/table-cell.spec.ts
+++ b/packages/nimble-components/src/table/components/cell/tests/table-cell.spec.ts
@@ -10,6 +10,7 @@ import type { TableCellRecord } from '../../../../table-column/base/types';
 import { TableCellPageObject } from './table-cell.pageobject';
 import { TableCellView } from '../../../../table-column/base/cell-view';
 import { createCellViewTemplate } from '../../../../table-column/base/cell-view/template';
+import { createEventListener } from '../../../../utilities/tests/component';
 
 interface SimpleTableCellRecord extends TableCellRecord {
     stringData: string;
@@ -79,4 +80,67 @@ describe('TableCell', () => {
         const renderedContent = pageObject.getRenderedCellContent();
         expect(renderedContent).toBe('bar');
     });
+
+    it('fires cell-view-focus-in/cell-focus-in/cell-blur events when cell contents are focused/blurred', async () => {
+        await connect();
+        await waitForUpdatesAsync();
+
+        const cellViewFocusInListener = createEventListener(
+            element,
+            'cell-view-focus-in'
+        );
+        const cellFocusInListener = createEventListener(
+            element,
+            'cell-focus-in'
+        );
+        const cellBlurListener = createEventListener(element, 'cell-blur');
+        const renderedCellView = pageObject.getRenderedCellView();
+        const span = renderedCellView.shadowRoot
+            ?.firstElementChild as HTMLSpanElement;
+        span.tabIndex = 0;
+        span.focus();
+        await cellViewFocusInListener.promise;
+        await cellFocusInListener.promise;
+
+        expect(cellViewFocusInListener.spy).toHaveBeenCalledOnceWith(
+            jasmine.objectContaining({ detail: element })
+        );
+        expect(cellFocusInListener.spy).toHaveBeenCalledOnceWith(
+            jasmine.objectContaining({ detail: element })
+        );
+        expect(cellBlurListener.spy).not.toHaveBeenCalled();
+
+        span.blur();
+        await cellBlurListener.promise;
+
+        expect(cellBlurListener.spy).toHaveBeenCalledOnceWith(
+            jasmine.objectContaining({ detail: element })
+        );
+    });
+
+    it('fires the cell-view-focus-in event when cell contents are focused, after the cell is already focused', async () => {
+        await connect();
+        await waitForUpdatesAsync();
+
+        const cellViewFocusInListener = createEventListener(
+            element,
+            'cell-view-focus-in'
+        );
+        const renderedCellView = pageObject.getRenderedCellView();
+        element.tabIndex = 0;
+        element.focus();
+        await waitForUpdatesAsync();
+
+        expect(cellViewFocusInListener.spy).not.toHaveBeenCalled();
+
+        const span = renderedCellView.shadowRoot
+            ?.firstElementChild as HTMLSpanElement;
+        span.tabIndex = 0;
+        span.focus();
+        await cellViewFocusInListener.promise;
+
+        expect(cellViewFocusInListener.spy).toHaveBeenCalledOnceWith(
+            jasmine.objectContaining({ detail: element })
+        );
+    });
 });
diff --git a/packages/nimble-components/src/table/components/group-row/index.ts b/packages/nimble-components/src/table/components/group-row/index.ts
index 52503a4aee..32b04ea875 100644
--- a/packages/nimble-components/src/table/components/group-row/index.ts
+++ b/packages/nimble-components/src/table/components/group-row/index.ts
@@ -1,16 +1,14 @@
 import { attr, observable } from '@microsoft/fast-element';
-import {
-    Checkbox,
-    DesignSystem,
-    FoundationElement
-} from '@microsoft/fast-foundation';
+import { DesignSystem, FoundationElement } from '@microsoft/fast-foundation';
 import type { TableColumn } from '../../../table-column/base';
 import { styles } from './styles';
 import { template } from './template';
 import {
+    TableRowFocusableElements,
     TableRowSelectionState,
     TableRowSelectionToggleEventDetail
 } from '../../types';
+import type { Checkbox } from '../../../checkbox';
 
 declare global {
     interface HTMLElementTagNameMap {
@@ -29,6 +27,13 @@ export class TableGroupRow extends FoundationElement {
     @observable
     public nestingLevel = 0;
 
+    /**
+     * Row index in the flattened set of all regular and group header rows.
+     * Represents the index in table.tableData (TableRowState[]).
+     */
+    @observable
+    public resolvedRowIndex?: number;
+
     @observable
     public immediateChildCount?: number;
 
@@ -83,7 +88,7 @@ export class TableGroupRow extends FoundationElement {
     }
 
     /** @internal */
-    public onSelectionChange(event: CustomEvent): void {
+    public onSelectionCheckboxChange(event: CustomEvent): void {
         if (this.ignoreSelectionChangeEvents) {
             return;
         }
@@ -100,6 +105,16 @@ export class TableGroupRow extends FoundationElement {
         this.$emit('group-selection-toggle', detail);
     }
 
+    /** @internal */
+    public getFocusableElements(): TableRowFocusableElements {
+        return {
+            selectionCheckbox: this.selectable
+                ? this.selectionCheckbox
+                : undefined,
+            cells: []
+        };
+    }
+
     private selectionStateChanged(): void {
         this.setSelectionCheckboxState();
     }
diff --git a/packages/nimble-components/src/table/components/group-row/styles.ts b/packages/nimble-components/src/table/components/group-row/styles.ts
index 662d30dbe7..cb3c257a11 100644
--- a/packages/nimble-components/src/table/components/group-row/styles.ts
+++ b/packages/nimble-components/src/table/components/group-row/styles.ts
@@ -3,6 +3,7 @@ import { White } from '@ni/nimble-tokens/dist/styledictionary/js/tokens';
 import { display } from '../../../utilities/style/display';
 import {
     applicationBackgroundColor,
+    borderHoverColor,
     borderWidth,
     controlHeight,
     fillHoverColor,
@@ -14,6 +15,7 @@ import { hexToRgbaCssColor } from '../../../utilities/style/colors';
 import { themeBehavior } from '../../../utilities/style/theme';
 import { userSelectNone } from '../../../utilities/style/user-select';
 import { styles as expandCollapseStyles } from '../../../patterns/expand-collapse/styles';
+import { focusVisible } from '../../../utilities/style/focus';
 
 export const styles = css`
     ${display('grid')}
@@ -54,6 +56,11 @@ export const styles = css`
         background-color: ${fillHoverColor};
     }
 
+    :host(${focusVisible}) {
+        outline: calc(2 * ${borderWidth}) solid ${borderHoverColor};
+        outline-offset: calc(-2 * ${borderWidth});
+    }
+
     .expand-collapse-button {
         margin-left: calc(
             ${mediumPadding} + ${standardPadding} * 2 *
diff --git a/packages/nimble-components/src/table/components/group-row/template.ts b/packages/nimble-components/src/table/components/group-row/template.ts
index c13a8b707e..43ce72a177 100644
--- a/packages/nimble-components/src/table/components/group-row/template.ts
+++ b/packages/nimble-components/src/table/components/group-row/template.ts
@@ -24,7 +24,7 @@ export const template = html<TableGroupRow>`
                 <${checkboxTag}
                     ${ref('selectionCheckbox')}
                     class="selection-checkbox"
-                    @change="${(x, c) => x.onSelectionChange(c.event as CustomEvent)}"
+                    @change="${(x, c) => x.onSelectionCheckboxChange(c.event as CustomEvent)}"
                     @click="${(_, c) => c.event.stopPropagation()}"
                     title="${x => tableGroupSelectAllLabel.getValueFor(x)}"
                     aria-label="${x => tableGroupSelectAllLabel.getValueFor(x)}"
diff --git a/packages/nimble-components/src/table/components/group-row/tests/table-group-row.spec.ts b/packages/nimble-components/src/table/components/group-row/tests/table-group-row.spec.ts
index 109045b2ed..702eb03754 100644
--- a/packages/nimble-components/src/table/components/group-row/tests/table-group-row.spec.ts
+++ b/packages/nimble-components/src/table/components/group-row/tests/table-group-row.spec.ts
@@ -197,4 +197,32 @@ describe('TableGroupRow', () => {
 
         expect(element.getAttribute('aria-expanded')).toBe('false');
     });
+
+    it('getFocusableElements() includes an empty array for cells', async () => {
+        await connect();
+
+        const focusableElements = element.getFocusableElements();
+        expect(focusableElements.cells).toEqual([]);
+    });
+
+    it('getFocusableElements() includes the selection checkbox when row is selectable', async () => {
+        element.selectable = true;
+        await connect();
+
+        const focusableElements = element.getFocusableElements();
+        expect(focusableElements.selectionCheckbox).toBe(
+            element.selectionCheckbox
+        );
+    });
+
+    it('if row is set to selectable then subsequently not selectable, getFocusableElements() does not include a selection checkbox', async () => {
+        element.selectable = true;
+        await connect();
+        await waitForUpdatesAsync();
+        element.selectable = false;
+        await waitForUpdatesAsync();
+
+        const focusableElements = element.getFocusableElements();
+        expect(focusableElements.selectionCheckbox).toBeUndefined();
+    });
 });
diff --git a/packages/nimble-components/src/table/components/header/styles.ts b/packages/nimble-components/src/table/components/header/styles.ts
index 465763ec63..8d70a428d4 100644
--- a/packages/nimble-components/src/table/components/header/styles.ts
+++ b/packages/nimble-components/src/table/components/header/styles.ts
@@ -1,12 +1,15 @@
 import { css } from '@microsoft/fast-element';
 import { display } from '../../../utilities/style/display';
 import {
+    borderHoverColor,
+    borderWidth,
     controlHeight,
     iconColor,
     mediumPadding,
     tableHeaderFont,
     tableHeaderFontColor
 } from '../../../theme-provider/design-tokens';
+import { focusVisible } from '../../../utilities/style/focus';
 
 export const styles = css`
     ${display('flex')}
@@ -23,6 +26,11 @@ export const styles = css`
         cursor: default;
     }
 
+    :host(${focusVisible}) {
+        outline: calc(2 * ${borderWidth}) solid ${borderHoverColor};
+        outline-offset: calc(-2 * ${borderWidth});
+    }
+
     .sort-indicator,
     .grouped-indicator {
         flex: 0 0 auto;
diff --git a/packages/nimble-components/src/table/components/row/index.ts b/packages/nimble-components/src/table/components/row/index.ts
index ec4cb5b7c5..96a6f538a9 100644
--- a/packages/nimble-components/src/table/components/row/index.ts
+++ b/packages/nimble-components/src/table/components/row/index.ts
@@ -5,11 +5,7 @@ import {
     observable,
     volatile
 } from '@microsoft/fast-element';
-import {
-    Checkbox,
-    DesignSystem,
-    FoundationElement
-} from '@microsoft/fast-foundation';
+import { DesignSystem, FoundationElement } from '@microsoft/fast-foundation';
 import { styles } from './styles';
 import { template } from './template';
 import type { TableCellState } from '../../../table-column/base/types';
@@ -18,15 +14,17 @@ import type {
     TableFieldName,
     TableRecord,
     TableRowExpansionToggleEventDetail,
+    TableRowFocusableElements,
     TableRowSelectionToggleEventDetail
 } from '../../types';
 import type { TableColumn } from '../../../table-column/base';
 import type { MenuButtonToggleEventDetail } from '../../../menu-button/types';
-import { TableCell } from '../cell';
+import { TableCell, tableCellTag } from '../cell';
 import {
     ColumnInternals,
     isColumnInternalsProperty
 } from '../../../table-column/base/models/column-internals';
+import type { Checkbox } from '../../../checkbox';
 
 declare global {
     interface HTMLElementTagNameMap {
@@ -77,6 +75,13 @@ export class TableRow<
     @observable
     public nestingLevel = 0;
 
+    /**
+     * Row index in the flattened set of all regular and group header rows.
+     * Represents the index in table.tableData (TableRowState[]).
+     */
+    @observable
+    public resolvedRowIndex?: number;
+
     @attr({ attribute: 'is-parent-row', mode: 'boolean' })
     public isParentRow = false;
 
@@ -133,6 +138,12 @@ export class TableRow<
         return this.isParentRow && this.nestingLevel > 0;
     }
 
+    /** @internal */
+    @volatile
+    public get showSelectionCheckbox(): boolean {
+        return this.selectable && !this.hideSelection;
+    }
+
     // Programmatically updating the selection state of a checkbox fires the 'change' event.
     // Therefore, selection change events that occur due to programmatically updating
     // the selection checkbox 'checked' value should be ingored.
@@ -149,17 +160,22 @@ export class TableRow<
     }
 
     /** @internal */
-    public onSelectionChange(event: CustomEvent): void {
+    public onSelectionCheckboxChange(event: CustomEvent): void {
         if (this.ignoreSelectionChangeEvents) {
             return;
         }
 
         const checkbox = event.target as Checkbox;
         const checked = checkbox.checked;
-        this.selected = checked;
+        this.onSelectionChange(!checked, checked);
+    }
+
+    /** @internal */
+    public onSelectionChange(oldState: boolean, newState: boolean): void {
+        this.selected = newState;
         const detail: TableRowSelectionToggleEventDetail = {
-            oldState: !checked,
-            newState: checked
+            oldState,
+            newState
         };
         this.$emit('row-selection-toggle', detail);
     }
@@ -213,14 +229,31 @@ export class TableRow<
         }
     }
 
-    public onRowExpandToggle(event: Event): void {
+    /** @internal */
+    public getFocusableElements(): TableRowFocusableElements {
+        return {
+            selectionCheckbox: this.showSelectionCheckbox
+                ? this.selectionCheckbox
+                : undefined,
+            cells: Array.from(
+                this.cellContainer.querySelectorAll(tableCellTag)
+            ).map(cell => ({
+                cell,
+                actionMenuButton: cell.hasActionMenu
+                    ? cell.actionMenuButton
+                    : undefined
+            }))
+        };
+    }
+
+    public onRowExpandToggle(event?: Event): void {
         const expandEventDetail: TableRowExpansionToggleEventDetail = {
             oldState: this.expanded,
             newState: !this.expanded,
             recordId: this.recordId!
         };
         this.$emit('row-expand-toggle', expandEventDetail);
-        event.stopImmediatePropagation();
+        event?.stopImmediatePropagation();
         // To avoid a visual glitch with improper expand/collapse icons performing an
         // animation (due to visual re-use apparently), we apply a class to the
         // contained expand-collapse button temporarily. We use the 'transitionend' event
diff --git a/packages/nimble-components/src/table/components/row/styles.ts b/packages/nimble-components/src/table/components/row/styles.ts
index d880cc944d..c75ff6161d 100644
--- a/packages/nimble-components/src/table/components/row/styles.ts
+++ b/packages/nimble-components/src/table/components/row/styles.ts
@@ -3,6 +3,7 @@ import { White } from '@ni/nimble-tokens/dist/styledictionary/js/tokens';
 import { display } from '../../../utilities/style/display';
 import {
     applicationBackgroundColor,
+    borderHoverColor,
     borderWidth,
     controlHeight,
     controlSlimHeight,
@@ -10,12 +11,14 @@ import {
     fillHoverSelectedColor,
     fillSelectedColor,
     mediumPadding,
+    smallPadding,
     standardPadding
 } from '../../../theme-provider/design-tokens';
 import { Theme } from '../../../theme-provider/types';
 import { hexToRgbaCssColor } from '../../../utilities/style/colors';
 import { themeBehavior } from '../../../utilities/style/theme';
 import { styles as expandCollapseStyles } from '../../../patterns/expand-collapse/styles';
+import { focusVisible } from '../../../utilities/style/focus';
 
 export const styles = css`
     ${display('flex')}
@@ -51,6 +54,11 @@ export const styles = css`
         background-color: ${fillHoverSelectedColor};
     }
 
+    :host(${focusVisible}) {
+        outline: calc(2 * ${borderWidth}) solid ${borderHoverColor};
+        outline-offset: calc(-2 * ${borderWidth});
+    }
+
     .expand-collapse-button {
         flex: 0 0 auto;
         margin-left: max(
@@ -125,6 +133,34 @@ export const styles = css`
         --ni-private-table-cell-action-menu-display: block;
     }
 
+    nimble-table-cell${focusVisible} {
+        --ni-private-table-cell-action-menu-display: block;
+    }
+
+    nimble-table-cell:first-of-type${focusVisible} {
+        margin-left: calc(
+            -1 * (${controlHeight} - ${smallPadding}) * var(--ni-private-table-cell-focus-offset-multiplier)
+        );
+        padding-left: calc(
+            (${controlHeight} - ${mediumPadding}) *
+                var(--ni-private-table-cell-focus-offset-multiplier) +
+                ${mediumPadding}
+        );
+    }
+
+    nimble-table-cell:first-of-type${focusVisible}::before {
+        content: '';
+        display: block;
+        width: calc(
+            (
+                    ${controlHeight} *
+                        var(--ni-private-table-cell-nesting-level) +
+                        ${smallPadding}
+                ) * var(--ni-private-table-cell-focus-offset-multiplier)
+        );
+        height: ${controlHeight};
+    }
+
     :host(:hover) nimble-table-cell {
         --ni-private-table-cell-action-menu-display: block;
     }
@@ -132,6 +168,10 @@ export const styles = css`
     :host([selected]) nimble-table-cell {
         --ni-private-table-cell-action-menu-display: block;
     }
+
+    :host(${focusVisible}) nimble-table-cell {
+        --ni-private-table-cell-action-menu-display: block;
+    }
 `.withBehaviors(
     themeBehavior(
         Theme.color,
diff --git a/packages/nimble-components/src/table/components/row/template.ts b/packages/nimble-components/src/table/components/row/template.ts
index fe9944ca89..255c085ef3 100644
--- a/packages/nimble-components/src/table/components/row/template.ts
+++ b/packages/nimble-components/src/table/components/row/template.ts
@@ -28,11 +28,13 @@ export const template = html<TableRow>`
     >
         ${when(x => !x.rowOperationGridCellHidden, html<TableRow>`
             <span role="gridcell" class="row-operations-container">
-                ${when(x => x.selectable && !x.hideSelection, html<TableRow>`
+                ${when(x => x.showSelectionCheckbox, html<TableRow>`
                     <${checkboxTag}
                         ${ref('selectionCheckbox')}
                         class="selection-checkbox"
-                        @change="${(x, c) => x.onSelectionChange(c.event as CustomEvent)}"
+                        ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                        tabindex="-1"
+                        @change="${(x, c) => x.onSelectionCheckboxChange(c.event as CustomEvent)}"
                         @click="${(_, c) => c.event.stopPropagation()}"
                         title="${x => tableRowSelectLabel.getValueFor(x)}"
                         aria-label="${x => tableRowSelectLabel.getValueFor(x)}"
diff --git a/packages/nimble-components/src/table/components/row/tests/table-row.spec.ts b/packages/nimble-components/src/table/components/row/tests/table-row.spec.ts
index 276dbeed4a..0ae09cba2e 100644
--- a/packages/nimble-components/src/table/components/row/tests/table-row.spec.ts
+++ b/packages/nimble-components/src/table/components/row/tests/table-row.spec.ts
@@ -477,5 +477,37 @@ describe('TableRow', () => {
             const updatedCell = pageObject.getRenderedCell(0);
             expect(originalCell).not.toBe(updatedCell);
         });
+
+        it('getFocusableElements() includes array of cells', async () => {
+            await connect();
+
+            const focusableElements = row.getFocusableElements();
+            const actualCells = pageObject.getRenderedCells();
+            expect(focusableElements.cells).toEqual([
+                { cell: actualCells[0]!, actionMenuButton: undefined },
+                { cell: actualCells[1]!, actionMenuButton: undefined }
+            ]);
+        });
+
+        it('getFocusableElements() includes the selection checkbox when row is selectable', async () => {
+            row.selectable = true;
+            await connect();
+
+            const focusableElements = row.getFocusableElements();
+            expect(focusableElements.selectionCheckbox).toBe(
+                row.selectionCheckbox
+            );
+        });
+
+        it('if row is set to selectable then subsequently not selectable, getFocusableElements() does not include a selection checkbox', async () => {
+            row.selectable = true;
+            await connect();
+            await waitForUpdatesAsync();
+            row.selectable = false;
+            await waitForUpdatesAsync();
+
+            const focusableElements = row.getFocusableElements();
+            expect(focusableElements.selectionCheckbox).toBeUndefined();
+        });
     });
 });
diff --git a/packages/nimble-components/src/table/index.ts b/packages/nimble-components/src/table/index.ts
index 698051c7ad..d36e470a4b 100644
--- a/packages/nimble-components/src/table/index.ts
+++ b/packages/nimble-components/src/table/index.ts
@@ -28,7 +28,7 @@ import {
     ExpandedState as TanStackExpandedState,
     OnChangeFn as TanStackOnChangeFn
 } from '@tanstack/table-core';
-import { keyShift } from '@microsoft/fast-web-utilities';
+import { keyEnter, keyShift } from '@microsoft/fast-web-utilities';
 import { TableColumn } from '../table-column/base';
 import { TableValidator } from './models/table-validator';
 import { styles } from './styles';
@@ -52,13 +52,16 @@ import { Virtualizer } from './models/virtualizer';
 import { getTanStackSortingFunction } from './models/sort-operations';
 import { TableLayoutManager } from './models/table-layout-manager';
 import { TableUpdateTracker } from './models/table-update-tracker';
-import type { TableRow } from './components/row';
+import { TableRow } from './components/row';
+import type { TableGroupRow } from './components/group-row';
 import { ColumnInternals } from '../table-column/base/models/column-internals';
 import { InteractiveSelectionManager } from './models/interactive-selection-manager';
 import { DataHierarchyManager } from './models/data-hierarchy-manager';
 import { ExpansionManager } from './models/expansion-manager';
 import { waitUntilCustomElementsDefinedAsync } from '../utilities/wait-until-custom-elements-defined-async';
 import { ColumnValidator } from '../table-column/base/models/column-validator';
+import { KeyboardNavigationManager } from './models/keyboard-navigation-manager';
+import { TableCellView } from '../table-column/base/cell-view';
 
 declare global {
     interface HTMLElementTagNameMap {
@@ -103,7 +106,7 @@ export class Table<
      * @internal
      */
     @observable
-    public readonly rowElements: TableRow[] = [];
+    public readonly rowElements: (TableRow | TableGroupRow)[] = [];
 
     /**
      * @internal
@@ -166,6 +169,12 @@ export class Table<
     @observable
     public readonly selectionCheckbox?: Checkbox;
 
+    /**
+     * @internal
+     */
+    @observable
+    public readonly collapseAllButton?: HTMLElement;
+
     /**
      * @internal
      */
@@ -197,6 +206,11 @@ export class Table<
      */
     public readonly layoutManager: TableLayoutManager<TData>;
 
+    /**
+     * @internal
+     */
+    public readonly keyboardNavigationManager: KeyboardNavigationManager<TData>;
+
     /**
      * @internal
      */
@@ -266,6 +280,10 @@ export class Table<
         };
         this.table = tanStackCreateTable(this.options);
         this.virtualizer = new Virtualizer(this, this.table);
+        this.keyboardNavigationManager = new KeyboardNavigationManager(
+            this,
+            this.virtualizer
+        );
         this.layoutManager = new TableLayoutManager(this);
         this.layoutManagerNotifier = Observable.getNotifier(this.layoutManager);
         this.layoutManagerNotifier.subscribe(this, 'isColumnBeingSized');
@@ -320,6 +338,7 @@ export class Table<
         this.viewport.addEventListener('scroll', this.onViewPortScroll, {
             passive: true
         });
+        this.keyboardNavigationManager.connect();
         document.addEventListener('keydown', this.onKeyDown);
         document.addEventListener('keyup', this.onKeyUp);
     }
@@ -327,6 +346,7 @@ export class Table<
     public override disconnectedCallback(): void {
         super.disconnectedCallback();
         this.virtualizer.disconnect();
+        this.keyboardNavigationManager.disconnect();
         this.viewport.removeEventListener('scroll', this.onViewPortScroll);
         document.removeEventListener('keydown', this.onKeyDown);
         document.removeEventListener('keyup', this.onKeyUp);
@@ -399,6 +419,16 @@ export class Table<
         return true;
     }
 
+    /** @internal */
+    public onRowFocusIn(event: FocusEvent): void {
+        this.keyboardNavigationManager.onRowFocusIn(event);
+    }
+
+    /** @internal */
+    public onRowBlur(event: FocusEvent): void {
+        this.keyboardNavigationManager.onRowBlur(event);
+    }
+
     /** @internal */
     public onAllRowsSelectionChange(event: CustomEvent): void {
         event.stopPropagation();
@@ -530,6 +560,19 @@ export class Table<
         this.emitColumnConfigurationChangeEvent();
     }
 
+    /**
+     * @internal
+     */
+    public onHeaderKeyDown(column: TableColumn, event: KeyboardEvent): boolean {
+        const allowMultiSort = event.shiftKey;
+        if (event.key === keyEnter) {
+            this.toggleColumnSort(column, allowMultiSort);
+        }
+        // Return true so that we don't prevent default behavior. Without this, Tab navigation
+        // gets stuck on the column headers.
+        return true;
+    }
+
     /**
      * @internal
      */
@@ -549,6 +592,10 @@ export class Table<
                 column => !column.columnHidden
             );
         }
+
+        if (this.tableUpdateTracker.requiresKeyboardFocusReset) {
+            this.keyboardNavigationManager.resetFocusState();
+        }
     }
 
     public override get ariaMultiSelectable(): 'true' | 'false' | null {
@@ -608,6 +655,37 @@ export class Table<
         return tanStackUpdates;
     }
 
+    /** @internal */
+    public handleFocusedCellRecycling(): void {
+        const hadActiveRowOrCellFocus = this.keyboardNavigationManager.hasActiveRowOrCellFocus;
+
+        let tableFocusedElement = this.shadowRoot!.activeElement;
+        while (
+            tableFocusedElement !== null
+            && !(tableFocusedElement instanceof TableCellView)
+        ) {
+            if (tableFocusedElement.shadowRoot) {
+                tableFocusedElement = tableFocusedElement.shadowRoot.activeElement;
+            } else {
+                break;
+            }
+        }
+        if (tableFocusedElement instanceof TableCellView) {
+            tableFocusedElement.focusedRecycleCallback();
+        }
+        if (this.openActionMenuRecordId !== undefined) {
+            const activeRow = this.rowElements.find(
+                row => row instanceof TableRow
+                    && row.recordId === this.openActionMenuRecordId
+            ) as TableRow | undefined;
+            activeRow?.closeOpenActionMenus();
+        }
+
+        this.keyboardNavigationManager.handleFocusedCellRecycling(
+            hadActiveRowOrCellFocus
+        );
+    }
+
     protected selectionModeChanged(
         _prev: string | undefined,
         _next: string | undefined
@@ -672,6 +750,7 @@ export class Table<
     private async handleRowActionMenuToggleEvent(
         event: CustomEvent<TableActionMenuToggleEventDetail>
     ): Promise<void> {
+        this.keyboardNavigationManager.onRowActionMenuToggle(event);
         const detail = await this.getActionMenuToggleEventDetail(event);
         this.$emit('action-menu-toggle', detail);
         if (!event.detail.newState) {
@@ -964,6 +1043,7 @@ export class Table<
                 isParentRow: isParent,
                 immediateChildCount: row.subRows.length,
                 groupColumn: this.getGroupRowColumn(row),
+                resolvedRowIndex: row.index,
                 isLoadingChildren: this.expansionManager.isLoadingChildren(
                     row.id
                 )
diff --git a/packages/nimble-components/src/table/models/keyboard-navigation-manager.ts b/packages/nimble-components/src/table/models/keyboard-navigation-manager.ts
new file mode 100644
index 0000000000..009d892665
--- /dev/null
+++ b/packages/nimble-components/src/table/models/keyboard-navigation-manager.ts
@@ -0,0 +1,1373 @@
+import { Notifier, Subscriber, Observable } from '@microsoft/fast-element';
+import {
+    keyArrowDown,
+    keyArrowLeft,
+    keyArrowRight,
+    keyArrowUp,
+    keyEnd,
+    keyEnter,
+    keyEscape,
+    keyFunction2,
+    keyHome,
+    keyPageDown,
+    keyPageUp,
+    keySpace,
+    keyTab
+} from '@microsoft/fast-web-utilities';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import type { ScrollToOptions } from '@tanstack/virtual-core';
+import type { Table } from '..';
+import {
+    TableActionMenuToggleEventDetail,
+    TableFocusType,
+    TableHeaderFocusableElements,
+    TableRowFocusableElements,
+    type TableRecord
+} from '../types';
+import type { Virtualizer } from './virtualizer';
+import { TableGroupRow } from '../components/group-row';
+import { TableRow } from '../components/row';
+import { TableCell } from '../components/cell';
+import type { MenuButton } from '../../menu-button';
+import { tableHeaderTag } from '../components/header';
+import { TableCellView } from '../../table-column/base/cell-view';
+
+interface TableFocusState {
+    focusType: TableFocusType;
+    headerActionIndex?: number;
+    rowIndex?: number;
+    columnIndex?: number;
+    cellContentIndex?: number;
+}
+
+/**
+ * Manages the keyboard navigation and focus within the table.
+ * @internal
+ */
+export class KeyboardNavigationManager<TData extends TableRecord>
+implements Subscriber {
+    private focusType: TableFocusType = TableFocusType.none;
+    private headerActionIndex = -1;
+    private rowIndex = -1;
+    private cellContentIndex = -1;
+    private columnIndex = -1;
+    private focusWithinTable = false;
+    private isCurrentlyFocusingElement = false;
+    private readonly tableNotifier: Notifier;
+    private readonly virtualizerNotifier: Notifier;
+    private visibleRowNotifiers: Notifier[] = [];
+    private get inNavigationMode(): boolean {
+        return (
+            this.focusType !== TableFocusType.cellActionMenu
+            && this.focusType !== TableFocusType.cellContent
+        );
+    }
+
+    public constructor(
+        private readonly table: Table<TData>,
+        private readonly virtualizer: Virtualizer<TData>
+    ) {
+        this.tableNotifier = Observable.getNotifier(this.table);
+        this.tableNotifier.subscribe(this, 'rowElements');
+        this.virtualizerNotifier = Observable.getNotifier(this.virtualizer);
+        this.virtualizerNotifier.subscribe(this, 'visibleItems');
+    }
+
+    public resetFocusState(): void {
+        this.focusType = TableFocusType.none;
+        const activeElement = this.getActiveElement();
+        if (activeElement && this.isInTable(activeElement)) {
+            this.setDefaultFocus();
+        }
+    }
+
+    public get hasActiveRowOrCellFocus(): boolean {
+        return this.focusWithinTable && this.hasRowOrCellFocusType();
+    }
+
+    public connect(): void {
+        this.table.addEventListener(
+            'keydown',
+            this.onCaptureKeyDown as EventListener,
+            { capture: true }
+        );
+        this.table.addEventListener('keydown', this.onKeyDown as EventListener);
+        this.table.addEventListener(
+            'focusin',
+            this.onTableFocusIn as EventListener
+        );
+        this.table.addEventListener(
+            'focusout',
+            this.onTableFocusOut as EventListener
+        );
+        this.table.viewport.addEventListener('keydown', this.onViewportKeyDown);
+        this.table.viewport.addEventListener(
+            'cell-action-menu-blur',
+            this.onCellActionMenuBlur as EventListener
+        );
+        this.table.viewport.addEventListener(
+            'cell-view-focus-in',
+            this.onCellViewFocusIn as EventListener
+        );
+        this.table.viewport.addEventListener(
+            'cell-focus-in',
+            this.onCellFocusIn as EventListener
+        );
+        this.table.viewport.addEventListener(
+            'cell-blur',
+            this.onCellBlur as EventListener
+        );
+    }
+
+    public disconnect(): void {
+        this.table.removeEventListener(
+            'keydown',
+            this.onCaptureKeyDown as EventListener,
+            { capture: true }
+        );
+        this.table.removeEventListener(
+            'keydown',
+            this.onKeyDown as EventListener
+        );
+        this.table.removeEventListener(
+            'focusin',
+            this.onTableFocusIn as EventListener
+        );
+        this.table.removeEventListener(
+            'focusout',
+            this.onTableFocusOut as EventListener
+        );
+        this.table.viewport.removeEventListener(
+            'keydown',
+            this.onViewportKeyDown
+        );
+        this.table.viewport.removeEventListener(
+            'cell-action-menu-blur',
+            this.onCellActionMenuBlur as EventListener
+        );
+        this.table.viewport.removeEventListener(
+            'cell-view-focus-in',
+            this.onCellViewFocusIn as EventListener
+        );
+        this.table.viewport.removeEventListener(
+            'cell-focus-in',
+            this.onCellFocusIn as EventListener
+        );
+        this.table.viewport.removeEventListener(
+            'cell-blur',
+            this.onCellBlur as EventListener
+        );
+    }
+
+    public handleChange(source: unknown, args: unknown): void {
+        let focusRowAndCell = false;
+        if (source === this.virtualizer && args === 'visibleItems') {
+            focusRowAndCell = true;
+        } else if (source === this.table && args === 'rowElements') {
+            for (const notifier of this.visibleRowNotifiers) {
+                notifier.unsubscribe(this);
+            }
+            this.visibleRowNotifiers = [];
+            for (const visibleRow of this.table.rowElements) {
+                const rowNotifier = Observable.getNotifier(visibleRow);
+                rowNotifier.subscribe(this, 'resolvedRowIndex');
+                if (visibleRow.resolvedRowIndex === this.rowIndex) {
+                    focusRowAndCell = true;
+                }
+            }
+        } else if (
+            args === 'resolvedRowIndex'
+            && this.isResolvedRowType(source)
+        ) {
+            if (source.resolvedRowIndex === this.rowIndex) {
+                focusRowAndCell = true;
+            }
+        }
+
+        if (focusRowAndCell) {
+            // Focusable elements in cells, and action menus, are both blurred on scroll. To maintain our row/cell focus state,
+            // we focus the cell instead here. (We also don't want to refocus the cell content when the focusedRecycleCallback just
+            // blurred it.)
+            if (
+                this.focusType === TableFocusType.cellActionMenu
+                || this.focusType === TableFocusType.cellContent
+            ) {
+                this.setCellFocusState(this.columnIndex, this.rowIndex, false);
+            }
+            if (this.inNavigationMode && this.hasRowOrCellFocusType()) {
+                if (this.rowIndex > this.table.tableData.length - 1) {
+                    // Focused row index no longer valid, coerce to 1st row if possible
+                    if (this.table.tableData.length > 0) {
+                        this.rowIndex = 0;
+                    } else {
+                        if (this.focusWithinTable) {
+                            this.setDefaultFocus();
+                        } else {
+                            this.focusType = TableFocusType.none;
+                        }
+                        return;
+                    }
+                }
+                if (this.focusWithinTable) {
+                    this.focusCurrentRow(false);
+                }
+            }
+        }
+    }
+
+    public handleFocusedCellRecycling(hadRowOrCellFocus: boolean): void {
+        if (hadRowOrCellFocus && !this.focusWithinTable) {
+            this.focusCurrentRow(false);
+        }
+    }
+
+    public onRowFocusIn(event: FocusEvent): void {
+        if (this.isCurrentlyFocusingElement) {
+            return;
+        }
+        const row = event.target;
+        if (this.isResolvedRowType(row)) {
+            if (this.rowIndex !== row.resolvedRowIndex) {
+                // If user focuses a row some other way (e.g. mouse), update our focus state so future keyboard nav
+                // will start from that row
+                this.setRowFocusState(row.resolvedRowIndex);
+            }
+        }
+    }
+
+    public onRowBlur(event: FocusEvent): void {
+        const row = event.target;
+        if (this.isResolvedRowType(row)) {
+            this.setElementFocusable(row, false);
+        }
+    }
+
+    public onRowActionMenuToggle(
+        event: CustomEvent<TableActionMenuToggleEventDetail>
+    ): void {
+        const isOpen = event.detail.newState;
+        if (isOpen) {
+            const row = event.target as TableRow;
+            const columnIndex = this.table.visibleColumns.findIndex(
+                column => column.columnId === event.detail.columnId
+            );
+            this.setCellActionMenuFocusState(
+                row.resolvedRowIndex!,
+                columnIndex,
+                false
+            );
+        }
+    }
+
+    private readonly onTableFocusIn = (event: FocusEvent): void => {
+        this.focusWithinTable = true;
+        this.updateFocusStateFromActiveElement(false);
+
+        // Sets initial focus on the appropriate table content
+        const actionMenuOpen = this.table.openActionMenuRecordId !== undefined;
+        if (
+            (event.target === this.table
+                || this.focusType === TableFocusType.none)
+            && !actionMenuOpen
+        ) {
+            let focusHeader = true;
+            if (
+                this.hasRowOrCellFocusType()
+                && this.scrollToAndFocusRow(this.rowIndex)
+            ) {
+                focusHeader = false;
+            }
+            if (focusHeader && !this.setFocusOnHeader()) {
+                // nothing to focus
+                this.table.blur();
+            }
+        }
+    };
+
+    private readonly onTableFocusOut = (): void => {
+        this.focusWithinTable = false;
+    };
+
+    private readonly onCellActionMenuBlur = (
+        event: CustomEvent<TableCell>
+    ): void => {
+        event.stopPropagation();
+        const cell = event.detail;
+        if (cell.actionMenuButton) {
+            // Ensure that action menu buttons get hidden when no longer focused
+            this.setActionMenuButtonFocused(cell.actionMenuButton, false);
+        }
+    };
+
+    private readonly onCellViewFocusIn = (
+        event: CustomEvent<TableCell>
+    ): void => {
+        event.stopPropagation();
+        this.updateFocusStateFromActiveElement(false);
+    };
+
+    private readonly onCellFocusIn = (event: CustomEvent<TableCell>): void => {
+        event.stopPropagation();
+        const cell = event.detail;
+        this.updateFocusStateFromActiveElement(true);
+        // Currently, clicking a non-interactive cell only updates the focus state to that row, it
+        // doesn't focus the cell. If we revisit this, we most likely need to set the cells to tabindex=-1
+        // upfront too, so their focusing behavior is consistent whether they've been previously keyboard
+        // focused or not.
+        if (
+            this.focusType === TableFocusType.row
+            && this.getActiveElement() === cell
+        ) {
+            this.focusCurrentRow(false);
+        }
+    };
+
+    private readonly onCellBlur = (event: CustomEvent<TableCell>): void => {
+        event.stopPropagation();
+        const cell = event.detail;
+        this.setElementFocusable(cell, false);
+    };
+
+    private readonly onCaptureKeyDown = (event: KeyboardEvent): void => {
+        let handled = false;
+        if (event.key === keyTab) {
+            handled = this.onTabPressed(event.shiftKey);
+        } else if (this.inNavigationMode) {
+            switch (event.key) {
+                case keyArrowLeft:
+                    handled = this.onLeftArrowPressed();
+                    break;
+                case keyArrowRight:
+                    handled = this.onRightArrowPressed();
+                    break;
+                case keyArrowUp:
+                    handled = this.onUpArrowPressed();
+                    break;
+                case keyArrowDown:
+                    handled = this.onDownArrowPressed();
+                    break;
+                case keyPageUp:
+                    handled = this.onPageUpPressed();
+                    break;
+                case keyPageDown:
+                    handled = this.onPageDownPressed();
+                    break;
+                case keyHome:
+                    handled = this.onHomePressed(event.ctrlKey);
+                    break;
+                case keyEnd:
+                    handled = this.onEndPressed(event.ctrlKey);
+                    break;
+                case keyEnter:
+                    handled = this.onEnterPressed(event.ctrlKey);
+                    break;
+                case keySpace:
+                    handled = this.onSpacePressed(event.shiftKey);
+                    break;
+                case keyFunction2:
+                    handled = this.onF2Pressed();
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (handled) {
+            event.preventDefault();
+        }
+    };
+
+    private readonly onKeyDown = (event: KeyboardEvent): void => {
+        if (!this.inNavigationMode && !event.defaultPrevented) {
+            if (event.key === keyEscape || event.key === keyFunction2) {
+                const row = this.getCurrentRow();
+                if (row) {
+                    this.trySetCellFocus(row.getFocusableElements());
+                }
+            }
+        }
+    };
+
+    private readonly onViewportKeyDown = (event: KeyboardEvent): void => {
+        let handleEvent = !this.inNavigationMode
+            && (event.key === keyArrowUp || event.key === keyArrowDown);
+        switch (event.key) {
+            case keyPageUp:
+            case keyPageDown:
+            case keyHome:
+            case keyEnd:
+                handleEvent = true;
+                break;
+            default:
+                break;
+        }
+        if (handleEvent) {
+            // Swallow key presses that would cause table scrolling, independently of keyboard navigation
+            event.preventDefault();
+            event.stopImmediatePropagation();
+        }
+    };
+
+    private onEnterPressed(ctrlKey: boolean): boolean {
+        let row: TableRow | TableGroupRow | undefined;
+        let rowElements: TableRowFocusableElements | undefined;
+        if (this.hasRowOrCellFocusType()) {
+            row = this.getCurrentRow();
+            rowElements = row?.getFocusableElements();
+        }
+        if (this.focusType === TableFocusType.row) {
+            if (row instanceof TableGroupRow) {
+                this.toggleRowExpanded(row);
+                return true;
+            }
+        }
+        if (this.focusType === TableFocusType.cell) {
+            if (ctrlKey) {
+                const cell = rowElements?.cells[this.columnIndex];
+                if (cell?.actionMenuButton && !cell.actionMenuButton.open) {
+                    cell.actionMenuButton.toggleButton!.control.click();
+                    return true;
+                }
+            }
+            return this.focusFirstInteractiveElementInCurrentCell(rowElements);
+        }
+        return false;
+    }
+
+    private onF2Pressed(): boolean {
+        if (this.focusType === TableFocusType.cell) {
+            const row = this.getCurrentRow();
+            const rowElements = row?.getFocusableElements();
+            return this.focusFirstInteractiveElementInCurrentCell(rowElements);
+        }
+        return false;
+    }
+
+    private onSpacePressed(shiftKey: boolean): boolean {
+        if (
+            this.focusType === TableFocusType.row
+            || this.focusType === TableFocusType.cell
+        ) {
+            if (this.focusType === TableFocusType.row || shiftKey) {
+                const row = this.getCurrentRow();
+                if (row instanceof TableRow && row.selectable) {
+                    row.onSelectionChange(row.selected, !row.selected);
+                } else if (row instanceof TableGroupRow) {
+                    this.toggleRowExpanded(row);
+                }
+            }
+            // Default Space behavior scrolls down, which is redundant given the rest of our keyboard nav code, and we'd still try to focus a
+            // row that you scrolled away from. So suppress default Space behavior if a row or cell is selected, regardless of if we're
+            // toggling selection or not.
+            return true;
+        }
+        return false;
+    }
+
+    private onLeftArrowPressed(): boolean {
+        let row: TableRow | TableGroupRow | undefined;
+        let rowElements: TableRowFocusableElements | undefined;
+        let headerElements!: TableHeaderFocusableElements;
+        if (this.hasRowOrCellFocusType()) {
+            row = this.getCurrentRow();
+            rowElements = row?.getFocusableElements();
+        } else if (this.hasHeaderFocusType()) {
+            headerElements = this.getTableHeaderFocusableElements();
+        }
+
+        switch (this.focusType) {
+            case TableFocusType.headerActions:
+                return this.trySetHeaderActionFocus(
+                    headerElements,
+                    this.headerActionIndex - 1
+                );
+            case TableFocusType.columnHeader:
+                return (
+                    this.trySetColumnHeaderFocus(
+                        headerElements,
+                        this.columnIndex - 1
+                    )
+                    || this.trySetHeaderActionFocus(
+                        headerElements,
+                        headerElements.headerActions.length - 1
+                    )
+                );
+            case TableFocusType.row:
+                if (this.isRowExpanded(row) === true) {
+                    this.toggleRowExpanded(row!);
+                    return true;
+                }
+                return false;
+            case TableFocusType.rowSelectionCheckbox:
+                this.setRowFocusState();
+                return this.focusCurrentRow(true);
+            case TableFocusType.cell:
+                if (
+                    !this.trySetCellFocus(rowElements, this.columnIndex - 1)
+                    && !this.trySetRowSelectionCheckboxFocus(rowElements)
+                ) {
+                    this.setRowFocusState();
+                    this.focusCurrentRow(true);
+                }
+                return true;
+            default:
+                break;
+        }
+
+        return false;
+    }
+
+    private onRightArrowPressed(): boolean {
+        let row: TableRow | TableGroupRow | undefined;
+        let rowElements: TableRowFocusableElements | undefined;
+        let headerElements!: TableHeaderFocusableElements;
+        if (this.hasRowOrCellFocusType()) {
+            row = this.getCurrentRow();
+            rowElements = row?.getFocusableElements();
+        } else if (this.hasHeaderFocusType()) {
+            headerElements = this.getTableHeaderFocusableElements();
+        }
+
+        switch (this.focusType) {
+            case TableFocusType.headerActions:
+                return (
+                    this.trySetHeaderActionFocus(
+                        headerElements,
+                        this.headerActionIndex + 1
+                    ) || this.trySetColumnHeaderFocus(headerElements, 0)
+                );
+            case TableFocusType.columnHeader:
+                return this.trySetColumnHeaderFocus(
+                    headerElements,
+                    this.columnIndex + 1
+                );
+            case TableFocusType.row:
+                if (this.isRowExpanded(row) === false) {
+                    this.toggleRowExpanded(row!);
+                    return true;
+                }
+                return (
+                    this.trySetRowSelectionCheckboxFocus(rowElements)
+                    || this.trySetCellFocus(rowElements, 0)
+                );
+            case TableFocusType.rowSelectionCheckbox:
+                return this.trySetCellFocus(rowElements, 0);
+            case TableFocusType.cell:
+                return this.trySetCellFocus(rowElements, this.columnIndex + 1);
+            default:
+                break;
+        }
+
+        return false;
+    }
+
+    private onUpArrowPressed(): boolean {
+        this.onMoveUp(1);
+        // Always prevent default - prevents page scroll, and FireFox changing focus if focus is at table extents
+        return true;
+    }
+
+    private onPageUpPressed(): boolean {
+        return this.onMoveUp(this.virtualizer.pageSize);
+    }
+
+    private onHomePressed(ctrlKey: boolean): boolean {
+        if (this.handleHomeEndWithinRow(ctrlKey)) {
+            const row = this.getCurrentRow();
+            const rowElements = row?.getFocusableElements();
+            return (
+                this.trySetRowSelectionCheckboxFocus(rowElements)
+                || this.trySetCellFocus(rowElements, 0)
+            );
+        }
+
+        return this.onMoveUp(0, 0);
+    }
+
+    private onDownArrowPressed(): boolean {
+        this.onMoveDown(1);
+        // Always prevent default - prevents page scroll, and FireFox changing focus if focus is at table extents
+        return true;
+    }
+
+    private onPageDownPressed(): boolean {
+        return this.onMoveDown(this.virtualizer.pageSize);
+    }
+
+    private onEndPressed(ctrlKey: boolean): boolean {
+        if (this.handleHomeEndWithinRow(ctrlKey)) {
+            const row = this.getCurrentRow();
+            const rowElements = row?.getFocusableElements();
+            return this.trySetCellFocus(
+                rowElements,
+                this.table.visibleColumns.length - 1
+            );
+        }
+
+        return this.onMoveDown(0, this.table.tableData.length - 1);
+    }
+
+    private handleHomeEndWithinRow(ctrlKey: boolean): boolean {
+        return (
+            (this.focusType === TableFocusType.cell
+                || this.focusType === TableFocusType.rowSelectionCheckbox)
+            && !ctrlKey
+        );
+    }
+
+    private onTabPressed(shiftKeyPressed: boolean): boolean {
+        const activeElement = this.getActiveElement();
+        if (activeElement === null || activeElement === this.table) {
+            return false;
+        }
+        const nextFocusState = this.hasRowOrCellFocusType()
+            ? this.getNextRowTabStop(shiftKeyPressed)
+            : this.getNextHeaderTabStop(shiftKeyPressed);
+        if (nextFocusState) {
+            this.focusType = nextFocusState.focusType;
+            this.rowIndex = nextFocusState.rowIndex ?? this.rowIndex;
+            this.columnIndex = nextFocusState.columnIndex ?? this.columnIndex;
+            this.headerActionIndex = nextFocusState.headerActionIndex ?? this.headerActionIndex;
+            this.cellContentIndex = nextFocusState.cellContentIndex ?? this.cellContentIndex;
+            if (this.hasRowOrCellFocusType()) {
+                this.focusCurrentRow(false);
+            } else {
+                this.focusHeaderElement();
+            }
+            return true;
+        }
+        this.blurAfterLastTab(activeElement);
+        return false;
+    }
+
+    private getNextRowTabStop(
+        shiftKeyPressed: boolean
+    ): TableFocusState | undefined {
+        const row = this.getCurrentRow();
+        if (row === undefined) {
+            return undefined;
+        }
+        let startIndex = -1;
+        const focusStates = [];
+        const rowElements = row.getFocusableElements();
+        if (rowElements.selectionCheckbox) {
+            focusStates.push({
+                focusType: TableFocusType.rowSelectionCheckbox
+            });
+            if (this.focusType === TableFocusType.rowSelectionCheckbox) {
+                startIndex = 0;
+            }
+        }
+        let cellIndex = 0;
+        while (cellIndex < rowElements.cells.length) {
+            const firstCellTabbableIndex = focusStates.length;
+            const cellInfo = rowElements.cells[cellIndex]!;
+            const cellViewTabbableChildren = cellInfo.cell.cellView.tabbableChildren;
+            for (let i = 0; i < cellViewTabbableChildren.length; i++) {
+                focusStates.push({
+                    focusType: TableFocusType.cellContent,
+                    columnIndex: cellIndex,
+                    cellContentIndex: i
+                });
+                if (
+                    this.focusType === TableFocusType.cellContent
+                    && this.columnIndex === cellIndex
+                    && this.cellContentIndex === i
+                ) {
+                    startIndex = focusStates.length - 1;
+                }
+            }
+            if (cellInfo.actionMenuButton) {
+                focusStates.push({
+                    focusType: TableFocusType.cellActionMenu,
+                    columnIndex: cellIndex
+                });
+                if (
+                    this.focusType === TableFocusType.cellActionMenu
+                    && this.columnIndex === cellIndex
+                ) {
+                    startIndex = focusStates.length - 1;
+                }
+            }
+            const lastCellTabbableIndex = focusStates.length - 1;
+            if (
+                this.focusType === TableFocusType.cell
+                && this.columnIndex === cellIndex
+            ) {
+                startIndex = shiftKeyPressed
+                    ? lastCellTabbableIndex + 1
+                    : firstCellTabbableIndex - 1;
+            }
+            cellIndex += 1;
+        }
+        if (this.focusType === TableFocusType.row) {
+            startIndex = shiftKeyPressed ? focusStates.length : -1;
+        }
+        const direction = shiftKeyPressed ? -1 : 1;
+        return focusStates[startIndex + direction];
+    }
+
+    private getNextHeaderTabStop(
+        shiftKeyPressed: boolean
+    ): TableFocusState | undefined {
+        let startIndex = -1;
+        const focusStates = [];
+        const headerTabbableElements = this.getTableHeaderFocusableElements().headerActions;
+        for (let i = 0; i < headerTabbableElements.length; i++) {
+            focusStates.push({
+                focusType: TableFocusType.headerActions,
+                headerActionIndex: i
+            });
+        }
+        if (this.focusType === TableFocusType.headerActions) {
+            startIndex = this.headerActionIndex;
+        } else {
+            // TableFocusType.columnHeader
+            startIndex = focusStates.length;
+        }
+        const direction = shiftKeyPressed ? -1 : 1;
+        return focusStates[startIndex + direction];
+    }
+
+    private blurAfterLastTab(activeElement: HTMLElement): void {
+        // In order to get the desired browser-provided Tab/Shift-Tab behavior of focusing the
+        // element before/after the table, the table shouldn't have tabIndex=0 when this event
+        // handling ends. However it needs to be tabIndex=0 so we can re-focus the table the next time
+        // it's tabbed to, so set tabIndex back to 0 after a rAF.
+        // Note: In Chrome this is only needed for Shift-Tab, but in Firefox both Tab and Shift-Tab need this
+        // to work as expected.
+        this.table.tabIndex = -1;
+        window.requestAnimationFrame(() => {
+            this.table.tabIndex = 0;
+        });
+
+        // Don't explicitly call blur() on activeElement (causes unexpected behavior on Safari / Mac Firefox)
+        this.setElementFocusable(activeElement, false);
+    }
+
+    private onMoveUp(rowDelta: number, newRowIndex?: number): boolean {
+        const coerceRowIndex = rowDelta > 1;
+        switch (this.focusType) {
+            case TableFocusType.row:
+            case TableFocusType.rowSelectionCheckbox:
+            case TableFocusType.cell: {
+                const scrollOptions: ScrollToOptions = {};
+                let rowIndex = this.rowIndex;
+                if (newRowIndex !== undefined) {
+                    rowIndex = newRowIndex;
+                }
+                rowIndex -= rowDelta;
+                if (coerceRowIndex && rowIndex < 0) {
+                    rowIndex = 0;
+                }
+                if (rowDelta > 1) {
+                    scrollOptions.align = 'start';
+                }
+
+                if (rowIndex < this.rowIndex && rowIndex >= 0) {
+                    return this.scrollToAndFocusRow(rowIndex, scrollOptions);
+                }
+                if (rowIndex === -1) {
+                    const headerElements = this.getTableHeaderFocusableElements();
+                    if (
+                        this.focusType === TableFocusType.row
+                        || this.focusType === TableFocusType.rowSelectionCheckbox
+                    ) {
+                        return (
+                            this.trySetHeaderActionFocus(headerElements, 0)
+                            || this.trySetColumnHeaderFocus(headerElements, 0)
+                        );
+                    }
+                    return this.trySetColumnHeaderFocus(
+                        headerElements,
+                        this.columnIndex
+                    );
+                }
+                return false;
+            }
+            default:
+                break;
+        }
+
+        return false;
+    }
+
+    private onMoveDown(rowDelta: number, newRowIndex?: number): boolean {
+        const coerceRowIndex = rowDelta > 1;
+        switch (this.focusType) {
+            case TableFocusType.headerActions: {
+                this.setRowFocusState(0);
+                return this.scrollToAndFocusRow(0);
+            }
+            case TableFocusType.columnHeader: {
+                this.setCellFocusState(this.columnIndex, 0, false);
+                return this.scrollToAndFocusRow(0);
+            }
+            case TableFocusType.row:
+            case TableFocusType.rowSelectionCheckbox:
+            case TableFocusType.cell: {
+                const scrollOptions: ScrollToOptions = {};
+                let rowIndex = this.rowIndex;
+                if (newRowIndex !== undefined) {
+                    rowIndex = newRowIndex;
+                }
+                rowIndex += rowDelta;
+                if (coerceRowIndex && rowIndex >= this.table.tableData.length) {
+                    rowIndex = this.table.tableData.length - 1;
+                }
+                if (rowDelta > 1) {
+                    scrollOptions.align = 'end';
+                }
+                if (
+                    rowIndex > this.rowIndex
+                    && rowIndex < this.table.tableData.length
+                ) {
+                    return this.scrollToAndFocusRow(rowIndex, scrollOptions);
+                }
+                return false;
+            }
+            default:
+                break;
+        }
+
+        return false;
+    }
+
+    private updateFocusStateFromActiveElement(setRowFocus: boolean): void {
+        // If the user is interacting with the table with non-keyboard methods (like mouse), we need to
+        // update our focus state based on the current active/focused element
+        const activeElement = this.getActiveElement();
+        if (activeElement) {
+            const row = this.getContainingRow(activeElement);
+            if (row) {
+                if (!(row instanceof TableGroupRow)) {
+                    const cell = this.getContainingCell(activeElement);
+                    if (cell) {
+                        const columnIndex = this.table.visibleColumns.indexOf(
+                            cell.column!
+                        );
+                        if (cell.actionMenuButton === activeElement) {
+                            this.setCellActionMenuFocusState(
+                                row.resolvedRowIndex!,
+                                columnIndex,
+                                false
+                            );
+                            return;
+                        }
+                        const contentIndex = cell.cellView.tabbableChildren.indexOf(
+                            activeElement
+                        );
+                        if (contentIndex > -1) {
+                            this.setCellContentFocusState(
+                                contentIndex,
+                                row.resolvedRowIndex!,
+                                columnIndex,
+                                false
+                            );
+                            return;
+                        }
+                    }
+                }
+                if (
+                    setRowFocus
+                    && this.hasRowOrCellFocusType()
+                    && this.rowIndex !== row.resolvedRowIndex
+                ) {
+                    this.setRowFocusState(row.resolvedRowIndex);
+                }
+            }
+        }
+    }
+
+    private focusElement(
+        element: HTMLElement,
+        focusOptions?: FocusOptions
+    ): void {
+        const previousActiveElement = this.getActiveElement();
+        if (previousActiveElement !== element) {
+            this.setElementFocusable(element, true);
+            this.isCurrentlyFocusingElement = true;
+            element.focus(focusOptions);
+            this.isCurrentlyFocusingElement = false;
+            if (
+                previousActiveElement
+                && this.isInTable(previousActiveElement)
+            ) {
+                this.setElementFocusable(previousActiveElement, false);
+            }
+        }
+    }
+
+    private setElementFocusable(
+        element: HTMLElement,
+        focusable: boolean
+    ): void {
+        if (element === this.table) {
+            return;
+        }
+
+        element.tabIndex = focusable ? 0 : -1;
+    }
+
+    private setActionMenuButtonFocused(
+        menuButton: MenuButton,
+        focused: boolean
+    ): void {
+        // The action MenuButton needs to be visible in order to be focused, so this CSS class styling
+        // handles that (see cell/styles.ts).
+        if (focused) {
+            menuButton.classList.add('cell-action-menu-focused');
+        } else {
+            menuButton.classList.remove('cell-action-menu-focused');
+        }
+    }
+
+    private setFocusOnHeader(): boolean {
+        if (this.hasHeaderFocusType()) {
+            return this.focusHeaderElement();
+        }
+        this.setDefaultFocus();
+        return this.focusType !== TableFocusType.none;
+    }
+
+    private setDefaultFocus(): void {
+        const headerElements = this.getTableHeaderFocusableElements();
+        if (
+            !this.trySetHeaderActionFocus(headerElements, 0)
+            && !this.trySetColumnHeaderFocus(headerElements, 0)
+            && !this.scrollToAndFocusRow(0)
+        ) {
+            this.focusType = TableFocusType.none;
+        }
+    }
+
+    private scrollToAndFocusRow(
+        totalRowIndex: number,
+        scrollOptions?: ScrollToOptions
+    ): boolean {
+        if (totalRowIndex >= 0 && totalRowIndex < this.table.tableData.length) {
+            switch (this.focusType) {
+                case TableFocusType.none:
+                case TableFocusType.headerActions:
+                case TableFocusType.columnHeader:
+                    this.setRowFocusState(totalRowIndex);
+                    break;
+                default:
+                    break;
+            }
+            this.rowIndex = totalRowIndex;
+            this.virtualizer.scrollToIndex(totalRowIndex, scrollOptions);
+            this.focusCurrentRow(true);
+            return true;
+        }
+        return false;
+    }
+
+    private focusCurrentRow(allowScroll: boolean): boolean {
+        const visibleRowIndex = this.getCurrentRowVisibleIndex();
+        if (visibleRowIndex < 0) {
+            return false;
+        }
+        const focusedRow = this.table.rowElements[visibleRowIndex]!;
+
+        let focusRowOnly = false;
+        switch (this.focusType) {
+            case TableFocusType.row:
+                focusRowOnly = true;
+                break;
+            case TableFocusType.cell:
+            case TableFocusType.cellActionMenu:
+            case TableFocusType.cellContent:
+                focusRowOnly = focusedRow instanceof TableGroupRow;
+                break;
+            default:
+                break;
+        }
+        const focusOptions = { preventScroll: !allowScroll };
+        if (focusRowOnly) {
+            this.focusElement(focusedRow, focusOptions);
+            return true;
+        }
+        this.focusRowElement(focusedRow, focusOptions);
+        return true;
+    }
+
+    private focusRowElement(
+        row: TableRow | TableGroupRow,
+        focusOptions?: FocusOptions
+    ): void {
+        const rowElements = row.getFocusableElements();
+        let focusableElement: HTMLElement | undefined;
+        switch (this.focusType) {
+            case TableFocusType.rowSelectionCheckbox:
+                focusableElement = rowElements.selectionCheckbox;
+                break;
+            case TableFocusType.cell: {
+                focusableElement = rowElements.cells[this.columnIndex]!.cell;
+                break;
+            }
+            case TableFocusType.cellActionMenu: {
+                const actionMenuButton = rowElements.cells[this.columnIndex]?.cell.actionMenuButton;
+                if (actionMenuButton) {
+                    focusableElement = actionMenuButton;
+                    this.setActionMenuButtonFocused(actionMenuButton, true);
+                }
+                break;
+            }
+            case TableFocusType.cellContent: {
+                focusableElement = rowElements.cells[this.columnIndex]?.cell.cellView
+                    .tabbableChildren[this.cellContentIndex];
+                break;
+            }
+            default:
+                break;
+        }
+        if (focusableElement) {
+            this.focusElement(focusableElement, focusOptions);
+        }
+    }
+
+    private focusHeaderElement(): boolean {
+        const headerElements = this.getTableHeaderFocusableElements();
+        let focusableElement: HTMLElement | undefined;
+        switch (this.focusType) {
+            case TableFocusType.headerActions:
+                focusableElement = headerElements.headerActions[this.headerActionIndex];
+                break;
+            case TableFocusType.columnHeader:
+                focusableElement = headerElements.columnHeaders[this.columnIndex];
+                break;
+            default:
+                break;
+        }
+        if (focusableElement) {
+            this.focusElement(focusableElement);
+            return true;
+        }
+        return false;
+    }
+
+    private getCurrentRowVisibleIndex(): number {
+        return this.table.rowElements.findIndex(
+            row => row.resolvedRowIndex === this.rowIndex
+        );
+    }
+
+    private getTableHeaderFocusableElements(): TableHeaderFocusableElements {
+        const headerActions: HTMLElement[] = [];
+        if (
+            this.table.selectionCheckbox?.getRootNode()
+            === this.table.shadowRoot
+        ) {
+            headerActions.push(this.table.selectionCheckbox);
+        }
+
+        if (
+            this.table.showCollapseAll
+            && this.table.collapseAllButton?.getRootNode()
+                === this.table.shadowRoot
+        ) {
+            headerActions.push(this.table.collapseAllButton);
+        }
+
+        const columnHeaders: HTMLElement[] = [];
+        if (this.canFocusColumnHeaders()) {
+            this.table.columnHeadersContainer
+                .querySelectorAll(tableHeaderTag)
+                .forEach(header => columnHeaders.push(header));
+        }
+
+        return { headerActions, columnHeaders };
+    }
+
+    private canFocusColumnHeaders(): boolean {
+        return (
+            this.table.columns.find(c => !c.columnInternals.sortingDisabled)
+            !== undefined
+        );
+    }
+
+    private getCurrentRow(): TableRow | TableGroupRow | undefined {
+        return this.table.rowElements[this.getCurrentRowVisibleIndex()];
+    }
+
+    private isRowExpanded(
+        row: TableRow | TableGroupRow | undefined
+    ): boolean | undefined {
+        if (
+            (row instanceof TableRow && row.isParentRow)
+            || row instanceof TableGroupRow
+        ) {
+            return row.expanded;
+        }
+        return undefined;
+    }
+
+    private toggleRowExpanded(row: TableRow | TableGroupRow): void {
+        if (row instanceof TableGroupRow) {
+            row.onGroupExpandToggle();
+        } else {
+            row.onRowExpandToggle();
+        }
+        this.focusRowElement(row);
+    }
+
+    private getContainingRow(
+        start: Element | undefined | null
+    ): TableRow | TableGroupRow | undefined {
+        return this.getContainingElement(start, e => this.isResolvedRowType(e));
+    }
+
+    private getContainingCell(
+        start: Element | undefined | null
+    ): TableCell | undefined {
+        return this.getContainingElement(start, e => e instanceof TableCell);
+    }
+
+    private getContainingElement<TElement>(
+        start: Element | undefined | null,
+        isElementMatch: (element: Element) => boolean
+    ): TElement | undefined {
+        let possibleMatch = start;
+        while (possibleMatch && possibleMatch !== this.table) {
+            if (isElementMatch(possibleMatch)) {
+                return possibleMatch as TElement;
+            }
+            possibleMatch = possibleMatch.parentElement
+                ?? (possibleMatch.parentNode as ShadowRoot)?.host;
+        }
+
+        return undefined;
+    }
+
+    private isInTable(start: Element): boolean {
+        let possibleMatch = start;
+        while (possibleMatch && possibleMatch !== this.table) {
+            possibleMatch = possibleMatch.parentElement
+                ?? (possibleMatch.parentNode as ShadowRoot)?.host;
+        }
+
+        return possibleMatch === this.table;
+    }
+
+    private getActiveElement(): HTMLElement | null {
+        let activeElement = document.activeElement;
+        while (activeElement?.shadowRoot?.activeElement) {
+            activeElement = activeElement.shadowRoot.activeElement;
+            // In some cases, the active element may be a sub-part of a control (example: MenuButton -> ToggleButton -> a div with tabindex=0). Stop at the outer control boundary, so that
+            // we can more simply check equality against the elements of getTableHeaderFocusableElements() / row.getFocusableElements().
+            // (For rows/cells/cell views, we do need to recurse into them, to get to the appropriate focused controls though)
+            if (
+                activeElement instanceof FoundationElement
+                && !this.isResolvedRowType(activeElement)
+                && !(activeElement instanceof TableCell)
+                && !(activeElement instanceof TableCellView)
+            ) {
+                break;
+            }
+        }
+
+        return activeElement as HTMLElement;
+    }
+
+    private focusFirstInteractiveElementInCurrentCell(
+        rowElements?: TableRowFocusableElements
+    ): boolean {
+        if (!rowElements) {
+            return false;
+        }
+        return (
+            this.trySetCellContentFocus(rowElements, 0)
+            || this.trySetCellActionMenuFocus(rowElements)
+        );
+    }
+
+    private hasRowOrCellFocusType(): boolean {
+        switch (this.focusType) {
+            case TableFocusType.cell:
+            case TableFocusType.cellActionMenu:
+            case TableFocusType.cellContent:
+            case TableFocusType.row:
+            case TableFocusType.rowSelectionCheckbox:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private hasHeaderFocusType(): boolean {
+        switch (this.focusType) {
+            case TableFocusType.headerActions:
+            case TableFocusType.columnHeader:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private trySetRowSelectionCheckboxFocus(
+        rowElements: TableRowFocusableElements | undefined
+    ): boolean {
+        if (rowElements?.selectionCheckbox) {
+            this.focusType = TableFocusType.rowSelectionCheckbox;
+            this.focusCurrentRow(true);
+            return true;
+        }
+        return false;
+    }
+
+    private trySetColumnHeaderFocus(
+        headerElements: TableHeaderFocusableElements,
+        columnIndex: number
+    ): boolean {
+        if (
+            columnIndex >= 0
+            && columnIndex < headerElements.columnHeaders.length
+        ) {
+            this.focusType = TableFocusType.columnHeader;
+            this.columnIndex = columnIndex;
+            this.focusHeaderElement();
+            return true;
+        }
+        return false;
+    }
+
+    private trySetHeaderActionFocus(
+        headerElements: TableHeaderFocusableElements,
+        headerActionIndex: number
+    ): boolean {
+        if (
+            headerActionIndex >= 0
+            && headerActionIndex < headerElements.headerActions.length
+        ) {
+            this.focusType = TableFocusType.headerActions;
+            this.headerActionIndex = headerActionIndex;
+            this.focusHeaderElement();
+            return true;
+        }
+        return false;
+    }
+
+    private trySetCellFocus(
+        rowElements: TableRowFocusableElements | undefined,
+        columnIndex?: number,
+        rowIndex?: number
+    ): boolean {
+        if (!rowElements) {
+            return false;
+        }
+        const newColumnIndex = columnIndex ?? this.columnIndex;
+        const newRowIndex = rowIndex ?? this.rowIndex;
+
+        if (newColumnIndex >= 0 && newColumnIndex < rowElements.cells.length) {
+            this.focusType = TableFocusType.cell;
+            this.setRowCellFocusState(newColumnIndex, newRowIndex, true);
+            return true;
+        }
+
+        return false;
+    }
+
+    private trySetCellContentFocus(
+        rowElements: TableRowFocusableElements | undefined,
+        cellContentIndex: number,
+        columnIndex?: number,
+        rowIndex?: number
+    ): boolean {
+        if (!rowElements) {
+            return false;
+        }
+        const newColumnIndex = columnIndex ?? this.columnIndex;
+        const newRowIndex = rowIndex ?? this.rowIndex;
+
+        if (
+            newColumnIndex >= 0
+            && newColumnIndex < rowElements.cells.length
+            && cellContentIndex >= 0
+            && cellContentIndex
+                < rowElements.cells[newColumnIndex]!.cell.cellView
+                    .tabbableChildren.length
+        ) {
+            this.setCellContentFocusState(
+                cellContentIndex,
+                newRowIndex,
+                newColumnIndex,
+                true
+            );
+            return true;
+        }
+
+        return false;
+    }
+
+    private trySetCellActionMenuFocus(
+        rowElements: TableRowFocusableElements,
+        columnIndex?: number,
+        rowIndex?: number
+    ): boolean {
+        const newColumnIndex = columnIndex ?? this.columnIndex;
+        const newRowIndex = rowIndex ?? this.rowIndex;
+
+        if (
+            newColumnIndex >= 0
+            && newColumnIndex < rowElements.cells.length
+            && rowElements.cells[newColumnIndex]!.actionMenuButton
+        ) {
+            this.setCellActionMenuFocusState(newRowIndex, newColumnIndex, true);
+            return true;
+        }
+
+        return false;
+    }
+
+    private setCellActionMenuFocusState(
+        rowIndex: number,
+        columnIndex: number,
+        focusElement: boolean
+    ): void {
+        this.focusType = TableFocusType.cellActionMenu;
+        this.setRowCellFocusState(columnIndex, rowIndex, focusElement);
+    }
+
+    private setCellContentFocusState(
+        cellContentIndex: number,
+        rowIndex: number,
+        columnIndex: number,
+        focusElement: boolean
+    ): void {
+        this.focusType = TableFocusType.cellContent;
+        this.cellContentIndex = cellContentIndex;
+        this.setRowCellFocusState(columnIndex, rowIndex, focusElement);
+    }
+
+    private setRowFocusState(rowIndex?: number): void {
+        this.focusType = TableFocusType.row;
+        if (rowIndex !== undefined) {
+            this.rowIndex = rowIndex;
+        }
+    }
+
+    private setCellFocusState(
+        columnIndex: number,
+        rowIndex: number,
+        focusElement: boolean
+    ): void {
+        this.focusType = TableFocusType.cell;
+        this.setRowCellFocusState(columnIndex, rowIndex, focusElement);
+    }
+
+    private setRowCellFocusState(
+        columnIndex: number,
+        rowIndex: number,
+        focusElement: boolean
+    ): void {
+        this.rowIndex = rowIndex;
+        this.columnIndex = columnIndex;
+        if (focusElement) {
+            this.focusCurrentRow(true);
+        }
+    }
+
+    private isResolvedRowType(row: unknown): row is TableRow | TableGroupRow {
+        return row instanceof TableRow || row instanceof TableGroupRow;
+    }
+}
diff --git a/packages/nimble-components/src/table/models/table-update-tracker.ts b/packages/nimble-components/src/table/models/table-update-tracker.ts
index 09f94b960c..bfd6bc3577 100644
--- a/packages/nimble-components/src/table/models/table-update-tracker.ts
+++ b/packages/nimble-components/src/table/models/table-update-tracker.ts
@@ -22,7 +22,9 @@ const trackedItems = [
     'rowParentIds',
     'groupRows',
     'columnIds',
+    'columnHidden',
     'columnSort',
+    'columnSortDisabled',
     'columnWidths',
     'columnDefinition',
     'actionMenuSlots',
@@ -97,6 +99,16 @@ export class TableUpdateTracker<
         );
     }
 
+    public get requiresKeyboardFocusReset(): boolean {
+        return (
+            this.isTracked('columnSortDisabled')
+            || this.isTracked('columnDefinition')
+            || this.isTracked('columnHidden')
+            || this.isTracked('selectionMode')
+            || this.isTracked('actionMenuSlots')
+        );
+    }
+
     public trackAllStateChanged(): void {
         this.trackAll();
         this.queueUpdate();
@@ -117,18 +129,21 @@ export class TableUpdateTracker<
             )
         ) {
             this.track('columnDefinition');
+        } else if (
+            isColumnInternalsProperty(changedColumnProperty, 'sortingDisabled')
+        ) {
+            this.track('columnSort');
+            this.track('columnSortDisabled');
         } else if (
             isColumnInternalsProperty(
                 changedColumnProperty,
-                'sortingDisabled',
                 'currentSortDirection',
                 'currentSortIndex'
             )
         ) {
             this.track('columnSort');
         } else if (
-            isColumnProperty(changedColumnProperty, 'columnHidden')
-            || isColumnInternalsProperty(
+            isColumnInternalsProperty(
                 changedColumnProperty,
                 'currentFractionalWidth',
                 'currentPixelWidth',
@@ -137,6 +152,9 @@ export class TableUpdateTracker<
             )
         ) {
             this.track('columnWidths');
+        } else if (isColumnProperty(changedColumnProperty, 'columnHidden')) {
+            this.track('columnWidths');
+            this.track('columnHidden');
         } else if (isColumnProperty(changedColumnProperty, 'actionMenuSlot')) {
             this.track('actionMenuSlots');
         } else if (
@@ -156,6 +174,7 @@ export class TableUpdateTracker<
         this.track('columnIds');
         this.track('columnDefinition');
         this.track('columnSort');
+        this.track('columnSortDisabled');
         this.track('columnWidths');
         this.track('actionMenuSlots');
         this.track('groupRows');
diff --git a/packages/nimble-components/src/table/models/virtualizer.ts b/packages/nimble-components/src/table/models/virtualizer.ts
index a676c4d856..f202bf4e76 100644
--- a/packages/nimble-components/src/table/models/virtualizer.ts
+++ b/packages/nimble-components/src/table/models/virtualizer.ts
@@ -6,12 +6,12 @@ import {
     elementScroll,
     observeElementOffset,
     observeElementRect,
-    VirtualItem
+    VirtualItem,
+    ScrollToOptions
 } from '@tanstack/virtual-core';
 import { borderWidth, controlHeight } from '../../theme-provider/design-tokens';
 import type { Table } from '..';
 import type { TableNode, TableRecord } from '../types';
-import { TableCellView } from '../../table-column/base/cell-view';
 
 /**
  * Helper class for the nimble-table for row virtualization.
@@ -31,10 +31,22 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
     @observable
     public rowContainerYOffset = 0;
 
+    public get pageSize(): number {
+        return this._pageSize;
+    }
+
+    private get rowHeight(): number {
+        return (
+            parseFloat(controlHeight.getValueFor(this.table))
+            + 2 * parseFloat(borderWidth.getValueFor(this.table))
+        );
+    }
+
     private readonly table: Table<TData>;
     private readonly tanStackTable: TanStackTable<TableNode<TData>>;
     private readonly viewportResizeObserver: ResizeObserver;
     private virtualizer?: TanStackVirtualizer<HTMLElement, HTMLElement>;
+    private _pageSize = 0;
 
     public constructor(
         table: Table<TData>,
@@ -45,6 +57,7 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
         this.viewportResizeObserver = new ResizeObserver(entries => {
             const borderBoxSize = entries[0]?.borderBoxSize[0];
             if (borderBoxSize) {
+                this.updatePageSize();
                 // If we have enough rows that a vertical scrollbar is shown, we need to offset the header widths
                 // by the same margin so the column headers align with the corresponding rendered cells
                 const viewportBoundingWidth = borderBoxSize.inlineSize;
@@ -69,6 +82,10 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
         }
     }
 
+    public scrollToIndex(index: number, options?: ScrollToOptions): void {
+        this.virtualizer?.scrollToIndex(index, options);
+    }
+
     private updateVirtualizer(): void {
         const options = this.createVirtualizerOptions();
         if (this.virtualizer) {
@@ -84,8 +101,7 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
     HTMLElement,
     HTMLElement
     > {
-        const rowHeight = parseFloat(controlHeight.getValueFor(this.table))
-            + 2 * parseFloat(borderWidth.getValueFor(this.table));
+        const rowHeight = this.rowHeight;
         return {
             count: this.tanStackTable.getRowModel().rows.length,
             getScrollElement: () => {
@@ -103,7 +119,7 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
     }
 
     private handleVirtualizerChange(): void {
-        this.notifyFocusedCellRecycling();
+        this.table.handleFocusedCellRecycling();
         const virtualizer = this.virtualizer!;
         this.visibleItems = virtualizer.getVirtualItems();
         this.scrollHeight = virtualizer.getTotalSize();
@@ -120,26 +136,9 @@ export class Virtualizer<TData extends TableRecord = TableRecord> {
         this.rowContainerYOffset = rowContainerYOffset;
     }
 
-    private notifyFocusedCellRecycling(): void {
-        let tableFocusedElement = this.table.shadowRoot!.activeElement;
-        while (
-            tableFocusedElement !== null
-            && !(tableFocusedElement instanceof TableCellView)
-        ) {
-            if (tableFocusedElement.shadowRoot) {
-                tableFocusedElement = tableFocusedElement.shadowRoot.activeElement;
-            } else {
-                break;
-            }
-        }
-        if (tableFocusedElement instanceof TableCellView) {
-            tableFocusedElement.focusedRecycleCallback();
-        }
-        if (this.table.openActionMenuRecordId !== undefined) {
-            const activeRow = this.table.rowElements.find(
-                row => row.recordId === this.table.openActionMenuRecordId
-            );
-            activeRow?.closeOpenActionMenus();
-        }
+    private updatePageSize(): void {
+        this._pageSize = Math.round(
+            this.table.viewport.clientHeight / this.rowHeight
+        );
     }
 }
diff --git a/packages/nimble-components/src/table/styles.ts b/packages/nimble-components/src/table/styles.ts
index c891be4946..0fe59a6763 100644
--- a/packages/nimble-components/src/table/styles.ts
+++ b/packages/nimble-components/src/table/styles.ts
@@ -18,6 +18,7 @@ import { themeBehavior } from '../utilities/style/theme';
 import { userSelectNone } from '../utilities/style/user-select';
 import { accessiblyHidden } from '../utilities/style/accessibly-hidden';
 import { ZIndexLevels } from '../utilities/style/types';
+import { focusVisible } from '../utilities/style/focus';
 
 export const styles = css`
     ${display('flex')}
@@ -28,6 +29,16 @@ export const styles = css`
         --ni-private-column-divider-padding: 3px;
     }
 
+    :host(${focusVisible}) {
+        ${
+            /* The table can briefly be focused in some keyboard nav cases (e.g. regaining focus and we
+            need to scroll to the previously focused row first). Ensure that we don't get the browser-default
+            focus outline in that case.
+        ) */ ''
+        }
+        outline: none;
+    }
+
     .disable-select {
         ${userSelectNone}
     }
@@ -158,6 +169,10 @@ export const styles = css`
         position: relative;
     }
 
+    .table-viewport${focusVisible} {
+        outline: none;
+    }
+
     .table-scroll {
         pointer-events: none;
         position: absolute;
@@ -184,10 +199,17 @@ export const styles = css`
 
     .group-row {
         position: relative;
+        --ni-private-table-cell-focus-offset-multiplier: 0;
     }
 
     .row {
         position: relative;
+        --ni-private-table-cell-focus-offset-multiplier: 0;
+    }
+
+    .collapse-all-visible .row,
+    .collapse-all-visible .group-row {
+        --ni-private-table-cell-focus-offset-multiplier: 1;
     }
 
     .accessibly-hidden {
diff --git a/packages/nimble-components/src/table/template.ts b/packages/nimble-components/src/table/template.ts
index 8353f3861f..d04441be3f 100644
--- a/packages/nimble-components/src/table/template.ts
+++ b/packages/nimble-components/src/table/template.ts
@@ -33,6 +33,8 @@ import {
 export const template = html<Table>`
     <template
         role="treegrid"
+        ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+        tabindex="0"
         aria-multiselectable="${x => x.ariaMultiSelectable}"
         ${children({ property: 'childItems', filter: elements() })}
     >
@@ -60,6 +62,8 @@ export const template = html<Table>`
                                 <span class="checkbox-container">
                                     <${checkboxTag}
                                         ${ref('selectionCheckbox')}
+                                        ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                                        tabindex="-1"
                                         class="${x => `selection-checkbox ${x.selectionMode ? x.selectionMode : ''}`}"
                                         @change="${(x, c) => x.onAllRowsSelectionChange(c.event as CustomEvent)}"
                                         title="${x => tableSelectAllLabel.getValueFor(x)}"
@@ -69,6 +73,9 @@ export const template = html<Table>`
                                 </span>
                             `)}
                             <${buttonTag}
+                                ${ref('collapseAllButton')}
+                                ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                                tabindex="-1"
                                 class="collapse-all-button ${x => `${x.showCollapseAll ? 'visible' : ''}`}"
                                 content-hidden
                                 appearance="${ButtonAppearance.ghost}"
@@ -96,9 +103,11 @@ export const template = html<Table>`
                                     `)}
                                         <${tableHeaderTag}
                                             class="header"
+                                            ${'' /* tabindex managed dynamically by KeyboardNavigationManager (if column sorting not disabled) */}
                                             sort-direction="${x => (typeof x.columnInternals.currentSortIndex === 'number' ? x.columnInternals.currentSortDirection : TableColumnSortDirection.none)}"
                                             ?first-sorted-column="${(x, c) => x === c.parent.firstSortedColumn}"
                                             ?indicators-hidden="${x => x.columnInternals.hideHeaderIndicators}"
+                                            @keydown="${(x, c) => c.parent.onHeaderKeyDown(x, c.event as KeyboardEvent)}"
                                             @click="${(x, c) => c.parent.toggleColumnSort(x, (c.event as MouseEvent).shiftKey)}"
                                             :isGrouped=${x => (typeof x.columnInternals.groupIndex === 'number' && !x.columnInternals.groupingDisabled)}
                                         >
@@ -122,15 +131,17 @@ export const template = html<Table>`
                         </span>
                     </div>
                 </div>
-                <div class="table-viewport" ${ref('viewport')}>
+                <div class="table-viewport" tabindex="-1" ${ref('viewport')}>
                     <div class="table-scroll"></div>
-                    <div class="table-row-container" ${children({ property: 'rowElements', filter: elements(tableRowTag) })}
+                    <div class="table-row-container ${x => `${x.showCollapseAll ? 'collapse-all-visible' : ''}`}" ${children({ property: 'rowElements', filter: elements(`${tableRowTag}, ${tableGroupRowTag}`) })}
                         role="rowgroup">
                         ${when(x => x.columns.length > 0 && x.canRenderRows, html<Table>`
                             ${repeat(x => x.virtualizer.visibleItems, html<VirtualItem, Table>`
                                 ${when((x, c) => (c.parent as Table).tableData[x.index]?.isGroupRow, html<VirtualItem, Table>`
                                     <${tableGroupRowTag}
                                         class="group-row"
+                                        ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                                        tabindex="-1"
                                         :groupRowValue="${(x, c) => c.parent.tableData[x.index]?.groupRowValue}"
                                         ?expanded="${(x, c) => c.parent.tableData[x.index]?.isExpanded}"
                                         :nestingLevel="${(x, c) => c.parent.tableData[x.index]?.nestingLevel}"
@@ -138,6 +149,9 @@ export const template = html<Table>`
                                         :groupColumn="${(x, c) => c.parent.tableData[x.index]?.groupColumn}"
                                         ?selectable="${(_, c) => c.parent.selectionMode === TableRowSelectionMode.multiple}"
                                         selection-state="${(x, c) => c.parent.tableData[x.index]?.selectionState}"
+                                        :resolvedRowIndex="${x => x.index}"
+                                        @focusin="${(_, c) => c.parent.onRowFocusIn(c.event as FocusEvent)}"
+                                        @blur="${(_, c) => c.parent.onRowBlur(c.event as FocusEvent)}"
                                         @group-selection-toggle="${(x, c) => c.parent.onRowSelectionToggle(x.index, c.event as CustomEvent<TableRowSelectionToggleEventDetail>)}"
                                         @group-expand-toggle="${(x, c) => c.parent.handleGroupRowExpanded(x.index, c.event)}"
                                     >
@@ -146,6 +160,8 @@ export const template = html<Table>`
                                 ${when((x, c) => !(c.parent as Table).tableData[x.index]?.isGroupRow, html<VirtualItem, Table>`
                                     <${tableRowTag}
                                         class="row"
+                                        ${'' /* tabindex managed dynamically by KeyboardNavigationManager */}
+                                        tabindex="-1"
                                         record-id="${(x, c) => c.parent.tableData[x.index]?.id}"
                                         ?selectable="${(_, c) => c.parent.selectionMode !== TableRowSelectionMode.none}"
                                         ?selected="${(x, c) => c.parent.tableData[x.index]?.selectionState === TableRowSelectionState.selected}"
@@ -157,12 +173,14 @@ export const template = html<Table>`
                                         :nestingLevel="${(x, c) => c.parent.tableData[x.index]?.nestingLevel}"
                                         ?row-operation-grid-cell-hidden="${(_, c) => !c.parent.showRowOperationColumn}"
                                         ?loading="${(x, c) => c.parent.tableData[x.index]?.isLoadingChildren}"
+                                        :resolvedRowIndex="${x => x.index}"
                                         @click="${(x, c) => c.parent.onRowClick(x.index, c.event as MouseEvent)}"
+                                        @focusin="${(_, c) => c.parent.onRowFocusIn(c.event as FocusEvent)}"
+                                        @blur="${(_, c) => c.parent.onRowBlur(c.event as FocusEvent)}"
                                         @row-selection-toggle="${(x, c) => c.parent.onRowSelectionToggle(x.index, c.event as CustomEvent<TableRowSelectionToggleEventDetail>)}"
                                         @row-action-menu-beforetoggle="${(x, c) => c.parent.onRowActionMenuBeforeToggle(x.index, c.event as CustomEvent<TableActionMenuToggleEventDetail>)}"
                                         @row-action-menu-toggle="${(_, c) => c.parent.onRowActionMenuToggle(c.event as CustomEvent<TableActionMenuToggleEventDetail>)}"
                                         @row-expand-toggle="${(x, c) => c.parent.handleRowExpanded(x.index)}"
-                                        :dataIndex="${x => x.index}"
                                     >
                                     ${when((x, c) => (c.parent as Table).openActionMenuRecordId === (c.parent as Table).tableData[x.index]?.id, html<VirtualItem, Table>`
                                         ${repeat((_, c) => (c.parent as Table).actionMenuSlots, html<string, Table>`
diff --git a/packages/nimble-components/src/table/testing/table.pageobject.ts b/packages/nimble-components/src/table/testing/table.pageobject.ts
index 7b7357fa9e..f6de40a6d5 100644
--- a/packages/nimble-components/src/table/testing/table.pageobject.ts
+++ b/packages/nimble-components/src/table/testing/table.pageobject.ts
@@ -142,7 +142,7 @@ export class TablePageObject<T extends TableRecord> {
         columnIndex: number
     ): TableCellView {
         const cell = this.getCell(rowIndex, columnIndex);
-        const cellView = cell.shadowRoot!.firstElementChild;
+        const cellView = cell.cellViewContainer.firstElementChild;
         if (!(cellView instanceof TableCellView)) {
             throw new Error(
                 'Cell view not found in cell - ensure cellViewTag is set for column'
@@ -156,7 +156,7 @@ export class TablePageObject<T extends TableRecord> {
         columnId: string
     ): TableCellView {
         const cell = this.getCellById(recordId, columnId);
-        const cellView = cell.shadowRoot!.firstElementChild;
+        const cellView = cell.cellViewContainer.firstElementChild;
         if (!(cellView instanceof TableCellView)) {
             throw new Error(
                 'Cell view not found in cell - ensure cellViewTag is set for column'
@@ -301,6 +301,12 @@ export class TablePageObject<T extends TableRecord> {
         }, 0);
     }
 
+    public async scrollToFirstRowAsync(): Promise<void> {
+        const scrollElement = this.tableElement.viewport;
+        scrollElement.scroll({ top: 0 });
+        await waitForUpdatesAsync();
+    }
+
     public async scrollToLastRowAsync(): Promise<void> {
         const scrollElement = this.tableElement.viewport;
         scrollElement.scroll({ top: scrollElement.scrollHeight });
@@ -656,7 +662,8 @@ export class TablePageObject<T extends TableRecord> {
         return groupRow.shadowRoot!.querySelector('.group-header-view')!;
     }
 
-    private getRow(rowIndex: number): TableRow {
+    /** @internal */
+    public getRow(rowIndex: number): TableRow {
         const rows = this.tableElement.shadowRoot!.querySelectorAll('nimble-table-row');
         if (rowIndex >= rows.length) {
             throw new Error(
@@ -667,6 +674,19 @@ export class TablePageObject<T extends TableRecord> {
         return rows.item(rowIndex);
     }
 
+    /** @internal */
+    public getCell(rowIndex: number, columnIndex: number): TableCell {
+        const row = this.getRow(rowIndex);
+        const cells = row.shadowRoot!.querySelectorAll('nimble-table-cell');
+        if (columnIndex >= cells.length) {
+            throw new Error(
+                'Attempting to index past the total number of rendered columns'
+            );
+        }
+
+        return cells.item(columnIndex);
+    }
+
     private getRowById(recordId: string): TableRow {
         const row: TableRow | null = this.tableElement.shadowRoot!.querySelector(
             `nimble-table-row[record-id="${CSS.escape(recordId)}"]`
@@ -680,18 +700,6 @@ export class TablePageObject<T extends TableRecord> {
         return row;
     }
 
-    private getCell(rowIndex: number, columnIndex: number): TableCell {
-        const row = this.getRow(rowIndex);
-        const cells = row.shadowRoot!.querySelectorAll('nimble-table-cell');
-        if (columnIndex >= cells.length) {
-            throw new Error(
-                'Attempting to index past the total number of rendered columns'
-            );
-        }
-
-        return cells.item(columnIndex);
-    }
-
     private getCellById(recordId: string, columnId: string): TableCell {
         const row = this.getRowById(recordId);
         const cell: TableCell | null = row.shadowRoot!.querySelector(
diff --git a/packages/nimble-components/src/table/tests/table-action-menu.spec.ts b/packages/nimble-components/src/table/tests/table-action-menu.spec.ts
index 46f47c9f81..f8d58690b6 100644
--- a/packages/nimble-components/src/table/tests/table-action-menu.spec.ts
+++ b/packages/nimble-components/src/table/tests/table-action-menu.spec.ts
@@ -198,6 +198,46 @@ describe('Table action menu', () => {
         expect(menuButton.textContent?.trim()).toEqual(label);
     });
 
+    it('button is included in row getFocusableElements() result', async () => {
+        const slot = 'my-action-menu';
+        column1.actionMenuSlot = slot;
+        createAndSlotMenu(slot);
+        await connect();
+        await waitForUpdatesAsync();
+
+        const row = pageObject.getRow(0)!;
+        const focusableElements = row.getFocusableElements();
+        expect(focusableElements.cells.length).toBe(2);
+        expect(focusableElements.cells[0]!.actionMenuButton).toBe(
+            pageObject.getCellActionMenu(0, 0)!
+        );
+        expect(focusableElements.cells[1]!.actionMenuButton).toBeUndefined();
+    });
+
+    it('when action menu button is blurred, cell fires cell-action-menu-blur event', async () => {
+        const slot = 'my-action-menu';
+        column1.actionMenuSlot = slot;
+        createAndSlotMenu(slot);
+        await connect();
+        await waitForUpdatesAsync();
+        pageObject.setRowHoverState(1, true);
+        await waitForUpdatesAsync();
+        const cell = pageObject.getCell(1, 0)!;
+        const menuButton = pageObject.getCellActionMenu(1, 0)!;
+        const blurListener = createEventListener(cell, 'cell-action-menu-blur');
+        menuButton.focus();
+        await waitForUpdatesAsync();
+
+        expect(blurListener.spy).not.toHaveBeenCalled();
+
+        menuButton.blur();
+        await blurListener.promise;
+
+        expect(blurListener.spy).toHaveBeenCalledOnceWith(
+            jasmine.objectContaining({ detail: cell })
+        );
+    });
+
     it('table creates two slots for two unique `action-menu-slot` values', async () => {
         const slot1 = 'my-action-menu';
         column1.actionMenuSlot = slot1;
diff --git a/packages/nimble-components/src/table/tests/table-keyboard-navigation.spec.ts b/packages/nimble-components/src/table/tests/table-keyboard-navigation.spec.ts
new file mode 100644
index 0000000000..e3598feb25
--- /dev/null
+++ b/packages/nimble-components/src/table/tests/table-keyboard-navigation.spec.ts
@@ -0,0 +1,1426 @@
+/* eslint-disable no-await-in-loop */
+import { customElement, html, observable, ref } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import {
+    keyArrowDown,
+    keyArrowLeft,
+    keyArrowRight,
+    keyArrowUp,
+    keyEnd,
+    keyEnter,
+    keyEscape,
+    keyFunction2,
+    keyHome,
+    keyPageDown,
+    keyPageUp,
+    keySpace,
+    keyTab
+} from '@microsoft/fast-web-utilities';
+import { parameterizeSpec } from '@ni/jasmine-parameterized';
+import type { Table } from '..';
+import { waitForUpdatesAsync } from '../../testing/async-helpers';
+import {
+    type Fixture,
+    fixture,
+    uniqueElementName
+} from '../../utilities/tests/fixture';
+import {
+    TableColumnSortDirection,
+    TableRecord,
+    TableRowSelectionMode
+} from '../types';
+import { TablePageObject } from '../testing/table.pageobject';
+import {
+    createEventListener,
+    sendKeyDownEvent
+} from '../../utilities/tests/component';
+import { TableRow } from '../components/row';
+import { TableCell } from '../components/cell';
+import { TableCellView } from '../../table-column/base/cell-view';
+import { TableColumn } from '../../table-column/base';
+import { TableGroupRow } from '../components/group-row';
+import { menuItemTag } from '../../menu-item';
+import {
+    tableColumnEmptyCellViewTag,
+    tableColumnEmptyGroupHeaderViewTag
+} from '../../table-column/base/tests/table-column.fixtures';
+import { mixinGroupableColumnAPI } from '../../table-column/mixins/groupable-column';
+import type { ColumnInternalsOptions } from '../../table-column/base/models/column-internals';
+import { ColumnValidator } from '../../table-column/base/models/column-validator';
+import { mixinSortableColumnAPI } from '../../table-column/mixins/sortable-column';
+
+interface SimpleTableRecord extends TableRecord {
+    id: string;
+    value?: string | null;
+    parentId?: string;
+}
+
+function currentFocusedElement(): HTMLElement | null {
+    let activeElement = document.activeElement;
+    while (activeElement?.shadowRoot?.activeElement) {
+        activeElement = activeElement.shadowRoot.activeElement;
+        // In some cases, the active element may be a sub-part of a control (example: MenuButton -> ToggleButton -> a div with tabindex=0). Stop at the outer control boundary, so that
+        // we can more simply check element equality.
+        // (For rows/cells/cell views, we do need to recurse into them, to get to the appropriate focused controls though)
+        if (
+            activeElement instanceof FoundationElement
+            && !(activeElement instanceof TableRow)
+            && !(activeElement instanceof TableGroupRow)
+            && !(activeElement instanceof TableCell)
+            && !(activeElement instanceof TableCellView)
+        ) {
+            break;
+        }
+    }
+
+    return activeElement as HTMLElement;
+}
+
+describe('Table keyboard navigation', () => {
+    let element: Table<SimpleTableRecord>;
+    let connect: () => Promise<void>;
+    let disconnect: () => Promise<void>;
+    let pageObject: TablePageObject<SimpleTableRecord>;
+
+    async function addActionMenu(column: TableColumn): Promise<void> {
+        column.actionMenuSlot = `${column.id}-action-menu-slot`;
+        column.actionMenuLabel = 'Actions';
+
+        const menu = document.createElement('nimble-menu');
+        menu.slot = column.actionMenuSlot;
+
+        const menuItem1 = document.createElement('nimble-menu-item');
+        menuItem1.textContent = 'menu item 1';
+        menu.appendChild(menuItem1);
+
+        element.appendChild(menu);
+
+        await waitForUpdatesAsync();
+    }
+
+    async function verifyLastTabKeyEventBehavior(
+        keyEvent: KeyboardEvent
+    ): Promise<void> {
+        // Note: Dispatching key events with dispatchEvent is not sufficient to trigger the browser's built-in Tab behavior.
+        // From these tests, we can only check defaultPrevented (and assume that defaultPrevented=false means that the browser will
+        // focus the expected element outside the table).
+        expect(keyEvent.defaultPrevented).toBe(false);
+        // Currently KeyboardNavigationManager will set tabindex=-1 on the focused element, but not blur it, relying on the browser's
+        // built in behavior for that (for correct behavior in Safari).
+        const focusedElement = currentFocusedElement()!;
+        expect(focusedElement).not.toBeNull();
+        expect(focusedElement.tabIndex).toBe(-1);
+        // Manually blur so we can ensure that the table doesn't re-take focus
+        focusedElement.blur();
+        await waitForUpdatesAsync();
+        expect(element.shadowRoot?.activeElement).toBeNull();
+    }
+
+    async function sendKeyPressToTable(
+        key: string,
+        init?: KeyboardEventInit
+    ): Promise<KeyboardEvent> {
+        return sendKeyDownEvent(element, key, init);
+    }
+
+    async function sendKeyPressesToTable(...keys: string[]): Promise<void> {
+        for (const key of keys) {
+            await sendKeyPressToTable(key);
+        }
+    }
+
+    function getContainingElement<TElement>(
+        start: Element | undefined | null,
+        isElementMatch: (element: Element) => boolean
+    ): TElement | undefined {
+        let possibleMatch = start;
+        while (possibleMatch && possibleMatch !== element) {
+            if (isElementMatch(possibleMatch)) {
+                return possibleMatch as TElement;
+            }
+            possibleMatch = possibleMatch.parentElement
+                ?? (possibleMatch.parentNode as ShadowRoot)?.host;
+        }
+
+        return undefined;
+    }
+
+    async function clickAndSendFocusEvents(
+        newFocus: HTMLElement
+    ): Promise<void> {
+        const oldFocus = currentFocusedElement();
+        const oldRow = oldFocus instanceof TableRow
+            ? oldFocus
+            : getContainingElement<TableRow>(
+                oldFocus,
+                el => el instanceof TableRow
+            );
+        const oldCell = oldFocus instanceof TableCell
+            ? oldFocus
+            : getContainingElement<TableCell>(
+                oldFocus,
+                el => el instanceof TableCell
+            );
+        const oldCellContent = oldFocus !== oldRow && oldFocus !== oldCell ? oldFocus : undefined;
+        const newRow = newFocus instanceof TableRow
+            ? newFocus
+            : getContainingElement<TableRow>(
+                newFocus,
+                el => el instanceof TableRow
+            );
+        const newCell = newFocus instanceof TableCell
+            ? newFocus
+            : getContainingElement<TableCell>(
+                newFocus,
+                el => el instanceof TableCell
+            );
+        const newCellContent = newFocus !== newRow && newFocus !== newCell ? newFocus : undefined;
+
+        newFocus.click();
+        oldCellContent?.dispatchEvent(new FocusEvent('blur'));
+        oldCell?.dispatchEvent(new FocusEvent('blur'));
+        oldRow?.dispatchEvent(new FocusEvent('blur'));
+        newRow?.dispatchEvent(new FocusEvent('focusin'));
+        newCell?.dispatchEvent(new FocusEvent('focusin'));
+        newCellContent?.dispatchEvent(new FocusEvent('focusin'));
+        newFocus.focus();
+        await waitForUpdatesAsync();
+    }
+
+    describe('with non-interactive columns', () => {
+        const nonInteractiveColumnName = uniqueElementName();
+        // prettier-ignore
+        @customElement({
+            name: nonInteractiveColumnName
+        })
+        class TestNonInteractiveTableColumn extends mixinSortableColumnAPI(mixinGroupableColumnAPI(TableColumn)) {
+            protected override getColumnInternalsOptions(): ColumnInternalsOptions {
+                return {
+                    cellRecordFieldNames: ['value'],
+                    cellViewTag: tableColumnEmptyCellViewTag,
+                    groupHeaderViewTag: tableColumnEmptyGroupHeaderViewTag,
+                    delegatedEvents: [],
+                    validator: new ColumnValidator<[]>([])
+                };
+            }
+        }
+
+        // prettier-ignore
+        async function setupNonInteractiveTable(): Promise<Fixture<Table<SimpleTableRecord>>> {
+            return fixture<Table<SimpleTableRecord>>(
+                html`<nimble-table id-field-name="id">
+                <${nonInteractiveColumnName} id="first-column" column-id="column-1"></${nonInteractiveColumnName}>
+                <${nonInteractiveColumnName} id="second-column" column-id="column-2"></${nonInteractiveColumnName}>
+                <${nonInteractiveColumnName} id="third-column" column-id="column-3"></${nonInteractiveColumnName}>
+            </nimble-table>`
+            );
+        }
+
+        let column1: TestNonInteractiveTableColumn;
+        let column2: TestNonInteractiveTableColumn;
+        let column3: TestNonInteractiveTableColumn;
+        const largeDataRowCount = 1000;
+
+        function createTableData(rowCount: number): SimpleTableRecord[] {
+            const data: SimpleTableRecord[] = [];
+            for (let i = 0; i < rowCount; i++) {
+                data.push({
+                    id: i.toString(),
+                    value: `a${i}`
+                });
+            }
+            return data;
+        }
+
+        async function setupBasicTable(): Promise<void> {
+            const data: readonly SimpleTableRecord[] = [
+                {
+                    id: '1',
+                    value: 'a1'
+                },
+                {
+                    id: '2',
+                    value: 'a2'
+                },
+                {
+                    id: '3',
+                    value: 'a3'
+                },
+                {
+                    id: '4',
+                    value: 'a4'
+                }
+            ] as const;
+
+            await element.setData(data);
+            await connect();
+            await waitForUpdatesAsync();
+        }
+
+        async function setupTableWithGrouping(): Promise<void> {
+            const data: readonly SimpleTableRecord[] = [
+                {
+                    id: '1',
+                    value: 'a1'
+                },
+                {
+                    id: '2',
+                    value: 'a2'
+                },
+                {
+                    id: '3',
+                    value: 'a3'
+                },
+                {
+                    id: '4',
+                    value: 'a4'
+                }
+            ] as const;
+
+            await element.setData(data);
+            column2.groupIndex = 0;
+            await connect();
+            await waitForUpdatesAsync();
+        }
+
+        async function setupLargeDataTable(): Promise<void> {
+            const data = createTableData(largeDataRowCount);
+            await element.setData(data);
+            await connect();
+            await waitForUpdatesAsync();
+        }
+
+        beforeEach(async () => {
+            ({ element, connect, disconnect } = await setupNonInteractiveTable());
+            pageObject = new TablePageObject<SimpleTableRecord>(element);
+            column1 = element.querySelector<TestNonInteractiveTableColumn>(
+                '#first-column'
+            )!;
+            column2 = element.querySelector<TestNonInteractiveTableColumn>(
+                '#second-column'
+            )!;
+            column3 = element.querySelector<TestNonInteractiveTableColumn>(
+                '#third-column'
+            )!;
+        });
+
+        afterEach(async () => {
+            await disconnect();
+        });
+
+        describe('for a simple table (no hierarchy/grouping/selection) with focus', () => {
+            beforeEach(async () => {
+                await setupBasicTable();
+                element.focus();
+                await waitForUpdatesAsync();
+            });
+
+            it('on initial table focus, the 1st column header is focused if sortable', () => {
+                const firstHeader = pageObject.getHeaderElement(0);
+                expect(currentFocusedElement()).toBe(firstHeader);
+            });
+
+            it('consecutive Enter key presses will sort the focused column (ascending, descending, no sort)', async () => {
+                const firstHeader = pageObject.getHeaderElement(0);
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.none
+                );
+
+                const focusedColumn = currentFocusedElement()!;
+                await sendKeyDownEvent(focusedColumn, keyEnter);
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.ascending
+                );
+
+                await sendKeyDownEvent(focusedColumn, keyEnter);
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.descending
+                );
+
+                await sendKeyDownEvent(focusedColumn, keyEnter);
+                await waitForUpdatesAsync();
+                expect(
+                    firstHeader.sortDirection
+                        === TableColumnSortDirection.none
+                        || firstHeader.sortDirection === null
+                ).toBe(true);
+            });
+
+            it('Shift-Enter key presses will sort the focused column (ascending, descending, no sort) and maintain other sorted columns', async () => {
+                const firstHeader = pageObject.getHeaderElement(0);
+                const secondHeader = pageObject.getHeaderElement(1);
+                await sendKeyDownEvent(currentFocusedElement()!, keyEnter);
+                await sendKeyPressToTable(keyArrowRight);
+
+                const focusedColumn = currentFocusedElement()!;
+                await sendKeyDownEvent(focusedColumn, keyEnter, {
+                    shiftKey: true
+                });
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.ascending
+                );
+                expect(secondHeader.sortDirection).toBe(
+                    TableColumnSortDirection.ascending
+                );
+
+                await sendKeyDownEvent(focusedColumn, keyEnter, {
+                    shiftKey: true
+                });
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.ascending
+                );
+                expect(secondHeader.sortDirection).toBe(
+                    TableColumnSortDirection.descending
+                );
+
+                await sendKeyDownEvent(focusedColumn, keyEnter, {
+                    shiftKey: true
+                });
+                expect(firstHeader.sortDirection).toBe(
+                    TableColumnSortDirection.ascending
+                );
+                expect(
+                    secondHeader.sortDirection
+                        === TableColumnSortDirection.none
+                        || secondHeader.sortDirection === null
+                ).toBe(true);
+            });
+
+            it('consecutive RightArrow presses focus each header to the right, stopping at the last header', async () => {
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(0)
+                );
+                await sendKeyPressToTable(keyArrowRight);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(1)
+                );
+                await sendKeyPressToTable(keyArrowRight);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(2)
+                );
+                await sendKeyPressToTable(keyArrowRight);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(2)
+                );
+            });
+
+            it('from the last header being focused, consecutive LeftArrow presses focus each header to the left, stopping at the 1st header', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowRight,
+                    keyArrowRight,
+                    keyArrowRight
+                );
+
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(2)
+                );
+                await sendKeyPressToTable(keyArrowLeft);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(1)
+                );
+                await sendKeyPressToTable(keyArrowLeft);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(0)
+                );
+                await sendKeyPressToTable(keyArrowLeft);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getHeaderElement(0)
+                );
+            });
+
+            it('after a DownArrow key press (from 1st column header), cell[0, 0] is focused', async () => {
+                await sendKeyPressToTable(keyArrowDown);
+
+                const firstCell = pageObject.getCell(0, 0);
+                expect(currentFocusedElement()).toBe(firstCell);
+            });
+
+            describe('starting with cell[0, 0] focused,', () => {
+                beforeEach(async () => {
+                    await sendKeyPressToTable(keyArrowDown);
+                });
+
+                it('pressing LeftArrow will focus the entire row', async () => {
+                    await sendKeyPressToTable(keyArrowLeft);
+                    expect(currentFocusedElement()).toBe(pageObject.getRow(0));
+                });
+
+                it('consecutive RightArrow presses focus each cell to the right in the same row, stopping at the last cell', async () => {
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 0)
+                    );
+                    await sendKeyPressToTable(keyArrowRight);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 1)
+                    );
+                    await sendKeyPressToTable(keyArrowRight);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 2)
+                    );
+                    await sendKeyPressToTable(keyArrowRight);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 2)
+                    );
+                });
+
+                it('from the last cell being focused, consecutive LeftArrow presses focus each cell to the left in the same row', async () => {
+                    await sendKeyPressesToTable(
+                        keyArrowRight,
+                        keyArrowRight,
+                        keyArrowRight
+                    );
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 2)
+                    );
+                    await sendKeyPressToTable(keyArrowLeft);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 1)
+                    );
+                    await sendKeyPressToTable(keyArrowLeft);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 0)
+                    );
+                });
+
+                it('End will focus the last cell in the same row, and Home will focus the 1st cell in the same row', async () => {
+                    await sendKeyPressToTable(keyEnd);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 2)
+                    );
+
+                    await sendKeyPressToTable(keyHome);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 0)
+                    );
+                });
+
+                it('consecutive DownArrow presses focus each cell to the bottom in subsequent rows', async () => {
+                    await sendKeyPressToTable(keyArrowDown);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(1, 0)
+                    );
+                    await sendKeyPressToTable(keyArrowDown);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(2, 0)
+                    );
+                    await sendKeyPressToTable(keyArrowDown);
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(3, 0)
+                    );
+                });
+
+                it('with no tabbable elements in the row, pressing Tab will move focus past the table', async () => {
+                    const keyEvent = await sendKeyPressToTable(keyTab);
+
+                    await verifyLastTabKeyEventBehavior(keyEvent);
+                });
+
+                it('with no tabbable elements in the row, pressing Shift-Tab will move focus past the table', async () => {
+                    const keyEvent = await sendKeyPressToTable(keyTab);
+
+                    await verifyLastTabKeyEventBehavior(keyEvent);
+                });
+
+                it('clicking a cell in a new row, then a cell in the original row, will focus the clicked (original) row', async () => {
+                    await clickAndSendFocusEvents(pageObject.getCell(1, 0));
+                    await clickAndSendFocusEvents(pageObject.getCell(0, 0));
+
+                    expect(currentFocusedElement()).toBe(pageObject.getRow(0));
+                });
+
+                it('when the table data changes (same or greater row count), the focused cell is maintained (row at the same index)', async () => {
+                    await sendKeyPressesToTable(keyArrowDown, keyArrowDown); // cell 2, 0
+
+                    const newData: SimpleTableRecord[] = [
+                        { id: 'A' },
+                        { id: 'B' },
+                        { id: 'C' },
+                        { id: 'D' },
+                        { id: 'E' }
+                    ];
+                    await element.setData(newData);
+                    await waitForUpdatesAsync();
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(2, 0)
+                    );
+                });
+
+                it('when the table data changes (fewer rows than previously focused row index), the focused cell resets to be for the 1st row', async () => {
+                    await sendKeyPressesToTable(keyArrowDown, keyArrowDown); // cell 2, 0
+
+                    const newData: SimpleTableRecord[] = [
+                        { id: 'A' },
+                        { id: 'B' }
+                    ];
+                    await element.setData(newData);
+                    await waitForUpdatesAsync();
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getCell(0, 0)
+                    );
+                });
+
+                it('when the table data changes to zero rows, the focus resets to the header', async () => {
+                    await sendKeyPressesToTable(keyArrowDown, keyArrowDown); // cell 2, 0
+
+                    const newData: SimpleTableRecord[] = [];
+                    await element.setData(newData);
+                    await waitForUpdatesAsync();
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getHeaderElement(0)
+                    );
+                });
+            });
+
+            it('DownArrow key press will focus the cell in the same column in the next row', async () => {
+                await sendKeyPressesToTable(keyArrowDown, keyArrowRight); // cell 0, 1
+
+                await sendKeyPressToTable(keyArrowDown);
+                expect(currentFocusedElement()).toBe(pageObject.getCell(1, 1));
+            });
+
+            it('UpArrow key press will focus the cell in the same column in the previous row', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowDown,
+                    keyArrowDown,
+                    keyArrowRight
+                ); // cell 1, 1
+
+                await sendKeyPressToTable(keyArrowUp);
+                expect(currentFocusedElement()).toBe(pageObject.getCell(0, 1));
+            });
+
+            it('a row is tabindex 0 when focused, and tabindex -1 when clicked away from', async () => {
+                await sendKeyPressesToTable(keyArrowDown, keyArrowLeft); // focus row
+                const firstRow = pageObject.getRow(0);
+
+                expect(firstRow.tabIndex).toBe(0);
+
+                await clickAndSendFocusEvents(pageObject.getCell(1, 0));
+
+                expect(firstRow.tabIndex).toBe(-1);
+            });
+
+            it('when a row is focused, pressing Space has no effect when selectionMode is none (row not selected)', async () => {
+                await sendKeyPressesToTable(keyArrowDown, keyArrowLeft);
+
+                await sendKeyPressToTable(keySpace);
+
+                expect(currentFocusedElement()).toBe(pageObject.getRow(0));
+                expect(pageObject.getRow(0).selected).toBe(false);
+            });
+
+            // This test relies on :focus-visible styling for the action menus to show, and programmatic focus / key events don't seem to
+            // trigger that for Firefox/WebKit.
+            it('when a row is focused, all action menus in that row are visible (and otherwise hidden) #SkipFirefox #SkipWebkit', async () => {
+                await addActionMenu(column2);
+                await addActionMenu(column3);
+                await sendKeyPressesToTable(keyArrowDown, keyArrowLeft); // focus row
+
+                expect(pageObject.isCellActionMenuVisible(0, 1)).toBe(true);
+                expect(pageObject.isCellActionMenuVisible(0, 2)).toBe(true);
+
+                await sendKeyPressToTable(keyArrowRight); // focus cell 0, 0
+                expect(pageObject.isCellActionMenuVisible(0, 1)).toBe(false);
+                expect(pageObject.isCellActionMenuVisible(0, 2)).toBe(false);
+            });
+
+            // This test relies on :focus-visible styling for the action menus to show, and programmatic focus / key events don't seem to
+            // trigger that for Firefox/WebKit.
+            it('when a cell is focused, its action menu is visible #SkipFirefox #SkipWebkit', async () => {
+                await addActionMenu(column1);
+
+                await sendKeyPressToTable(keyArrowDown);
+
+                expect(pageObject.isCellActionMenuVisible(0, 0)).toBe(true);
+            });
+
+            it('when a cell with an action menu is focused, pressing Ctrl-Enter will open the action menu', async () => {
+                await addActionMenu(column1);
+                await sendKeyPressToTable(keyArrowDown);
+
+                const toggleListener = createEventListener(
+                    element,
+                    'action-menu-toggle'
+                );
+                await sendKeyPressToTable(keyEnter, { ctrlKey: true });
+                await toggleListener.promise;
+
+                expect(pageObject.getCell(0, 0).menuOpen).toBe(true);
+            });
+
+            it('when a cell with an action menu is focused, pressing Enter will focus the action menu (if the cell contains no other interactive elements)', async () => {
+                await addActionMenu(column1);
+                await sendKeyPressToTable(keyArrowDown);
+
+                await sendKeyPressToTable(keyEnter);
+
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getCellActionMenu(0, 0)
+                );
+            });
+
+            describe("when a cell's action menu is focused, pressing the given key will focus the cell:", () => {
+                const tests = [
+                    { name: 'Escape', key: keyEscape },
+                    { name: 'F2', key: keyFunction2 }
+                ];
+                parameterizeSpec(tests, (spec, name, value) => {
+                    spec(name, async () => {
+                        await addActionMenu(column1);
+                        await sendKeyPressToTable(keyArrowDown);
+                        await sendKeyPressToTable(keyTab);
+                        expect(currentFocusedElement()).toBe(
+                            pageObject.getCellActionMenu(0, 0)
+                        );
+
+                        await sendKeyPressToTable(value.key);
+
+                        expect(currentFocusedElement()).toBe(
+                            pageObject.getCell(0, 0)
+                        );
+                    });
+                });
+            });
+
+            describe("when a cell's action menu is focused,", () => {
+                beforeEach(async () => {
+                    await addActionMenu(column1);
+                    await sendKeyPressToTable(keyArrowDown);
+                    await sendKeyPressToTable(keyTab);
+                });
+
+                const tests = [
+                    { name: 'UpArrow', key: keyArrowUp },
+                    { name: 'DownArrow', key: keyArrowDown }
+                ];
+                parameterizeSpec(tests, (spec, name, value) => {
+                    spec(
+                        `pressing ${name} will open the action menu, Esc will close the menu, and another Esc press will focus the (same) cell`,
+                        async () => {
+                            const actionMenuButton = pageObject.getCellActionMenu(0, 0)!;
+                            const toggleListener = createEventListener(
+                                element,
+                                'action-menu-toggle'
+                            );
+                            await sendKeyDownEvent(
+                                actionMenuButton.toggleButton!,
+                                value.key
+                            );
+                            await toggleListener.promise;
+
+                            const firstCell = pageObject.getCell(0, 0);
+                            expect(firstCell.menuOpen).toBe(true);
+
+                            const actionMenuItem = element.querySelector(menuItemTag)!;
+
+                            await sendKeyDownEvent(actionMenuItem, keyEscape);
+
+                            expect(firstCell.menuOpen).toBe(false);
+
+                            await sendKeyPressToTable(keyEscape);
+
+                            expect(currentFocusedElement()).toBe(firstCell);
+                        }
+                    );
+                });
+            });
+
+            describe('table focus state is reset back to default on certain table configuration changes:', () => {
+                beforeEach(async () => {
+                    await sendKeyPressesToTable(keyArrowDown, keyArrowRight); // focus cell 0, 1
+                });
+
+                it('adding an action menu to a column', async () => {
+                    await addActionMenu(column1);
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getHeaderElement(0)
+                    );
+                });
+
+                it('hiding a column', async () => {
+                    column1.columnHidden = true;
+                    await waitForUpdatesAsync();
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getHeaderElement(0)
+                    );
+                });
+
+                it('changing selection mode', async () => {
+                    element.selectionMode = TableRowSelectionMode.single;
+                    await waitForUpdatesAsync();
+
+                    expect(currentFocusedElement()).toBe(
+                        pageObject.getHeaderElement(0)
+                    );
+                });
+            });
+        });
+
+        describe('for a large dataset (virtualized) table with cell[0, 0] focused,', () => {
+            beforeEach(async () => {
+                await setupLargeDataTable();
+                element.focus();
+                await waitForUpdatesAsync();
+                await sendKeyPressToTable(keyArrowDown);
+            });
+
+            function getFirstRowVisibleIndex(): number {
+                const visibleIndex = 0;
+                const firstRenderedRow = pageObject.getRow(visibleIndex);
+                if (firstRenderedRow.dataRecord!.id !== '0') {
+                    throw new Error(
+                        'Expected 1st visible row to be the 1st row in the dataset'
+                    );
+                }
+                return visibleIndex;
+            }
+
+            function getLastRowVisibleIndex(): number {
+                const renderedRowCount = pageObject.getRenderedRowCount();
+                const visibleIndex = renderedRowCount - 1;
+                const lastRenderedRow = pageObject.getRow(visibleIndex);
+                if (
+                    lastRenderedRow.dataRecord!.id
+                    !== (largeDataRowCount - 1).toString()
+                ) {
+                    throw new Error(
+                        'Expected last visible row to be the last row in the dataset'
+                    );
+                }
+                return visibleIndex;
+            }
+
+            it('with a row focused, End focuses the last row, and Home focuses the 1st row', async () => {
+                await sendKeyPressToTable(keyArrowLeft);
+
+                await sendKeyPressToTable(keyEnd);
+                await waitForUpdatesAsync();
+                const lastRow = pageObject.getRow(getLastRowVisibleIndex());
+                expect(currentFocusedElement()).toBe(lastRow);
+
+                await sendKeyPressToTable(keyHome);
+                await waitForUpdatesAsync();
+                const firstRow = pageObject.getRow(getFirstRowVisibleIndex());
+                expect(currentFocusedElement()).toBe(firstRow);
+            });
+
+            it('with a cell focused, Ctrl-End focuses the cell (same column) in the last row, and Ctrl-Home focuses the cell (same column) in the 1st row', async () => {
+                await sendKeyPressToTable(keyEnd, { ctrlKey: true });
+                await waitForUpdatesAsync();
+                const cellInLastRow = pageObject.getCell(
+                    getLastRowVisibleIndex(),
+                    0
+                );
+                expect(currentFocusedElement()).toBe(cellInLastRow);
+
+                await sendKeyPressToTable(keyHome, { ctrlKey: true });
+                await waitForUpdatesAsync();
+                const cellInFirstRow = pageObject.getCell(
+                    getFirstRowVisibleIndex(),
+                    0
+                );
+                expect(currentFocusedElement()).toBe(cellInFirstRow);
+            });
+
+            it('with a row focused, PgDown will focus a row one page (table viewport height of rows) down', async () => {
+                await sendKeyPressToTable(keyArrowLeft);
+
+                await sendKeyPressToTable(keyPageDown);
+                await waitForUpdatesAsync();
+                const focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableRow);
+                const newRowIndex = (focusedElement as TableRow)
+                    .resolvedRowIndex!;
+
+                expect(newRowIndex).toBeCloseTo(
+                    element.virtualizer.pageSize,
+                    0
+                );
+            });
+
+            it('with a row focused, PgUp will focus a row one page (table viewport height of rows) up', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowLeft,
+                    keyPageDown,
+                    keyPageDown
+                );
+                let focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableRow);
+                const oldRowIndex = (focusedElement as TableRow)
+                    .resolvedRowIndex!;
+
+                await sendKeyPressToTable(keyPageUp);
+                await waitForUpdatesAsync();
+                focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableRow);
+                const newRowIndex = (focusedElement as TableRow)
+                    .resolvedRowIndex!;
+
+                expect(newRowIndex).toBeCloseTo(
+                    oldRowIndex - element.virtualizer.pageSize,
+                    0
+                );
+            });
+
+            it('with a row focused, if the table is scrolled away from that row, then back to it, it is focused again', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowLeft,
+                    keyArrowDown,
+                    keyArrowDown,
+                    keyArrowDown
+                );
+                let focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableRow);
+                const originalFocusedRowId = (focusedElement as TableRow)
+                    .recordId;
+
+                await pageObject.scrollToLastRowAsync();
+                await pageObject.scrollToFirstRowAsync();
+
+                focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableRow);
+                expect((focusedElement as TableRow).recordId).toBe(
+                    originalFocusedRowId
+                );
+            });
+
+            it('with a cell focused, if the table is scrolled away from that cell, then back to it, it is focused again', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowDown,
+                    keyArrowDown,
+                    keyArrowDown
+                );
+                let focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableCell);
+                const originalFocusedCellId = (focusedElement as TableCell)
+                    .recordId;
+
+                await pageObject.scrollToLastRowAsync();
+                await pageObject.scrollToFirstRowAsync();
+
+                focusedElement = currentFocusedElement();
+                expect(focusedElement).toBeInstanceOf(TableCell);
+                expect((focusedElement as TableCell).recordId).toBe(
+                    originalFocusedCellId
+                );
+            });
+
+            it('if a cell is focused, then the table loses focus, it does not steal focus back on scroll', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowDown,
+                    keyArrowDown,
+                    keyArrowDown
+                );
+
+                currentFocusedElement()!.blur();
+                await pageObject.scrollToLastRowAsync();
+                await pageObject.scrollToFirstRowAsync();
+
+                expect(currentFocusedElement()).toBe(document.body);
+            });
+
+            it('if a cell is focused, then the table loses focus, it does not steal focus back on data updates', async () => {
+                await sendKeyPressesToTable(
+                    keyArrowDown,
+                    keyArrowDown,
+                    keyArrowDown
+                );
+
+                currentFocusedElement()!.blur();
+                const newTableData = createTableData(20);
+                await element.setData(newTableData);
+                await waitForUpdatesAsync();
+
+                expect(currentFocusedElement()).toBe(document.body);
+            });
+        });
+
+        it('for a simple table with no columns sortable, on initial table focus, the 1st row is focused', async () => {
+            await setupBasicTable();
+            column1.sortingDisabled = true;
+            column2.sortingDisabled = true;
+            column3.sortingDisabled = true;
+            await waitForUpdatesAsync();
+            element.focus();
+            await waitForUpdatesAsync();
+
+            const firstRow = pageObject.getRow(0);
+            expect(currentFocusedElement()).toBe(firstRow);
+        });
+
+        describe('for a single-selection table with focus', () => {
+            beforeEach(async () => {
+                await setupBasicTable();
+                element.selectionMode = TableRowSelectionMode.single;
+                await waitForUpdatesAsync();
+                element.focus();
+                await waitForUpdatesAsync();
+            });
+
+            it('when a row is focused, pressing Space will select the row, and pressing it again will deselect the row', async () => {
+                await sendKeyPressesToTable(keyArrowDown, keyArrowLeft);
+
+                const row = pageObject.getRow(0);
+                await sendKeyPressToTable(keySpace);
+
+                expect(row.selected).toBe(true);
+
+                await sendKeyPressToTable(keySpace);
+
+                expect(row.selected).toBe(false);
+            });
+
+            it('when a cell is focused, pressing Shift-Space will select the row, and pressing it again will deselect the row', async () => {
+                await sendKeyPressesToTable(keyArrowDown);
+
+                const row = pageObject.getRow(0);
+                await sendKeyPressToTable(keySpace, { shiftKey: true });
+
+                expect(row.selected).toBe(true);
+
+                await sendKeyPressToTable(keySpace, { shiftKey: true });
+
+                expect(row.selected).toBe(false);
+            });
+        });
+
+        describe('for a multiple-selection table with focus, when a row is focused,', () => {
+            beforeEach(async () => {
+                await setupBasicTable();
+                element.selectionMode = TableRowSelectionMode.multiple;
+                await waitForUpdatesAsync();
+                element.focus();
+                await waitForUpdatesAsync();
+                await sendKeyPressToTable(keyArrowDown);
+            });
+
+            it('pressing Space will select the row', async () => {
+                const row = pageObject.getRow(0);
+                await sendKeyPressToTable(keySpace);
+
+                expect(row.selected).toBe(true);
+            });
+
+            it('pressing RightArrow will focus the row selection checkbox', async () => {
+                await sendKeyPressToTable(keyArrowRight);
+
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getRow(0).selectionCheckbox!
+                );
+            });
+
+            it('pressing DownArrow multiple times when the row selection checkbox is focused will focus the row selection checkbox on subsequent rows', async () => {
+                await sendKeyPressToTable(keyArrowRight);
+
+                await sendKeyPressToTable(keyArrowDown);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getRow(1).selectionCheckbox!
+                );
+
+                await sendKeyPressToTable(keyArrowDown);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getRow(2).selectionCheckbox!
+                );
+
+                await sendKeyPressToTable(keyArrowDown);
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getRow(3).selectionCheckbox!
+                );
+            });
+
+            it('pressing Home when a cell is focused will focus the row selection checkbox', async () => {
+                await sendKeyPressesToTable(keyArrowRight, keyArrowRight);
+
+                await sendKeyPressToTable(keyHome);
+
+                expect(currentFocusedElement()).toBe(
+                    pageObject.getRow(0).selectionCheckbox!
+                );
+            });
+
+            it('pressing End when the row selection checkbox is focused will focus the last cell', async () => {
+                await sendKeyPressesToTable(keyArrowRight);
+
+                await sendKeyPressToTable(keyEnd);
+
+                expect(currentFocusedElement()).toBe(pageObject.getCell(0, 2));
+            });
+        });
+
+        describe('for a table with a grouped column, when a group row is focused,', () => {
+            beforeEach(async () => {
+                await setupTableWithGrouping();
+                element.focus();
+                await waitForUpdatesAsync();
+                await sendKeyPressToTable(keyArrowDown);
+                if (!(currentFocusedElement() instanceof TableGroupRow)) {
+                    throw new Error('Expected group row to be focused');
+                }
+            });
+
+            describe('for an expanded group row, pressing the given key will collapse the group:', () => {
+                const tests = [
+                    { name: 'Space', key: keySpace },
+                    { name: 'Enter', key: keyEnter },
+                    { name: 'LeftArrow', key: keyArrowLeft }
+                ];
+                parameterizeSpec(tests, (spec, name, value) => {
+                    spec(name, async () => {
+                        await sendKeyPressToTable(value.key);
+
+                        const focusedElement = currentFocusedElement();
+                        expect(focusedElement).toBeInstanceOf(TableGroupRow);
+                        expect((focusedElement as TableGroupRow).expanded).toBe(
+                            false
+                        );
+                    });
+                });
+            });
+
+            describe('for a collapsed group row, pressing the given key will expand the group:', () => {
+                const tests = [
+                    { name: 'Space', key: keySpace },
+                    { name: 'Enter', key: keyEnter },
+                    { name: 'RightArrow', key: keyArrowRight }
+                ];
+                parameterizeSpec(tests, (spec, name, value) => {
+                    spec(name, async () => {
+                        pageObject.toggleGroupRowExpandedState(0);
+                        await waitForUpdatesAsync();
+                        let focusedElement = currentFocusedElement();
+                        if (
+                            !(focusedElement instanceof TableGroupRow)
+                            || focusedElement.expanded
+                        ) {
+                            throw new Error(
+                                'Expected focused group row to be collapsed'
+                            );
+                        }
+
+                        await sendKeyPressToTable(value.key);
+
+                        focusedElement = currentFocusedElement();
+                        expect(focusedElement).toBeInstanceOf(TableGroupRow);
+                        expect((focusedElement as TableGroupRow).expanded).toBe(
+                            true
+                        );
+                    });
+                });
+            });
+
+            describe('when multiple selection is enabled', () => {
+                beforeEach(async () => {
+                    element.selectionMode = TableRowSelectionMode.multiple;
+                    await waitForUpdatesAsync();
+                    element.focus();
+                    await waitForUpdatesAsync();
+                    await sendKeyPressToTable(keyArrowDown);
+                    if (!(currentFocusedElement() instanceof TableGroupRow)) {
+                        throw new Error('Expected group row to be focused');
+                    }
+                });
+
+                it('pressing RightArrow on an focused expanded group row will focus the selection checkbox', async () => {
+                    const initialFocusedGroupRow = currentFocusedElement() as TableGroupRow;
+                    await sendKeyPressToTable(keyArrowRight);
+
+                    expect(currentFocusedElement()).toBe(
+                        initialFocusedGroupRow.selectionCheckbox!
+                    );
+                });
+
+                it('pressing LeftArrow on a focused group row selection checkbox will focus the entire group row', async () => {
+                    const initialFocusedGroupRow = currentFocusedElement() as TableGroupRow;
+                    await sendKeyPressToTable(keyArrowRight);
+                    await sendKeyPressToTable(keyArrowLeft);
+
+                    expect(currentFocusedElement()).toBe(
+                        initialFocusedGroupRow
+                    );
+                });
+            });
+
+            it('with no tabbable elements in the group row, pressing Tab will move focus past the table', async () => {
+                const keyEvent = await sendKeyPressToTable(keyTab);
+
+                await verifyLastTabKeyEventBehavior(keyEvent);
+            });
+
+            it('with no tabbable elements in the group row, pressing Shift-Tab will move focus past the table', async () => {
+                const keyEvent = await sendKeyPressToTable(keyTab, {
+                    shiftKey: true
+                });
+
+                await verifyLastTabKeyEventBehavior(keyEvent);
+            });
+        });
+
+        describe('for a table with hierarchy', () => {
+            beforeEach(async () => {
+                const data = [
+                    {
+                        stringData1: 'A0',
+                        stringData2: 'B0',
+                        stringData3: 'C0',
+                        id: '0',
+                        parentId: undefined
+                    },
+                    {
+                        stringData1: 'A1',
+                        stringData2: 'B1',
+                        stringData3: 'C1',
+                        id: '1',
+                        parentId: '0'
+                    }
+                ];
+                element.idFieldName = 'id';
+                element.parentIdFieldName = 'parentId';
+                await element.setData(data);
+                await connect();
+                await waitForUpdatesAsync();
+                element.focus();
+                await waitForUpdatesAsync();
+            });
+
+            it('when a collapsed row is focused, pressing RightArrow will expand the row', async () => {
+                pageObject.clickDataRowExpandCollapseButton(0);
+                await sendKeyPressToTable(keyArrowDown);
+
+                await sendKeyPressToTable(keyArrowRight);
+
+                const row = pageObject.getRow(0);
+                expect(row.expanded).toBe(true);
+            });
+
+            it('when an expanded row is focused, pressing LeftArrow will collapse the row', async () => {
+                await sendKeyPressToTable(keyArrowDown);
+
+                await sendKeyPressToTable(keyArrowLeft);
+
+                const row = pageObject.getRow(0);
+                expect(row.expanded).toBe(false);
+            });
+
+            it('when an expanded row is focused, pressing RightArrow will move to the 1st cell of the row (and the row stays expanded)', async () => {
+                await sendKeyPressToTable(keyArrowDown);
+
+                await sendKeyPressToTable(keyArrowRight);
+
+                expect(currentFocusedElement()).toBe(pageObject.getCell(0, 0));
+                expect(pageObject.getRow(0).expanded).toBe(true);
+            });
+        });
+    });
+
+    describe('with interactive columns', () => {
+        const interactiveCellViewName = uniqueElementName();
+        const interactiveColumnName = uniqueElementName();
+
+        // prettier-ignore
+        @customElement({
+            name: interactiveCellViewName,
+            template: html<TestInteractiveCellView>`<span tabindex="-1" ${ref('spanElement')}>Test</span>`
+        })
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        class TestInteractiveCellView extends TableCellView {
+            @observable
+            public spanElement!: HTMLSpanElement;
+
+            public override get tabbableChildren(): HTMLElement[] {
+                return [this.spanElement];
+            }
+
+            public override focusedRecycleCallback(): void {
+                this.spanElement.blur();
+            }
+        }
+        // prettier-ignore
+        @customElement({
+            name: interactiveColumnName
+        })
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        class TestInteractiveTableColumn extends TableColumn {
+            protected override getColumnInternalsOptions(): ColumnInternalsOptions {
+                return {
+                    cellViewTag: interactiveCellViewName,
+                    cellRecordFieldNames: ['value'],
+                    groupHeaderViewTag: tableColumnEmptyGroupHeaderViewTag,
+                    delegatedEvents: [],
+                    validator: new ColumnValidator<[]>([])
+                };
+            }
+        }
+
+        // prettier-ignore
+        async function setupInteractiveTable(): Promise<Fixture<Table<SimpleTableRecord>>> {
+            return fixture<Table<SimpleTableRecord>>(
+                html`<nimble-table id-field-name="id">
+                <${interactiveColumnName} id="first-column" column-id="column-1"></${interactiveColumnName}>
+                <${interactiveColumnName} id="second-column" column-id="column-2"></${interactiveColumnName}>
+                <${interactiveColumnName} id="third-column" column-id="column-3"></${interactiveColumnName}>
+            </nimble-table>`
+            );
+        }
+
+        function getRenderedCellContent(
+            rowIndex: number,
+            columnIndex: number
+        ): HTMLElement {
+            return (
+                pageObject.getRenderedCellView(
+                    rowIndex,
+                    columnIndex
+                ) as TestInteractiveCellView
+            ).spanElement;
+        }
+
+        beforeEach(async () => {
+            ({ element, connect, disconnect } = await setupInteractiveTable());
+            pageObject = new TablePageObject(element);
+
+            const tableData = [
+                {
+                    id: '1',
+                    value: 'a1'
+                },
+                {
+                    id: '2',
+                    value: 'a2'
+                },
+                {
+                    id: '3',
+                    value: 'a3'
+                },
+                {
+                    id: '4',
+                    value: 'a4'
+                }
+            ] as SimpleTableRecord[];
+            await element.setData(tableData);
+            const column2 = element.querySelector<TableColumn>('#second-column')!;
+            await addActionMenu(column2);
+            await connect();
+            await waitForUpdatesAsync();
+            element.focus();
+            await waitForUpdatesAsync();
+        });
+
+        afterEach(async () => {
+            await disconnect();
+        });
+
+        it('with the first row focused, clicking interactive cell content in another row will focus that content, and an Esc key press will refocus the cell', async () => {
+            await sendKeyPressesToTable(keyArrowDown, keyArrowLeft); // focus row
+
+            const row2CellContent = getRenderedCellContent(1, 0);
+            await clickAndSendFocusEvents(row2CellContent);
+
+            expect(currentFocusedElement()).toBe(row2CellContent);
+
+            await sendKeyPressToTable(keyEscape);
+
+            expect(currentFocusedElement()).toBe(pageObject.getCell(1, 0));
+        });
+
+        describe('and cell[0, 1] focused,', () => {
+            beforeEach(async () => {
+                await sendKeyPressesToTable(keyArrowDown, keyArrowRight);
+            });
+
+            it('each Tab press will focus each of the remaining tabbable elements in the row (to the right), then will move focus past the table', async () => {
+                const expectedFocusedElements = [
+                    getRenderedCellContent(0, 1),
+                    pageObject.getCellActionMenu(0, 1)!,
+                    getRenderedCellContent(0, 2)
+                ];
+                for (const expectedElement of expectedFocusedElements) {
+                    const tabEvent = await sendKeyPressToTable(keyTab);
+                    expect(currentFocusedElement()).toBe(expectedElement);
+                    expect(tabEvent.defaultPrevented).toBe(true);
+                }
+                const lastTabEvent = await sendKeyPressToTable(keyTab);
+                await verifyLastTabKeyEventBehavior(lastTabEvent);
+            });
+
+            it('each Shift-Tab press will focus each of the remaining tabbable elements in the row (to the left), then will move focus past the table', async () => {
+                const expectedFocusedElements = [
+                    pageObject.getCellActionMenu(0, 1)!,
+                    getRenderedCellContent(0, 1),
+                    getRenderedCellContent(0, 0)
+                ];
+                for (const expectedElement of expectedFocusedElements) {
+                    const tabEvent = await sendKeyPressToTable(keyTab, {
+                        shiftKey: true
+                    });
+                    expect(currentFocusedElement()).toBe(expectedElement);
+                    expect(tabEvent.defaultPrevented).toBe(true);
+                }
+                const lastTabEvent = await sendKeyPressToTable(keyTab, {
+                    shiftKey: true
+                });
+                await verifyLastTabKeyEventBehavior(lastTabEvent);
+            });
+
+            describe('pressing the given key will focus the interactive cell content in the current cell:', () => {
+                const keyTests = [
+                    { name: 'Enter', key: keyEnter },
+                    { name: 'F2', key: keyFunction2 }
+                ];
+                parameterizeSpec(
+                    keyTests,
+                    (keyTestSpec, keyTestName, keyTestValue) => {
+                        keyTestSpec(keyTestName, async () => {
+                            await sendKeyPressToTable(keyTestValue.key);
+
+                            const cellContent = getRenderedCellContent(0, 1);
+                            expect(currentFocusedElement()).toBe(cellContent);
+                        });
+                    }
+                );
+            });
+
+            describe('when the interactive content in the cell is focused, pressing the given key will focus the cell:', () => {
+                const keyTests = [
+                    { name: 'Escape', key: keyEscape },
+                    { name: 'F2', key: keyFunction2 }
+                ];
+                parameterizeSpec(
+                    keyTests,
+                    (keyTestSpec, keyTestName, keyTestValue) => {
+                        keyTestSpec(keyTestName, async () => {
+                            await sendKeyPressToTable(keyEnter);
+
+                            await sendKeyPressToTable(keyTestValue.key);
+
+                            expect(currentFocusedElement()).toBe(
+                                pageObject.getCell(0, 1)
+                            );
+                        });
+                    }
+                );
+            });
+
+            it('when the interactive content in the cell is focused, and a data update happens, the matching cell will be focused afterwards', async () => {
+                await sendKeyPressToTable(keyEnter);
+
+                const tableData: SimpleTableRecord[] = [];
+                for (let i = 0; i < 20; i++) {
+                    tableData.push({
+                        id: i.toString(),
+                        value: `a${i}`
+                    });
+                }
+                await element.setData(tableData);
+                await waitForUpdatesAsync();
+
+                expect(currentFocusedElement()).toBe(pageObject.getCell(0, 1));
+            });
+        });
+    });
+});
diff --git a/packages/nimble-components/src/table/tests/table.spec.ts b/packages/nimble-components/src/table/tests/table.spec.ts
index fbd7f6e63e..f03fdb0eca 100644
--- a/packages/nimble-components/src/table/tests/table.spec.ts
+++ b/packages/nimble-components/src/table/tests/table.spec.ts
@@ -642,6 +642,10 @@ describe('Table', () => {
             })
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             class TestFocusableCellView extends TableColumnTextCellView {
+                public override get tabbableChildren(): HTMLElement[] {
+                    return [this.shadowRoot!.firstElementChild as HTMLElement];
+                }
+
                 public override focusedRecycleCallback(): void {
                     (this.shadowRoot!.firstElementChild as HTMLElement).blur();
                 }
diff --git a/packages/nimble-components/src/table/tests/types.spec.ts b/packages/nimble-components/src/table/tests/types.spec.ts
index e096eee548..be22def2eb 100644
--- a/packages/nimble-components/src/table/tests/types.spec.ts
+++ b/packages/nimble-components/src/table/tests/types.spec.ts
@@ -29,4 +29,10 @@ describe('Table type', () => {
         const delayedHierarchyState: TableRecordDelayedHierarchyState = 'hello';
         expect(delayedHierarchyState!).toEqual('hello');
     });
+
+    it('TableFocusType fails compile if assigning arbitrary string values', () => {
+        // @ts-expect-error This expect will fail if the enum-like type is missing "as const"
+        const focusType: TableFocusType = 'hello';
+        expect(focusType).toEqual('hello');
+    });
 });
diff --git a/packages/nimble-components/src/table/types.ts b/packages/nimble-components/src/table/types.ts
index c048ff0f7d..cc102a4205 100644
--- a/packages/nimble-components/src/table/types.ts
+++ b/packages/nimble-components/src/table/types.ts
@@ -1,5 +1,8 @@
+import type { Checkbox } from '../checkbox';
+import type { MenuButton } from '../menu-button';
 import type { TableColumn } from '../table-column/base';
 import type { ValidityObject } from '../utilities/models/validator';
+import type { TableCell } from './components/cell';
 
 /**
  * TableFieldName describes the type associated with keys within
@@ -211,4 +214,43 @@ export interface TableRowState<TData extends TableRecord = TableRecord> {
     groupColumn?: TableColumn;
     isParentRow: boolean;
     isLoadingChildren: boolean;
+    resolvedRowIndex?: number;
+}
+
+/**
+ * @internal
+ * Table keyboard focus types
+ */
+export const TableFocusType = {
+    none: 'none',
+    columnHeader: 'columnHeader',
+    headerActions: 'headerActions',
+    row: 'row',
+    rowSelectionCheckbox: 'rowSelectionCheckbox',
+    cell: 'cell',
+    cellActionMenu: 'cellActionMenu',
+    cellContent: 'cellContent'
+} as const;
+export type TableFocusType =
+    (typeof TableFocusType)[keyof typeof TableFocusType];
+
+/**
+ * @internal
+ * Focusable elements of a table row
+ */
+export interface TableRowFocusableElements {
+    selectionCheckbox?: Checkbox;
+    cells: {
+        cell: TableCell,
+        actionMenuButton?: MenuButton
+    }[];
+}
+
+/**
+ * @internal
+ * Focusable elements of a table's header
+ */
+export interface TableHeaderFocusableElements {
+    headerActions: HTMLElement[];
+    columnHeaders: HTMLElement[];
 }
diff --git a/packages/nimble-components/src/utilities/tests/component.ts b/packages/nimble-components/src/utilities/tests/component.ts
index c6ddf003df..46d99b5d9a 100644
--- a/packages/nimble-components/src/utilities/tests/component.ts
+++ b/packages/nimble-components/src/utilities/tests/component.ts
@@ -5,6 +5,22 @@ export async function clickElement(element: HTMLElement): Promise<void> {
     await waitForUpdatesAsync();
 }
 
+export async function sendKeyDownEvent(
+    target: HTMLElement,
+    key: string,
+    init?: KeyboardEventInit
+): Promise<KeyboardEvent> {
+    const event = new KeyboardEvent('keydown', {
+        key,
+        cancelable: true,
+        bubbles: true,
+        ...init
+    });
+    target.dispatchEvent(event);
+    await waitForUpdatesAsync();
+    return event;
+}
+
 /** A helper function to abstract turning waiting for an event to fire into a promise.
  * The returned promise should be resolved prior to completing a test.
  */
diff --git a/packages/storybook/src/nimble/table/table-matrix.stories.ts b/packages/storybook/src/nimble/table/table-matrix.stories.ts
index 78dc3a7157..48594b5113 100644
--- a/packages/storybook/src/nimble/table/table-matrix.stories.ts
+++ b/packages/storybook/src/nimble/table/table-matrix.stories.ts
@@ -12,7 +12,9 @@ import { createStory } from '../../utilities/storybook';
 import {
     createMatrixThemeStory,
     createMatrix,
-    sharedMatrixParameters
+    sharedMatrixParameters,
+    cartesianProduct,
+    createMatrixInteractionsFromStates
 } from '../../utilities/matrix';
 import { hiddenWrapper } from '../../utilities/hidden';
 import { isChromatic } from '../../utilities/isChromatic';
@@ -149,15 +151,40 @@ export const tableNoSelectionThemeMatrix: StoryFn = createMatrixThemeStory(
 tableNoSelectionThemeMatrix.play = playFunction;
 
 export const tableSingleSelectionThemeMatrix: StoryFn = createMatrixThemeStory(
-    createMatrix(component, [['single'], groupedStates, hierarchyStates])
+    createMatrix(component, [
+        [TableRowSelectionMode.single],
+        groupedStates,
+        hierarchyStates
+    ])
 );
 tableSingleSelectionThemeMatrix.play = playFunction;
 
 export const tableMultipleSelectionThemeMatrix: StoryFn = createMatrixThemeStory(
-    createMatrix(component, [['multiple'], groupedStates, hierarchyStates])
+    createMatrix(component, [
+        [TableRowSelectionMode.multiple],
+        groupedStates,
+        hierarchyStates
+    ])
 );
 tableMultipleSelectionThemeMatrix.play = playFunction;
 
+const groupedStatesGroupingEnabled = groupedStates[0];
+const hierarchyStatesHierarchyEnabled = hierarchyStates[0];
+const tableKeyboardFocusStates = cartesianProduct([
+    [TableRowSelectionMode.multiple],
+    [groupedStatesGroupingEnabled],
+    [hierarchyStatesHierarchyEnabled]
+] as const);
+export const tableKeyboardFocusThemeMatrix: StoryFn = createMatrixThemeStory(
+    createMatrixInteractionsFromStates(component, {
+        hover: [],
+        hoverActive: [],
+        active: [],
+        focus: tableKeyboardFocusStates
+    })
+);
+tableKeyboardFocusThemeMatrix.play = playFunction;
+
 export const hiddenTable: StoryFn = createStory(
     hiddenWrapper(html`<${tableTag} hidden></${tableTag}>`)
 );
diff --git a/packages/storybook/src/nimble/table/table.mdx b/packages/storybook/src/nimble/table/table.mdx
index b1df91a523..3124850437 100644
--- a/packages/storybook/src/nimble/table/table.mdx
+++ b/packages/storybook/src/nimble/table/table.mdx
@@ -97,6 +97,71 @@ The expected usage of the dynamically loaded hierarchy is as follows:
 -   calling `setData` will clear options associated with IDs that are no longer
     present in the data
 
-{/* ## Accessibility */}
+## Accessibility
+
+### Keyboard navigation
+
+Once the table is focused, it supports navigation via keyboard keys.
+
+-   If the table is focused via `Tab`/`Shift-Tab`: focus starts on the first
+    action button in the header row (if any), the first column header (if any
+    columns are sortable), or the first row of data.
+-   If the table is focused via mouse-click on a row, keyboard navigation will
+    start from that row once a navigation key is pressed afterwards.
+
+Column sorting:
+
+-   If a column header is focused, `Enter` will toggle its sort mode between
+    ascending, descending, and no sorting.
+-   `Shift-Enter` will do the same but will maintain other columns as sorted if
+    they were already.
+
+Navigating the table:
+
+-   `UpArrow`, `DownArrow`, `LeftArrow`, `RightArrow` will navigate amongst the
+    table column headers, rows, and cells.
+-   When a row is focused:
+    -   If the row is expandable, `RightArrow` and `LeftArrow` will
+        expand/collapse the row.
+    -   If the row cannot be expanded (or is already expanded), a `RightArrow`
+        press will focus the first cell.
+    -   `Home` and `End` will focus the first and last rows in the dataset,
+        respectively.
+-   When a cell is focused:
+    -   If the leftmost cell of a row is focused, another `LeftArrow` press will
+        focus the entire row.
+    -   `Home` and `End` will focus the first and last cells of the row,
+        respectively.
+    -   `Ctrl-Home` and `Ctrl-End` will focus the cell in the same column of the
+        first and last rows of the dataset.
+-   `PgUp` and `PgDown` will navigate up or down by one page's worth of rows.
+    -   If a cell was focused, the cell in the same column in the new row will
+        be focused.
+    -   If a row was focused, the new row will be focused afterwards.
+
+Interacting with cell contents:
+
+-   When a cell is focused:
+    -   `Enter` or `F2` will focus the first interactive element inside a cell,
+        if there is one (such as an anchor).
+    -   `Ctrl-Enter` will open the cell's action menu, if it has one.
+-   When an action menu or element inside a cell has focus:
+    -   Arrow key presses will no longer navigate between rows/cells.
+    -   Pressing `Esc` or `F2` will return to row/cell navigation mode.
+
+Row selection and grouping:
+
+-   If a row is focused, `Space` will select the row.
+-   If a row or cell is focused, `Shift-Space` will select the row. (Note, in
+    multiple selection mode, this may result in ranges of rows being selected.)
+-   If a group header row is focused, `Space` will expand/collapse the group. To
+    select the group, navigate to the selection checkbox with `LeftArrow` and
+    `RightArrow`, and toggle it with `Space`.
+
+`Tab` and `Shift-Tab` can be used to navigate between the interactive elements
+in the current row or header, such as buttons or anchors. Once those elements in
+the current row have been traversed, `Tab`/`Shift-Tab` will move focus outside
+the table. When the table is focused again, navigation will resume from the
+previously focused element.
 
 {/* ## Resources */}
diff --git a/packages/storybook/src/utilities/matrix.ts b/packages/storybook/src/utilities/matrix.ts
index a5c4af090e..8471bbef07 100644
--- a/packages/storybook/src/utilities/matrix.ts
+++ b/packages/storybook/src/utilities/matrix.ts
@@ -1,4 +1,4 @@
-import { html, repeat, ViewTemplate } from '@microsoft/fast-element';
+import { html, repeat, ViewTemplate, when } from '@microsoft/fast-element';
 import { themeProviderTag } from '../../../nimble-components/src/theme-provider';
 import {
     bodyFont,
@@ -134,22 +134,30 @@ export function createMatrixInteractionsFromStates<
         font: var(${bodyFont.cssCustomProperty});
         color: var(${bodyFontColor.cssCustomProperty});
     ">
-        <div class="pseudo-hover-all">
-            <p>Hover</p>
-            ${createMatrixFromStates(component, states.hover)}
-        </div>
-        <div class="pseudo-hover-all pseudo-active-all">
-            <p>Hover and active</p>
-            ${createMatrixFromStates(component, states.hoverActive)}
-        </div>
-        <div class="pseudo-active-all">
-            <p>Active</p>
-            ${createMatrixFromStates(component, states.active)}
-        </div>
-        <div class="pseudo-focus-visible-all pseudo-focus-within-all">
-            <p>Focus</p>
-            ${createMatrixFromStates(component, states.focus)}
-        </div>
+        ${when(() => states.hover.length > 0, html`
+            <div class="pseudo-hover-all">
+                <p>Hover</p>
+                ${createMatrixFromStates(component, states.hover)}
+            </div>
+        `)}
+        ${when(() => states.hoverActive.length > 0, html`
+            <div class="pseudo-hover-all pseudo-active-all">
+                <p>Hover and active</p>
+                ${createMatrixFromStates(component, states.hoverActive)}
+            </div>
+        `)}
+        ${when(() => states.active.length > 0, html`
+            <div class="pseudo-active-all">
+                <p>Active</p>
+                ${createMatrixFromStates(component, states.active)}
+            </div>
+        `)}
+        ${when(() => states.focus.length > 0, html`
+            <div class="pseudo-focus-visible-all pseudo-focus-within-all">
+                <p>Focus</p>
+                ${createMatrixFromStates(component, states.focus)}
+            </div>
+        `)}
     </div>
 `;
 }