diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index f2d66c6656c65..ee92b516d996e 100644
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -245,6 +245,8 @@ const CONST = {
     POPOVER_DROPDOWN_WIDTH: 334,
     POPOVER_DROPDOWN_MIN_HEIGHT: 0,
     POPOVER_DROPDOWN_MAX_HEIGHT: 416,
+    POPOVER_CATEGORY_PICKER_WIDTH: 350,
+    POPOVER_CATEGORY_PICKER_MAX_HEIGHT: 450,
     POPOVER_MENU_MAX_HEIGHT: 496,
     POPOVER_MENU_MAX_HEIGHT_MOBILE: 432,
     POPOVER_DATE_WIDTH: 338,
@@ -7501,6 +7503,7 @@ const CONST = {
                 COMPLETED: 'completed',
             },
         },
+        INLINE_EDITABLE_EXPENSE_STATUSES: new Set<string>(['', 'unreported', 'drafts', 'outstanding']),
         GROUP_COLUMN_PREFIX: 'group',
         TABLE_COLUMNS: {
             RECEIPT: 'receipt',
@@ -8569,6 +8572,9 @@ const CONST = {
             GROUP_SELECT_ALL_CHECKBOX: 'Search-GroupSelectAllCheckbox',
             SORTABLE_HEADER: 'Search-SortableHeader',
         },
+        TABLE: {
+            EDITABLE_CELL: 'Table-EditableCell',
+        },
         REPORT: {
             FLOATING_MESSAGE_COUNTER: 'Report-FloatingMessageCounter',
             LIST_BOUNDARY_LOADER_RETRY: 'Report-ListBoundaryLoaderRetry',
diff --git a/src/components/CategoryPicker/CategoryPickerModal.tsx b/src/components/CategoryPicker/CategoryPickerModal.tsx
new file mode 100644
index 0000000000000..7545562acbb39
--- /dev/null
+++ b/src/components/CategoryPicker/CategoryPickerModal.tsx
@@ -0,0 +1,104 @@
+import React, {useRef, useState} from 'react';
+import {View} from 'react-native';
+import ConfirmCancelButtonRow from '@components/ConfirmCancelButtonRow';
+import PopoverWithMeasuredContent from '@components/PopoverWithMeasuredContent';
+import type PopoverWithMeasuredContentProps from '@components/PopoverWithMeasuredContent/types';
+import type {ListItem} from '@components/SelectionList/types';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useStyleUtils from '@hooks/useStyleUtils';
+import useThemeStyles from '@hooks/useThemeStyles';
+import CONST from '@src/CONST';
+import CategoryPicker from '.';
+
+const DEFAULT_ANCHOR_ALIGNMENT = {
+    horizontal: CONST.MODAL.ANCHOR_ORIGIN_HORIZONTAL.LEFT,
+    vertical: CONST.MODAL.ANCHOR_ORIGIN_VERTICAL.TOP,
+};
+
+const popoverDimensions = {
+    width: CONST.POPOVER_DROPDOWN_WIDTH,
+    height: CONST.POPOVER_DROPDOWN_MAX_HEIGHT,
+};
+
+type CategoryPickerModalProps = {
+    /** Callback to close the modal */
+    onClose: () => void;
+
+    /** The policy whose categories should be shown */
+    policyID: string | undefined;
+
+    /** Currently selected category */
+    selectedCategory?: string;
+
+    /** Called when the user confirms a category selection */
+    onSelected?: (item: ListItem) => void;
+} & Omit<PopoverWithMeasuredContentProps, 'anchorRef' | 'children' | 'onClose'>;
+
+function CategoryPickerModal({
+    isVisible,
+    onClose,
+    anchorPosition,
+    policyID,
+    selectedCategory,
+    onSelected,
+    anchorAlignment = DEFAULT_ANCHOR_ALIGNMENT,
+    shouldMeasureAnchorPositionFromTop = false,
+}: CategoryPickerModalProps) {
+    const styles = useThemeStyles();
+    const StyleUtils = useStyleUtils();
+
+    // We need to use isSmallScreenWidth instead of shouldUseNarrowLayout to distinguish RHL and narrow layout
+    // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
+    const {isSmallScreenWidth} = useResponsiveLayout();
+    const anchorRef = useRef<View>(null);
+
+    const [pendingItem, setPendingItem] = useState<ListItem | undefined>(undefined);
+
+    const handleConfirm = () => {
+        if (pendingItem) {
+            onSelected?.(pendingItem);
+        }
+        setPendingItem(undefined);
+        onClose();
+    };
+
+    const handleCancel = () => {
+        setPendingItem(undefined);
+        onClose();
+    };
+
+    return (
+        <PopoverWithMeasuredContent
+            anchorRef={anchorRef}
+            isVisible={isVisible}
+            onClose={handleCancel}
+            anchorPosition={anchorPosition}
+            popoverDimensions={popoverDimensions}
+            anchorAlignment={anchorAlignment}
+            innerContainerStyle={isSmallScreenWidth ? styles.w100 : {width: CONST.POPOVER_DROPDOWN_WIDTH}}
+            restoreFocusType={CONST.MODAL.RESTORE_FOCUS_TYPE.DELETE}
+            shouldSwitchPositionIfOverflow
+            shouldEnableNewFocusManagement
+            shouldMeasureAnchorPositionFromTop={shouldMeasureAnchorPositionFromTop}
+            shouldSkipRemeasurement
+            shouldDisplayBelowModals
+        >
+            <View style={[StyleUtils.getHeight(CONST.POPOVER_DROPDOWN_MAX_HEIGHT), styles.flexColumn, styles.pt4]}>
+                <View style={styles.flex1}>
+                    <CategoryPicker
+                        policyID={policyID}
+                        selectedCategory={pendingItem?.keyForList ?? selectedCategory}
+                        onSubmit={setPendingItem}
+                    />
+                </View>
+                <ConfirmCancelButtonRow
+                    onConfirm={handleConfirm}
+                    onCancel={handleCancel}
+                    isConfirmDisabled={!pendingItem}
+                />
+            </View>
+        </PopoverWithMeasuredContent>
+    );
+}
+
+export default CategoryPickerModal;
diff --git a/src/components/CategoryPicker.tsx b/src/components/CategoryPicker/index.tsx
similarity index 93%
rename from src/components/CategoryPicker.tsx
rename to src/components/CategoryPicker/index.tsx
index 57101183022e2..45c219f3cac18 100644
--- a/src/components/CategoryPicker.tsx
+++ b/src/components/CategoryPicker/index.tsx
@@ -1,4 +1,7 @@
 import React from 'react';
+import RadioListItem from '@components/SelectionList/ListItem/RadioListItem';
+import SelectionListWithSections from '@components/SelectionList/SelectionListWithSections';
+import type {ListItem} from '@components/SelectionList/types';
 import useDebouncedState from '@hooks/useDebouncedState';
 import useLocalize from '@hooks/useLocalize';
 import useNetwork from '@hooks/useNetwork';
@@ -11,9 +14,6 @@ import {getHeaderMessageForNonUserList} from '@libs/OptionsListUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
-import RadioListItem from './SelectionList/ListItem/RadioListItem';
-import SelectionListWithSections from './SelectionList/SelectionListWithSections';
-import type {ListItem} from './SelectionList/types';
 
 type CategoryPickerProps = {
     policyID: string | undefined;
diff --git a/src/components/ConfirmCancelButtonRow.tsx b/src/components/ConfirmCancelButtonRow.tsx
new file mode 100644
index 0000000000000..695d7f4946c80
--- /dev/null
+++ b/src/components/ConfirmCancelButtonRow.tsx
@@ -0,0 +1,40 @@
+import React from 'react';
+import {View} from 'react-native';
+import useLocalize from '@hooks/useLocalize';
+import useThemeStyles from '@hooks/useThemeStyles';
+import Button from './Button';
+
+type ConfirmCancelButtonRowProps = {
+    /** Called when the user presses Apply */
+    onConfirm: () => void;
+
+    /** Called when the user presses Cancel */
+    onCancel: () => void;
+
+    /** Whether the Apply button is disabled */
+    isConfirmDisabled?: boolean;
+};
+
+function ConfirmCancelButtonRow({onConfirm, onCancel, isConfirmDisabled = false}: ConfirmCancelButtonRowProps) {
+    const styles = useThemeStyles();
+    const {translate} = useLocalize();
+
+    return (
+        <View style={[styles.flexRow, styles.gap2, styles.ph4, styles.pb4]}>
+            <Button
+                style={[styles.flex1]}
+                text={translate('common.cancel')}
+                onPress={onCancel}
+            />
+            <Button
+                style={[styles.flex1]}
+                success
+                text={translate('common.apply')}
+                onPress={onConfirm}
+                isDisabled={isConfirmDisabled}
+            />
+        </View>
+    );
+}
+
+export default ConfirmCancelButtonRow;
diff --git a/src/components/DatePicker/DatePickerModal.tsx b/src/components/DatePicker/DatePickerModal.tsx
index 88f71d53cabf2..ed77ce203ee0e 100644
--- a/src/components/DatePicker/DatePickerModal.tsx
+++ b/src/components/DatePicker/DatePickerModal.tsx
@@ -1,6 +1,7 @@
 import {setYear} from 'date-fns';
 import React, {useEffect, useRef, useState} from 'react';
 import type {View} from 'react-native';
+import ConfirmCancelButtonRow from '@components/ConfirmCancelButtonRow';
 import PopoverWithMeasuredContent from '@components/PopoverWithMeasuredContent';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useThemeStyles from '@hooks/useThemeStyles';
@@ -31,10 +32,12 @@ function DatePickerModal({
     isVisible,
     onClose,
     anchorPosition,
+    anchorAlignment = DEFAULT_ANCHOR_ORIGIN,
     onSelected,
     shouldCloseWhenBrowserNavigationChanged = false,
     shouldPositionFromTop = false,
     forwardedFSClass,
+    shouldShowConfirmButtons = false,
 }: DatePickerProps) {
     const [selectedDate, setSelectedDate] = useState(value ?? defaultValue ?? undefined);
     const anchorRef = useRef<View>(null);
@@ -45,19 +48,39 @@ function DatePickerModal({
     const {isSmallScreenWidth} = useResponsiveLayout();
 
     useEffect(() => {
+        // In confirm mode, selectedDate is a pending selection and should not be synced with value until the user confirms
+        if (shouldShowConfirmButtons) {
+            return;
+        }
         if (shouldSaveDraft && formID) {
             setDraftValues(formID, {[inputID]: selectedDate});
         }
         if (selectedDate !== value) {
             setSelectedDate(value);
         }
-    }, [formID, inputID, selectedDate, shouldSaveDraft, value]);
+    }, [formID, inputID, selectedDate, shouldSaveDraft, shouldShowConfirmButtons, value]);
 
-    const handleDateSelection = (newValue: string) => {
-        onSelected?.(newValue);
+    const commitDate = (date: string) => {
+        onSelected?.(date);
         onTouched?.();
-        onInputChange?.(newValue);
+        onInputChange?.(date);
+        if (shouldSaveDraft && formID) {
+            setDraftValues(formID, {[inputID]: date});
+        }
+    };
+
+    const handleDateSelection = (newValue: string) => {
         setSelectedDate(newValue);
+        if (!shouldShowConfirmButtons) {
+            commitDate(newValue);
+        }
+    };
+
+    const handleConfirm = () => {
+        if (selectedDate) {
+            commitDate(selectedDate);
+        }
+        onClose();
     };
 
     return (
@@ -69,7 +92,7 @@ function DatePickerModal({
             popoverDimensions={popoverDimensions}
             shouldCloseWhenBrowserNavigationChanged={shouldCloseWhenBrowserNavigationChanged}
             innerContainerStyle={isSmallScreenWidth ? styles.w100 : {width: CONST.POPOVER_DATE_WIDTH}}
-            anchorAlignment={DEFAULT_ANCHOR_ORIGIN}
+            anchorAlignment={anchorAlignment}
             restoreFocusType={CONST.MODAL.RESTORE_FOCUS_TYPE.DELETE}
             shouldSwitchPositionIfOverflow
             shouldEnableNewFocusManagement
@@ -84,6 +107,13 @@ function DatePickerModal({
                 value={selectedDate}
                 onSelected={handleDateSelection}
             />
+            {shouldShowConfirmButtons && (
+                <ConfirmCancelButtonRow
+                    onConfirm={handleConfirm}
+                    onCancel={onClose}
+                    isConfirmDisabled={!selectedDate}
+                />
+            )}
         </PopoverWithMeasuredContent>
     );
 }
diff --git a/src/components/DatePicker/types.ts b/src/components/DatePicker/types.ts
index dceffd7f6c1e6..0670b955b9f0b 100644
--- a/src/components/DatePicker/types.ts
+++ b/src/components/DatePicker/types.ts
@@ -103,6 +103,9 @@ type DatePickerProps = {
 
     /** If the popover will be positioned from the top */
     shouldPositionFromTop?: boolean;
+
+    /** When true, shows Cancel/Confirm buttons instead of immediately firing onSelected on date pick */
+    shouldShowConfirmButtons?: boolean;
 } & Omit<BaseTextInputProps & PopoverWithMeasuredContentProps, 'anchorRef' | 'children'>;
 
 export type {DatePickerBaseProps, DatePickerModalProps, DateInputWithPickerProps, DatePickerProps};
diff --git a/src/components/MoneyRequestAmountInput.tsx b/src/components/MoneyRequestAmountInput.tsx
index 7efb56e6b537c..3a1fac69bef4e 100644
--- a/src/components/MoneyRequestAmountInput.tsx
+++ b/src/components/MoneyRequestAmountInput.tsx
@@ -124,12 +124,15 @@ type MoneyRequestAmountInputProps = {
      */
     shouldWrapInputInContainer?: boolean;
 
+    /** Style applied to the outer ScrollView inside NumberWithSymbolForm */
+    scrollViewStyle?: StyleProp<ViewStyle>;
+
     /** Whether the input is disabled or not */
     disabled?: boolean;
 
     /** Reference to the outer element */
     ref?: ForwardedRef<BaseTextInputRef>;
-} & Pick<TextInputWithSymbolProps, 'autoGrowExtraSpace' | 'submitBehavior' | 'shouldUseDefaultLineHeightForPrefix' | 'onFocus' | 'onBlur'>;
+} & Pick<TextInputWithSymbolProps, 'autoGrowExtraSpace' | 'submitBehavior' | 'shouldUseDefaultLineHeightForPrefix' | 'onFocus' | 'onBlur' | 'symbolTextStyle'>;
 
 type Selection = {
     start: number;
@@ -166,6 +169,7 @@ function MoneyRequestAmountInput({
     shouldApplyPaddingToContainer = false,
     shouldUseDefaultLineHeightForPrefix = true,
     shouldWrapInputInContainer = true,
+    scrollViewStyle,
     isNegative = false,
     allowFlippingAmount = false,
     allowNegativeInput = false,
@@ -244,6 +248,7 @@ function MoneyRequestAmountInput({
             currency={currency}
             hideSymbol={hideCurrencySymbol}
             isSymbolPressable={isCurrencyPressable}
+            symbolTextStyle={props.symbolTextStyle}
             shouldShowBigNumberPad={shouldShowBigNumberPad}
             style={inputStyle}
             autoGrow={autoGrow}
@@ -253,6 +258,7 @@ function MoneyRequestAmountInput({
             shouldApplyPaddingToContainer={shouldApplyPaddingToContainer}
             shouldUseDefaultLineHeightForPrefix={shouldUseDefaultLineHeightForPrefix}
             shouldWrapInputInContainer={shouldWrapInputInContainer}
+            scrollViewStyle={scrollViewStyle}
             containerStyle={props.containerStyle}
             prefixStyle={props.prefixStyle}
             prefixContainerStyle={props.prefixContainerStyle}
diff --git a/src/components/MoneyRequestReportView/MoneyRequestReportTransactionItem.tsx b/src/components/MoneyRequestReportView/MoneyRequestReportTransactionItem.tsx
index a789adcbf7c39..49e7bf8870290 100644
--- a/src/components/MoneyRequestReportView/MoneyRequestReportTransactionItem.tsx
+++ b/src/components/MoneyRequestReportView/MoneyRequestReportTransactionItem.tsx
@@ -5,6 +5,7 @@ import {getButtonRole} from '@components/Button/utils';
 import OfflineWithFeedback from '@components/OfflineWithFeedback';
 import {PressableWithFeedback} from '@components/Pressable';
 import type {SearchColumnType, TableColumnSize} from '@components/Search/types';
+import {getIsEditingCell} from '@components/Table/EditableCell';
 import TransactionItemRow from '@components/TransactionItemRow';
 import useAnimatedHighlightStyle from '@hooks/useAnimatedHighlightStyle';
 import useLocalize from '@hooks/useLocalize';
@@ -12,6 +13,7 @@ import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useResponsiveLayoutOnWideRHP from '@hooks/useResponsiveLayoutOnWideRHP';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
+import useTransactionInlineEdit from '@hooks/useTransactionInlineEdit';
 import useTransactionViolations from '@hooks/useTransactionViolations';
 import ControlSelection from '@libs/ControlSelection';
 import canUseTouchScreen from '@libs/DeviceCapabilities/canUseTouchScreen';
@@ -96,6 +98,22 @@ function MoneyRequestReportTransactionItem({
     // Filter violations based on user visibility and dismissal state at the row level.
     const filteredViolations = useTransactionViolations(transaction.transactionID);
 
+    const {
+        canEditDate,
+        canEditMerchant,
+        canEditDescription,
+        canEditCategory,
+        canEditAmount,
+        canEditTag,
+        onEditDate,
+        onEditMerchant,
+        onEditDescription,
+        onEditCategory,
+        onEditAmount,
+        onEditTag,
+        wasEditingOnMouseDownRef,
+    } = useTransactionInlineEdit({transactionID: transaction.transactionID, reportID: transaction.reportID});
+
     const viewRef = useRef<View>(null);
 
     // This useEffect scrolls to this transaction when it is newly added to the report
@@ -120,6 +138,12 @@ function MoneyRequestReportTransactionItem({
             <PressableWithFeedback
                 key={transaction.transactionID}
                 onPress={() => {
+                    // If a cell was being edited when the user tapped the row, suppress navigation
+                    // so the second tap doesn't immediately open the transaction detail.
+                    if (wasEditingOnMouseDownRef.current) {
+                        wasEditingOnMouseDownRef.current = false;
+                        return;
+                    }
                     handleOnPress(transaction.transactionID);
                 }}
                 accessibilityLabel={translate('iou.viewDetails')}
@@ -130,7 +154,12 @@ function MoneyRequestReportTransactionItem({
                 style={[styles.transactionListItemStyle]}
                 hoverStyle={[!isPendingDelete && styles.hoveredComponentBG, isSelected && styles.activeComponentBG]}
                 dataSet={{[CONST.SELECTION_SCRAPER_HIDDEN_ELEMENT]: true}}
-                onPressIn={() => canUseTouchScreen() && ControlSelection.block()}
+                onPressIn={() => {
+                    wasEditingOnMouseDownRef.current = getIsEditingCell();
+                    if (canUseTouchScreen()) {
+                        ControlSelection.block();
+                    }
+                }}
                 onPressOut={() => ControlSelection.unblock()}
                 onLongPress={() => {
                     handleLongPress(transaction.transactionID);
@@ -161,6 +190,18 @@ function MoneyRequestReportTransactionItem({
                         }}
                         onArrowRightPress={() => onArrowRightPress?.(transaction.transactionID)}
                         isHover={hovered}
+                        canEditDate={canEditDate}
+                        canEditMerchant={canEditMerchant}
+                        canEditDescription={canEditDescription}
+                        canEditCategory={canEditCategory}
+                        canEditAmount={canEditAmount}
+                        canEditTag={canEditTag}
+                        onEditDate={onEditDate}
+                        onEditMerchant={onEditMerchant}
+                        onEditDescription={onEditDescription}
+                        onEditCategory={onEditCategory}
+                        onEditAmount={onEditAmount}
+                        onEditTag={onEditTag}
                     />
                 )}
             </PressableWithFeedback>
diff --git a/src/components/NumberWithSymbolForm.tsx b/src/components/NumberWithSymbolForm.tsx
index 0a49cb53c766f..f3703ec7502ae 100644
--- a/src/components/NumberWithSymbolForm.tsx
+++ b/src/components/NumberWithSymbolForm.tsx
@@ -1,7 +1,7 @@
 import {useIsFocused} from '@react-navigation/native';
 import type {ForwardedRef} from 'react';
 import React, {useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState} from 'react';
-import type {NativeSyntheticEvent} from 'react-native';
+import type {NativeSyntheticEvent, StyleProp, ViewStyle} from 'react-native';
 import {View} from 'react-native';
 import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
 import useLocalize from '@hooks/useLocalize';
@@ -68,6 +68,9 @@ type NumberWithSymbolFormProps = {
     /** Whether to wrap the input in a container */
     shouldWrapInputInContainer?: boolean;
 
+    /** Style applied to the outer ScrollView */
+    scrollViewStyle?: StyleProp<ViewStyle>;
+
     /** Whether the amount is negative */
     isNegative?: boolean;
 
@@ -150,6 +153,7 @@ function NumberWithSymbolForm({
     shouldApplyPaddingToContainer = false,
     shouldUseDefaultLineHeightForPrefix = true,
     shouldWrapInputInContainer = true,
+    scrollViewStyle,
     isNegative = false,
     allowFlippingAmount = false,
     allowNegativeInput = false,
@@ -486,7 +490,7 @@ function NumberWithSymbolForm({
 
     return (
         <ScrollView
-            contentContainerStyle={styles.flexGrow1}
+            contentContainerStyle={[styles.flexGrow1, scrollViewStyle]}
             style={!shouldWrapInputInContainer && styles.flexGrow0}
         >
             {shouldWrapInputInContainer ? (
diff --git a/src/components/Search/SearchList/BaseSearchList/index.tsx b/src/components/Search/SearchList/BaseSearchList/index.tsx
index 1f9e558851413..3ab0dcd639409 100644
--- a/src/components/Search/SearchList/BaseSearchList/index.tsx
+++ b/src/components/Search/SearchList/BaseSearchList/index.tsx
@@ -1,9 +1,10 @@
 import {useIsFocused} from '@react-navigation/native';
 import {FlashList} from '@shopify/flash-list';
 import React, {useCallback, useEffect, useMemo, useRef} from 'react';
-import type {NativeSyntheticEvent} from 'react-native';
+import type {GestureResponderEvent, NativeSyntheticEvent} from 'react-native';
 import Animated from 'react-native-reanimated';
 import type {ExtendedTargetedEvent, SearchListItem} from '@components/SelectionListWithSections/types';
+import {getIsEditingCell} from '@components/Table/EditableCell';
 import useArrowKeyFocusManager from '@hooks/useArrowKeyFocusManager';
 import useKeyboardShortcut from '@hooks/useKeyboardShortcut';
 import {isMobileChrome} from '@libs/Browser';
@@ -80,22 +81,34 @@ function BaseSearchList({
         [focusedIndex, renderItem, setFocusedIndex],
     );
 
-    const selectFocusedOption = useCallback(() => {
-        const focusedItem = data.at(focusedIndex);
+    const selectFocusedOption = useCallback(
+        (event?: GestureResponderEvent | KeyboardEvent) => {
+            // Allow event propagation during cell editing so Enter can trigger TextInput.onSubmitEditing.
+            // When not editing, stop propagation to prevent unintended button activation and handle row selection.
+            if (getIsEditingCell()) {
+                return;
+            }
 
-        if (!focusedItem) {
-            return;
-        }
+            event?.stopPropagation();
+
+            const focusedItem = data.at(focusedIndex);
 
-        onSelectRow(focusedItem);
-    }, [data, focusedIndex, onSelectRow]);
+            if (!focusedItem) {
+                return;
+            }
+
+            onSelectRow(focusedItem);
+        },
+        [data, focusedIndex, onSelectRow],
+    );
 
     useKeyboardShortcut(CONST.KEYBOARD_SHORTCUTS.ENTER, selectFocusedOption, {
         captureOnInputs: true,
         shouldBubble: false,
         shouldPreventDefault: false,
         isActive: isFocused && focusedIndex >= 0,
-        shouldStopPropagation: true,
+        // Propagation is controlled manually in selectFocusedOption based on editing state
+        shouldStopPropagation: false,
     });
 
     useEffect(() => {
diff --git a/src/components/SelectionListWithSections/Search/DateCell.tsx b/src/components/SelectionListWithSections/Search/DateCell.tsx
index f9d3482d83bd4..6bf1bb226efd4 100644
--- a/src/components/SelectionListWithSections/Search/DateCell.tsx
+++ b/src/components/SelectionListWithSections/Search/DateCell.tsx
@@ -1,4 +1,7 @@
 import React from 'react';
+import DatePickerModal from '@components/DatePicker/DatePickerModal';
+import {EditableCell, usePopoverEditState} from '@components/Table/EditableCell';
+import type {EditableProps} from '@components/Table/EditableCell/types';
 import TextWithTooltip from '@components/TextWithTooltip';
 import useThemeStyles from '@hooks/useThemeStyles';
 import DateUtils from '@libs/DateUtils';
@@ -8,20 +11,55 @@ type DateCellProps = {
     date: string;
     showTooltip: boolean;
     isLargeScreenWidth: boolean;
-};
+} & EditableProps<string>;
 
-function DateCell({date, showTooltip, isLargeScreenWidth}: DateCellProps) {
+function DateCell({date, showTooltip, isLargeScreenWidth, canEdit, onSave}: DateCellProps) {
     const styles = useThemeStyles();
+    const {isEditing, anchorRef, isPopoverVisible, popoverPosition, isInverted, startEditing, cancelEditing} = usePopoverEditState({canEdit});
 
     const formattedDate = DateUtils.formatWithUTCTimeZone(date, DateUtils.doesDateBelongToAPastYear(date) ? CONST.DATE.MONTH_DAY_YEAR_ABBR_FORMAT : CONST.DATE.MONTH_DAY_ABBR_FORMAT);
 
-    return (
+    const handleDateSelected = (newDate: string) => {
+        onSave?.(newDate);
+        cancelEditing();
+    };
+
+    const displayContent = (
         <TextWithTooltip
             text={formattedDate}
             shouldShowTooltip={showTooltip}
             style={[styles.lineHeightLarge, styles.pre, styles.justifyContentCenter, isLargeScreenWidth ? undefined : [styles.textMicro, styles.textSupporting]]}
         />
     );
+
+    return (
+        <EditableCell
+            canEdit={canEdit}
+            isEditing={isEditing}
+            onStartEditing={startEditing}
+            anchorRef={anchorRef}
+            popoverContent={
+                <DatePickerModal
+                    value={date}
+                    isVisible={isPopoverVisible}
+                    onClose={cancelEditing}
+                    onSelected={handleDateSelected}
+                    anchorPosition={popoverPosition}
+                    anchorAlignment={{
+                        horizontal: CONST.MODAL.ANCHOR_ORIGIN_HORIZONTAL.LEFT,
+                        vertical: CONST.MODAL.ANCHOR_ORIGIN_VERTICAL.TOP,
+                    }}
+                    shouldPositionFromTop={!isInverted}
+                    minDate={CONST.CALENDAR_PICKER.MIN_DATE}
+                    maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
+                    inputID="EditableDateCell"
+                    shouldShowConfirmButtons
+                />
+            }
+        >
+            {displayContent}
+        </EditableCell>
+    );
 }
 
 export default DateCell;
diff --git a/src/components/SelectionListWithSections/Search/TransactionListItem.tsx b/src/components/SelectionListWithSections/Search/TransactionListItem.tsx
index cb7fa5715fc34..940eaf762526c 100644
--- a/src/components/SelectionListWithSections/Search/TransactionListItem.tsx
+++ b/src/components/SelectionListWithSections/Search/TransactionListItem.tsx
@@ -10,15 +10,18 @@ import OfflineWithFeedback from '@components/OfflineWithFeedback';
 import PressableWithFeedback from '@components/Pressable/PressableWithFeedback';
 import {useSearchStateContext} from '@components/Search/SearchContext';
 import type {ListItem, TransactionListItemProps, TransactionListItemType} from '@components/SelectionListWithSections/types';
+import {getIsEditingCell} from '@components/Table/EditableCell/editingCellState';
 import TransactionItemRow from '@components/TransactionItemRow';
 import useAnimatedHighlightStyle from '@hooks/useAnimatedHighlightStyle';
 import useCurrentUserPersonalDetails from '@hooks/useCurrentUserPersonalDetails';
+import useEffectivePolicyID from '@hooks/useEffectivePolicyID';
 import useOnyx from '@hooks/useOnyx';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useStyleUtils from '@hooks/useStyleUtils';
 import useSyncFocus from '@hooks/useSyncFocus';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
+import useTransactionInlineEdit from '@hooks/useTransactionInlineEdit';
 import type {TransactionPreviewData} from '@libs/actions/Search';
 import {handleActionButtonPress as handleActionButtonPressUtil} from '@libs/actions/Search';
 import {syncMissingAttendeesViolation} from '@libs/AttendeeUtils';
@@ -58,20 +61,15 @@ function TransactionListItem<TItem extends ListItem>({
     const theme = useTheme();
 
     const {isLargeScreenWidth, shouldUseNarrowLayout} = useResponsiveLayout();
-    const {currentSearchHash, currentSearchKey, currentSearchResults} = useSearchStateContext();
+    const {currentSearchHash, currentSearchKey, currentSearchResults, currentSearchQueryJSON} = useSearchStateContext();
     const snapshotReport = (currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${transactionItem.reportID}`] ?? {}) as Report;
 
     const [isActionLoading] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${transactionItem.reportID}`, {selector: isActionLoadingSelector});
 
-    // Use active policy (user's current workspace) as fallback for self DM tracking expenses
-    // This matches MoneyRequestView's approach via usePolicyForMovingExpenses()
-    const [activePolicyID] = useOnyx(ONYXKEYS.NVP_ACTIVE_POLICY_ID);
-
     // Use report's policyID as fallback when transaction doesn't have policyID directly
     // Use active policy as final fallback for SelfDM (tracking expenses)
-    // NOTE: Using || instead of ?? to treat empty string "" as falsy
     // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-    const policyID = transactionItem.policyID || snapshotReport?.policyID || activePolicyID;
+    const policyID = useEffectivePolicyID(transactionItem.policyID || snapshotReport?.policyID);
     const [parentPolicy] = originalUseOnyx(`${ONYXKEYS.COLLECTION.POLICY}${getNonEmptyStringOnyxID(policyID)}`);
     const snapshotPolicy = (currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.POLICY}${transactionItem.policyID}`] ?? {}) as Policy;
 
@@ -150,6 +148,45 @@ function TransactionListItem<TItem extends ListItem>({
     const {isDelegateAccessRestricted} = useDelegateNoAccessState();
     const {showDelegateNoAccessModal} = useDelegateNoAccessActions();
 
+    const transactionID = transactionItem.transactionID;
+
+    const {
+        canEditDate,
+        canEditMerchant,
+        canEditDescription,
+        canEditCategory,
+        canEditAmount,
+        canEditTag,
+        onEditDate,
+        onEditMerchant,
+        onEditDescription,
+        onEditCategory,
+        onEditAmount,
+        onEditTag,
+        wasEditingOnMouseDownRef,
+    } = useTransactionInlineEdit({
+        transactionID,
+        reportID: transactionItem.reportID,
+        reportActionID: transactionItem.reportAction?.reportActionID,
+        parentReportAction,
+        hash: currentSearchHash,
+        queryJSON: currentSearchQueryJSON,
+    });
+
+    const handleOnPress = () => {
+        // Consume the tap that dismissed an editing cell — a second tap will open the row.
+        // We check the ref rather than getIsEditingCell() because blur fires before onPress and resets the state.
+        if (wasEditingOnMouseDownRef.current) {
+            wasEditingOnMouseDownRef.current = false;
+            return;
+        }
+        // react-native-web fires onPress on Space for role="button" elements; suppress it while a cell is being edited.
+        if (getIsEditingCell()) {
+            return;
+        }
+        onSelectRow(item, transactionPreviewData);
+    };
+
     const handleActionButtonPress = () => {
         handleActionButtonPressUtil({
             hash: currentSearchHash,
@@ -177,12 +214,18 @@ function TransactionListItem<TItem extends ListItem>({
             <PressableWithFeedback
                 ref={pressableRef}
                 onLongPress={() => onLongPressRow?.(item)}
-                onPress={() => onSelectRow(item, transactionPreviewData)}
+                onPress={handleOnPress}
                 disabled={isDisabled && !item.isSelected}
                 accessibilityLabel={item.text ?? ''}
                 role={getButtonRole(true)}
                 isNested
-                onMouseDown={(e) => e.preventDefault()}
+                onMouseDown={(e) => {
+                    wasEditingOnMouseDownRef.current = getIsEditingCell();
+                    // Skip preventDefault when editing so the browser naturally blurs the input (triggering save/cancel).
+                    if (!getIsEditingCell()) {
+                        e.preventDefault();
+                    }
+                }}
                 hoverStyle={[!item.isDisabled && styles.hoveredComponentBG, item.isSelected && styles.activeComponentBG]}
                 dataSet={{[CONST.SELECTION_SCRAPER_HIDDEN_ELEMENT]: true, [CONST.INNER_BOX_SHADOW_ELEMENT]: false}}
                 id={item.keyForList ?? ''}
@@ -232,6 +275,18 @@ function TransactionListItem<TItem extends ListItem>({
                             isHover={hovered}
                             customCardNames={customCardNames}
                             reportActions={exportedReportActions}
+                            onEditDate={onEditDate}
+                            onEditMerchant={onEditMerchant}
+                            onEditDescription={onEditDescription}
+                            onEditCategory={onEditCategory}
+                            onEditAmount={onEditAmount}
+                            onEditTag={onEditTag}
+                            canEditDate={canEditDate}
+                            canEditMerchant={canEditMerchant}
+                            canEditDescription={canEditDescription}
+                            canEditCategory={canEditCategory}
+                            canEditAmount={canEditAmount}
+                            canEditTag={canEditTag}
                         />
                     </>
                 )}
diff --git a/src/components/SelectionListWithSections/SearchTableHeader.tsx b/src/components/SelectionListWithSections/SearchTableHeader.tsx
index 7d05263b54a09..6692883a39ae3 100644
--- a/src/components/SelectionListWithSections/SearchTableHeader.tsx
+++ b/src/components/SelectionListWithSections/SearchTableHeader.tsx
@@ -16,6 +16,7 @@ type SearchColumnConfig = {
     translationKey: TranslationPaths | undefined;
     icon?: IconAsset;
     isColumnSortable?: boolean;
+    canEdit?: boolean;
 };
 
 type SearchHeaderIcons = {
@@ -38,6 +39,7 @@ const getExpenseHeaders = (groupBy?: SearchGroupBy): SearchColumnConfig[] => [
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.DATE,
         translationKey: 'common.date',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.POSTED,
@@ -58,10 +60,12 @@ const getExpenseHeaders = (groupBy?: SearchGroupBy): SearchColumnConfig[] => [
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.MERCHANT,
         translationKey: 'common.merchant',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.DESCRIPTION,
         translationKey: 'common.description',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.FROM,
@@ -82,10 +86,12 @@ const getExpenseHeaders = (groupBy?: SearchGroupBy): SearchColumnConfig[] => [
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.CATEGORY,
         translationKey: 'common.category',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.TAG,
         translationKey: 'common.tag',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.REIMBURSABLE,
@@ -118,6 +124,7 @@ const getExpenseHeaders = (groupBy?: SearchGroupBy): SearchColumnConfig[] => [
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.TOTAL_AMOUNT,
         translationKey: groupBy ? 'common.total' : 'iou.amount',
+        canEdit: true,
     },
     {
         columnName: CONST.SEARCH.TABLE_COLUMNS.BASE_62_REPORT_ID,
diff --git a/src/components/SelectionListWithSections/SortableTableHeader.tsx b/src/components/SelectionListWithSections/SortableTableHeader.tsx
index 6b7ba34a35d5f..24c591ad99313 100644
--- a/src/components/SelectionListWithSections/SortableTableHeader.tsx
+++ b/src/components/SelectionListWithSections/SortableTableHeader.tsx
@@ -17,6 +17,7 @@ type ColumnConfig = {
     icon?: IconAsset;
     isColumnSortable?: boolean;
     canBeMissing?: boolean;
+    canEdit?: boolean;
 };
 
 type SearchTableHeaderProps = {
@@ -61,7 +62,7 @@ function SortableTableHeader({
     return (
         <View style={[styles.flex1]}>
             <View style={[styles.flex1, styles.flexRow, styles.gap3, containerStyles]}>
-                {columns.map(({columnName, translationKey, icon, isColumnSortable}) => {
+                {columns.map(({columnName, translationKey, icon, isColumnSortable, canEdit}) => {
                     if (!shouldShowColumn(columnName)) {
                         return null;
                     }
@@ -80,6 +81,7 @@ function SortableTableHeader({
                             isActive={isActive}
                             sentryLabel={CONST.SENTRY_LABEL.SEARCH.SORTABLE_HEADER}
                             containerStyle={[
+                                canEdit && styles.editableCellHeader,
                                 StyleUtils.getReportTableColumnStyles(
                                     columnName,
                                     dateColumnSize === CONST.SEARCH.TABLE_COLUMN_SIZES.WIDE,
diff --git a/src/components/Table/EditableCell/EditableCell.tsx b/src/components/Table/EditableCell/EditableCell.tsx
new file mode 100644
index 0000000000000..fb2d08c9d901c
--- /dev/null
+++ b/src/components/Table/EditableCell/EditableCell.tsx
@@ -0,0 +1,110 @@
+import React, {useEffect} from 'react';
+import type {ReactNode, RefObject} from 'react';
+import {View} from 'react-native';
+import PressableWithFeedback from '@components/Pressable/PressableWithFeedback';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import CONST from '@src/CONST';
+import {setIsEditingCell} from './editingCellState';
+
+type EditableCellProps = {
+    /** Content to display when not editing */
+    children: ReactNode;
+
+    /** Content to display when editing (inline replacement like TextInput). If omitted while isEditing, children are shown with an active border (popover mode). */
+    editContent?: ReactNode;
+
+    /** Popover or modal rendered as a sibling to the cell (e.g. date picker, category picker). Rendered for all edit-capable branches. */
+    popoverContent?: ReactNode;
+
+    /** Whether the cell is currently in editing mode */
+    isEditing: boolean;
+
+    /**
+     * Whether editing is currently permitted.
+     * Only meaningful when the layout supports editing. When false the styled container is still rendered (maintaining layout
+     * consistency) but the pressable is disabled and editing cannot be triggered.
+     */
+    canEdit?: boolean;
+
+    /** Callback when edit mode should be activated */
+    onStartEditing: () => void;
+
+    /** Ref attached to the cell wrapper — used as popover anchor for date/category pickers */
+    anchorRef?: RefObject<View | null>;
+};
+
+/**
+ * A stateless wrapper that handles hover highlight + click-to-edit for table cells.
+ * Does not manage editing state — the consumer controls that via hooks.
+ *
+ * Modes:
+ *   1. isEditable=false           → renders children as-is (narrow/mobile layout — no container needed)
+ *   2. isEditing + editContent    → replaces children with editContent (inline edit)
+ *   3. isEditing + no editContent → shows children with active border (popover edit)
+ *   4. canEdit=false              → styled container View, no pressable (transient: loading / no permission)
+ *   5. default                    → PressableWithFeedback (hover border, click triggers edit)
+ */
+function EditableCell({children, editContent, popoverContent, isEditing, canEdit, onStartEditing, anchorRef}: EditableCellProps) {
+    const styles = useThemeStyles();
+    const {isLargeScreenWidth} = useResponsiveLayout();
+    const isEditable = isLargeScreenWidth;
+
+    useEffect(() => {
+        if (!isEditable || !isEditing) {
+            return;
+        }
+        setIsEditingCell(true);
+        return () => setIsEditingCell(false);
+    }, [isEditing, isEditable]);
+
+    // Architectural exclusion (e.g. narrow layout) — no container, no padding.
+    if (!isEditable) {
+        return children;
+    }
+
+    // Inline edit mode: replace display content with the edit input
+    if (isEditing && editContent) {
+        return <View style={[styles.editableCell, styles.editableCellFocus]}>{editContent}</View>;
+    }
+
+    // Popover edit mode: keep showing display content with active border
+    if (isEditing && popoverContent) {
+        return (
+            <>
+                <View
+                    ref={anchorRef}
+                    style={[styles.editableCell, styles.editableCellFocus]}
+                >
+                    {children}
+                </View>
+                {popoverContent}
+            </>
+        );
+    }
+
+    // Transient non-editable state (loading, permissions pending): render the container for layout
+    // consistency but skip the pressable so the user cannot trigger edit mode.
+    if (!canEdit) {
+        return <View style={[styles.editableCell]}>{children}</View>;
+    }
+
+    return (
+        <PressableWithFeedback
+            accessibilityRole={CONST.ROLE.BUTTON}
+            accessibilityLabel="Edit cell"
+            sentryLabel={CONST.SENTRY_LABEL.TABLE.EDITABLE_CELL}
+            onPress={onStartEditing}
+            style={styles.editableCell}
+            wrapperStyle={styles.w100}
+            focusStyle={styles.editableCellFocus}
+            hoverStyle={styles.editableCellHover}
+        >
+            {children}
+        </PressableWithFeedback>
+    );
+}
+
+EditableCell.displayName = 'EditableCell';
+
+export default EditableCell;
diff --git a/src/components/Table/EditableCell/editingCellState.ts b/src/components/Table/EditableCell/editingCellState.ts
new file mode 100644
index 0000000000000..97b605149b373
--- /dev/null
+++ b/src/components/Table/EditableCell/editingCellState.ts
@@ -0,0 +1,16 @@
+/**
+ * Tracks whether an inline editable cell is currently open.
+ *
+ * Plain module state rather than React state because this is only read inside event handlers.
+ */
+let isEditingCell = false;
+
+function setIsEditingCell(value: boolean) {
+    isEditingCell = value;
+}
+
+function getIsEditingCell() {
+    return isEditingCell;
+}
+
+export {setIsEditingCell, getIsEditingCell};
diff --git a/src/components/Table/EditableCell/index.ts b/src/components/Table/EditableCell/index.ts
new file mode 100644
index 0000000000000..3fa26ff425c40
--- /dev/null
+++ b/src/components/Table/EditableCell/index.ts
@@ -0,0 +1,5 @@
+export {default as EditableCell} from './EditableCell';
+export {getIsEditingCell, setIsEditingCell} from './editingCellState';
+export {default as useInlineEditState} from './useInlineEditState';
+export {default as usePopoverEditState} from './usePopoverEditState';
+export type {EditableProps} from './types';
diff --git a/src/components/Table/EditableCell/types.ts b/src/components/Table/EditableCell/types.ts
new file mode 100644
index 0000000000000..3e5e8494ec97b
--- /dev/null
+++ b/src/components/Table/EditableCell/types.ts
@@ -0,0 +1,19 @@
+/**
+ * Shared props for all inline-editable table cells.
+ *
+ * @template T  The type of the value being saved (e.g. `string`, `number`).
+ */
+type EditableProps<T> = {
+    /**
+     * Transient flag: false while editing is temporarily unavailable
+     * (e.g. receipt scanning, insufficient permissions).
+     * The styled container is still rendered to preserve column alignment.
+     */
+    canEdit?: boolean;
+
+    /** Called with the new value when the user commits an edit. */
+    onSave?: (value: T) => void;
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export type {EditableProps};
diff --git a/src/components/Table/EditableCell/useInlineEditState.ts b/src/components/Table/EditableCell/useInlineEditState.ts
new file mode 100644
index 0000000000000..a94149890623c
--- /dev/null
+++ b/src/components/Table/EditableCell/useInlineEditState.ts
@@ -0,0 +1,52 @@
+import {useCallback, useEffect, useState} from 'react';
+
+/**
+ * Hook for managing inline editing state (text, number fields).
+ *
+ * Handles:
+ *   - Local value buffering (so the input doesn't write to parent on every keystroke)
+ *   - Save on blur (compares localValue vs original value)
+ *   - Cancel (reset to original)
+ *   - isEditing toggle
+ *   - Auto-cancel when canEdit becomes false
+ */
+function useInlineEditState<T>(canEdit: boolean | undefined, value: T, onSave?: (value: T) => void) {
+    const [isEditing, setIsEditing] = useState(false);
+    const [localValue, setLocalValue] = useState(value);
+
+    // Sync local value when the source-of-truth changes externally
+    useEffect(() => {
+        setLocalValue(value);
+    }, [value]);
+
+    const startEditing = useCallback(() => {
+        setIsEditing(true);
+    }, []);
+
+    const save = useCallback(() => {
+        if (localValue !== value) {
+            onSave?.(localValue);
+        }
+        // Always reset to the source-of-truth so a rejected save (e.g. empty merchant)
+        // doesn't leave stale localValue displayed after edit mode closes.
+        setLocalValue(value);
+        setIsEditing(false);
+    }, [localValue, value, onSave]);
+
+    const cancelEditing = useCallback(() => {
+        setLocalValue(value);
+        setIsEditing(false);
+    }, [value]);
+
+    // Cancel editing when permission is revoked (e.g., transaction status changed)
+    useEffect(() => {
+        if (canEdit || !isEditing) {
+            return;
+        }
+        cancelEditing();
+    }, [canEdit, cancelEditing, isEditing]);
+
+    return {isEditing, localValue, setLocalValue, startEditing, save, cancelEditing};
+}
+
+export default useInlineEditState;
diff --git a/src/components/Table/EditableCell/usePopoverEditState.ts b/src/components/Table/EditableCell/usePopoverEditState.ts
new file mode 100644
index 0000000000000..47504c0ddf8e0
--- /dev/null
+++ b/src/components/Table/EditableCell/usePopoverEditState.ts
@@ -0,0 +1,96 @@
+import {useEffect, useRef, useState} from 'react';
+import type {View} from 'react-native';
+import {InteractionManager} from 'react-native';
+import useWindowDimensions from '@hooks/useWindowDimensions';
+import CONST from '@src/CONST';
+
+type PopoverPosition = {
+    horizontal: number;
+    vertical: number;
+};
+
+type UsePopoverEditStateOptions = {
+    /** Whether editing is currently permitted. When false, editing will be cancelled. */
+    canEdit: boolean | undefined;
+
+    /** Height of the popover content (used for overflow detection). Defaults to CONST.POPOVER_DATE_MAX_HEIGHT */
+    popoverHeight?: number;
+
+    /** Padding between the anchor and the popover */
+    padding?: number;
+
+    /**
+     * Which horizontal edge of the anchor to use as the popover's x-origin.
+     * 'right' = x + width (right edge of anchor)
+     * 'left' = x (left edge of anchor)
+     */
+    anchorEdge?: 'left' | 'right';
+};
+
+/**
+ * Hook for managing popover-based editing state (date picker, category picker, etc.).
+ *
+ * Handles:
+ *   - Anchor ref for popover positioning
+ *   - measureInWindow-based position calculation
+ *   - Overflow detection (inverts when too close to bottom)
+ *   - Auto-open after layout via InteractionManager
+ *   - isEditing + isPopoverVisible toggling
+ *   - Auto-cancel when canEdit becomes false
+ */
+function usePopoverEditState({canEdit, popoverHeight = CONST.POPOVER_DATE_MAX_HEIGHT, padding = 8, anchorEdge = 'left'}: UsePopoverEditStateOptions) {
+    const {windowHeight} = useWindowDimensions();
+    const anchorRef = useRef<View>(null);
+    const [isEditing, setIsEditing] = useState(false);
+    const [isPopoverVisible, setIsPopoverVisible] = useState(false);
+    const [popoverPosition, setPopoverPosition] = useState<PopoverPosition>({horizontal: 0, vertical: 0});
+    const [isInverted, setIsInverted] = useState(false);
+
+    const openPopover = () => {
+        anchorRef.current?.measureInWindow((x, y, width, height) => {
+            const wouldExceedBottom = y + popoverHeight + padding > windowHeight;
+            setIsInverted(wouldExceedBottom);
+            setPopoverPosition({
+                horizontal: anchorEdge === 'left' ? x : x + width,
+                vertical: y + (wouldExceedBottom ? 0 : height + padding),
+            });
+            setIsPopoverVisible(true);
+        });
+    };
+
+    const startEditing = () => {
+        setIsEditing(true);
+        // Defer opening until after interactions so the anchor is measured correctly
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        InteractionManager.runAfterInteractions(() => {
+            openPopover();
+        });
+    };
+
+    const cancelEditing = () => {
+        setIsPopoverVisible(false);
+        setIsEditing(false);
+    };
+
+    // Cancel editing when permission is revoked (e.g., transaction status changed)
+    useEffect(() => {
+        if (canEdit || !isEditing) {
+            return;
+        }
+        queueMicrotask(() => {
+            cancelEditing();
+        });
+    }, [canEdit, isEditing]);
+
+    return {
+        isEditing,
+        anchorRef,
+        isPopoverVisible,
+        popoverPosition,
+        isInverted,
+        startEditing,
+        cancelEditing,
+    };
+}
+
+export default usePopoverEditState;
diff --git a/src/components/TagPicker/TagPickerModal.tsx b/src/components/TagPicker/TagPickerModal.tsx
new file mode 100644
index 0000000000000..a79692ccf4d38
--- /dev/null
+++ b/src/components/TagPicker/TagPickerModal.tsx
@@ -0,0 +1,112 @@
+import React, {useRef, useState} from 'react';
+import {View} from 'react-native';
+import ConfirmCancelButtonRow from '@components/ConfirmCancelButtonRow';
+import PopoverWithMeasuredContent from '@components/PopoverWithMeasuredContent';
+import type PopoverWithMeasuredContentProps from '@components/PopoverWithMeasuredContent/types';
+import useOnyx from '@hooks/useOnyx';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import {getTagList} from '@libs/PolicyUtils';
+import type {OptionData} from '@libs/ReportUtils';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import TagPicker from '.';
+
+const DEFAULT_ANCHOR_ALIGNMENT = {
+    horizontal: CONST.MODAL.ANCHOR_ORIGIN_HORIZONTAL.LEFT,
+    vertical: CONST.MODAL.ANCHOR_ORIGIN_VERTICAL.TOP,
+};
+
+const popoverDimensions = {
+    width: CONST.POPOVER_DROPDOWN_WIDTH,
+    height: CONST.POPOVER_DROPDOWN_MAX_HEIGHT,
+};
+
+type TagPickerModalProps = {
+    /** Callback to close the modal */
+    onClose: () => void;
+
+    /** The policy whose tags should be shown */
+    policyID: string | undefined;
+
+    /** Currently selected tag */
+    selectedTag?: string;
+
+    /** Called when the user confirms a tag selection */
+    onSelected?: (tag: string) => void;
+} & Omit<PopoverWithMeasuredContentProps, 'anchorRef' | 'children' | 'onClose'>;
+
+function TagPickerModal({
+    isVisible,
+    onClose,
+    anchorPosition,
+    policyID,
+    selectedTag = '',
+    onSelected,
+    anchorAlignment = DEFAULT_ANCHOR_ALIGNMENT,
+    shouldMeasureAnchorPositionFromTop = false,
+}: TagPickerModalProps) {
+    const styles = useThemeStyles();
+    // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
+    const {isSmallScreenWidth} = useResponsiveLayout();
+    const anchorRef = useRef<View>(null);
+
+    const [policyTags] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY_TAGS}${policyID}`);
+    const tagListName = getTagList(policyTags, 0).name;
+
+    const [pendingItem, setPendingItem] = useState<Partial<OptionData> | undefined>(undefined);
+
+    const handleTagSelected = (item: Partial<OptionData>) => {
+        setPendingItem(item);
+    };
+
+    const handleConfirm = () => {
+        if (pendingItem) {
+            onSelected?.(pendingItem.searchText ?? pendingItem.text ?? '');
+        }
+        setPendingItem(undefined);
+        onClose();
+    };
+
+    const handleCancel = () => {
+        setPendingItem(undefined);
+        onClose();
+    };
+
+    return (
+        <PopoverWithMeasuredContent
+            anchorRef={anchorRef}
+            isVisible={isVisible}
+            onClose={handleCancel}
+            anchorPosition={anchorPosition}
+            popoverDimensions={popoverDimensions}
+            anchorAlignment={anchorAlignment}
+            innerContainerStyle={isSmallScreenWidth ? styles.w100 : {width: CONST.POPOVER_DROPDOWN_WIDTH}}
+            restoreFocusType={CONST.MODAL.RESTORE_FOCUS_TYPE.DELETE}
+            shouldSwitchPositionIfOverflow
+            shouldEnableNewFocusManagement
+            shouldMeasureAnchorPositionFromTop={shouldMeasureAnchorPositionFromTop}
+            shouldSkipRemeasurement
+            shouldDisplayBelowModals
+        >
+            <View style={[{height: CONST.POPOVER_DROPDOWN_MAX_HEIGHT, flexDirection: 'column'}, styles.pt4]}>
+                <View style={styles.flex1}>
+                    <TagPicker
+                        policyID={policyID}
+                        tagListName={tagListName}
+                        tagListIndex={0}
+                        selectedTag={pendingItem?.searchText ?? pendingItem?.text ?? selectedTag}
+                        onSubmit={handleTagSelected}
+                    />
+                </View>
+                <ConfirmCancelButtonRow
+                    onConfirm={handleConfirm}
+                    onCancel={handleCancel}
+                    isConfirmDisabled={!pendingItem}
+                />
+            </View>
+        </PopoverWithMeasuredContent>
+    );
+}
+
+export default TagPickerModal;
diff --git a/src/components/TagPicker.tsx b/src/components/TagPicker/index.tsx
similarity index 96%
rename from src/components/TagPicker.tsx
rename to src/components/TagPicker/index.tsx
index 8cc6712b360d7..dfb57aab1732d 100644
--- a/src/components/TagPicker.tsx
+++ b/src/components/TagPicker/index.tsx
@@ -1,4 +1,6 @@
 import React, {useMemo, useState} from 'react';
+import RadioListItem from '@components/SelectionList/ListItem/RadioListItem';
+import SelectionListWithSections from '@components/SelectionList/SelectionListWithSections';
 import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
 import useThemeStyles from '@hooks/useThemeStyles';
@@ -11,8 +13,6 @@ import {getTagArrayFromName} from '@libs/TransactionUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type {PolicyTag, PolicyTags} from '@src/types/onyx';
-import RadioListItem from './SelectionList/ListItem/RadioListItem';
-import SelectionListWithSections from './SelectionList/SelectionListWithSections';
 
 type TagPickerProps = {
     /** The policyID we are getting tags for */
diff --git a/src/components/TextInput/BaseTextInput/implementation/index.native.tsx b/src/components/TextInput/BaseTextInput/implementation/index.native.tsx
index 78620a2c4159e..3a27b143e1aca 100644
--- a/src/components/TextInput/BaseTextInput/implementation/index.native.tsx
+++ b/src/components/TextInput/BaseTextInput/implementation/index.native.tsx
@@ -274,7 +274,7 @@ function BaseTextInput({
         autoGrowHeight && {scrollPaddingTop: typeof maxAutoGrowHeight === 'number' ? 2 * maxAutoGrowHeight : undefined},
         isAutoGrowHeightMarkdown && styles.pb2,
         inputProps.disabled && styles.textInputDisabledContainer,
-        shouldAddPaddingBottom && styles.pb1,
+        shouldAddPaddingBottom && shouldApplyPaddingToContainer && styles.pb1,
     ]);
 
     // TextInputMeasurement is absolutely positioned, so it doesn’t inherit padding/border.
diff --git a/src/components/TextInput/BaseTextInput/implementation/index.tsx b/src/components/TextInput/BaseTextInput/implementation/index.tsx
index a42aecebf6f80..26777bfe56351 100644
--- a/src/components/TextInput/BaseTextInput/implementation/index.tsx
+++ b/src/components/TextInput/BaseTextInput/implementation/index.tsx
@@ -313,7 +313,7 @@ function BaseTextInput({
         autoGrowHeight && {scrollPaddingTop: typeof maxAutoGrowHeight === 'number' ? 2 * maxAutoGrowHeight : undefined},
         isAutoGrowHeightMarkdown && styles.pb2,
         inputProps.disabled && shouldUseDisabledStyles && styles.textInputDisabledContainer,
-        shouldAddPaddingBottom && styles.pb1,
+        shouldAddPaddingBottom && shouldApplyPaddingToContainer && styles.pb1,
     ]);
 
     // TextInputMeasurement is absolutely positioned, so it doesn’t inherit padding/border.
diff --git a/src/components/TransactionItemRow/DataCells/CategoryCell.tsx b/src/components/TransactionItemRow/DataCells/CategoryCell.tsx
index 1eed41e4076b3..f52f3b7b31579 100644
--- a/src/components/TransactionItemRow/DataCells/CategoryCell.tsx
+++ b/src/components/TransactionItemRow/DataCells/CategoryCell.tsx
@@ -1,18 +1,38 @@
-import React from 'react';
+import React, {useCallback} from 'react';
+import CategoryPickerModal from '@components/CategoryPicker/CategoryPickerModal';
+import type {ListItem} from '@components/SelectionList/types';
 import TextWithIconCell from '@components/SelectionListWithSections/Search/TextWithIconCell';
+import {EditableCell, usePopoverEditState} from '@components/Table/EditableCell';
+import type {EditableProps} from '@components/Table/EditableCell';
 import TextWithTooltip from '@components/TextWithTooltip';
 import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
 import useThemeStyles from '@hooks/useThemeStyles';
 import {getDecodedCategoryName, isCategoryMissing} from '@libs/CategoryUtils';
 import type TransactionDataCellProps from './TransactionDataCellProps';
 
-function CategoryCell({shouldUseNarrowLayout, shouldShowTooltip, transactionItem}: TransactionDataCellProps) {
+type CategoryCellProps = TransactionDataCellProps &
+    EditableProps<string> & {
+        policyID?: string;
+    };
+
+function CategoryCell({shouldUseNarrowLayout, shouldShowTooltip, transactionItem, canEdit, onSave, policyID}: CategoryCellProps) {
     const icons = useMemoizedLazyExpensifyIcons(['Folder']);
     const styles = useThemeStyles();
+    const {isEditing, anchorRef, isPopoverVisible, popoverPosition, isInverted, startEditing, cancelEditing} = usePopoverEditState({canEdit});
 
     const categoryForDisplay = isCategoryMissing(transactionItem?.category) ? '' : getDecodedCategoryName(transactionItem?.category ?? '');
 
-    return shouldUseNarrowLayout ? (
+    const handleCategorySelected = useCallback(
+        (item: ListItem) => {
+            if (item.keyForList) {
+                onSave?.(String(item.keyForList));
+            }
+            cancelEditing();
+        },
+        [onSave, cancelEditing],
+    );
+
+    const displayContent = shouldUseNarrowLayout ? (
         <TextWithIconCell
             icon={icons.Folder}
             showTooltip={shouldShowTooltip}
@@ -27,6 +47,28 @@ function CategoryCell({shouldUseNarrowLayout, shouldShowTooltip, transactionItem
             style={[styles.lineHeightLarge, styles.preWrap, styles.justifyContentCenter]}
         />
     );
+
+    return (
+        <EditableCell
+            canEdit={canEdit}
+            isEditing={isEditing}
+            onStartEditing={startEditing}
+            anchorRef={anchorRef}
+            popoverContent={
+                <CategoryPickerModal
+                    policyID={policyID}
+                    selectedCategory={transactionItem?.category ?? ''}
+                    isVisible={isPopoverVisible}
+                    onClose={cancelEditing}
+                    anchorPosition={popoverPosition}
+                    shouldMeasureAnchorPositionFromTop={!isInverted}
+                    onSelected={handleCategorySelected}
+                />
+            }
+        >
+            {displayContent}
+        </EditableCell>
+    );
 }
 
 export default CategoryCell;
diff --git a/src/components/TransactionItemRow/DataCells/MerchantCell.tsx b/src/components/TransactionItemRow/DataCells/MerchantCell.tsx
index 7aec8d8fdfda4..6e8761b32a208 100644
--- a/src/components/TransactionItemRow/DataCells/MerchantCell.tsx
+++ b/src/components/TransactionItemRow/DataCells/MerchantCell.tsx
@@ -1,35 +1,115 @@
-import React, {useMemo} from 'react';
+import React, {useEffect, useMemo, useRef} from 'react';
+import type {TextInputKeyPressEvent} from 'react-native';
+import {EditableCell, useInlineEditState} from '@components/Table/EditableCell';
+import type {EditableProps} from '@components/Table/EditableCell/types';
+import TextInput from '@components/TextInput';
 import TextWithTooltip from '@components/TextWithTooltip';
 import useThemeStyles from '@hooks/useThemeStyles';
 import Parser from '@libs/Parser';
+import StringUtils from '@libs/StringUtils';
+import CONST from '@src/CONST';
 
-function MerchantOrDescriptionCell({
-    merchantOrDescription,
-    shouldShowTooltip,
-    shouldUseNarrowLayout,
-    isDescription,
-}: {
+type MerchantOrDescriptionCellProps = {
     merchantOrDescription: string;
     shouldUseNarrowLayout?: boolean;
     shouldShowTooltip: boolean;
     isDescription?: boolean;
-}) {
+} & EditableProps<string>;
+
+function MerchantOrDescriptionCell({merchantOrDescription, shouldShowTooltip, shouldUseNarrowLayout, isDescription, canEdit, onSave}: MerchantOrDescriptionCellProps) {
     const styles = useThemeStyles();
 
     const text = useMemo(() => {
         if (!isDescription) {
             return merchantOrDescription;
         }
-        return Parser.htmlToText(merchantOrDescription).replaceAll('\n', ' ');
+        return StringUtils.lineBreaksToSpaces(Parser.htmlToText(merchantOrDescription));
     }, [merchantOrDescription, isDescription]);
 
+    const {isEditing, localValue, setLocalValue, startEditing, save} = useInlineEditState(canEdit, text, onSave);
+
+    const isMultilineInput = isDescription;
+
+    const handleChangeText = (value: string) => {
+        // Sanitize line breaks on change for single line inputs.
+        if (!isMultilineInput) {
+            setLocalValue(StringUtils.removeLineBreaks(value));
+            return;
+        }
+        setLocalValue(value);
+    };
+
+    // Prevent double-save: pressing Enter can fires onSubmitEditing (on single-line inputs) then
+    // immediately triggers a blur (blurOnSubmit=true by default), which would call save twice.
+    const submitFiredRef = useRef(false);
+
+    // Reset the submit flag when entering edit mode to ensure clean state for each editing session
+    useEffect(() => {
+        if (!isEditing) {
+            return;
+        }
+        submitFiredRef.current = false;
+    }, [isEditing]);
+
+    const handleSubmitEditing = () => {
+        submitFiredRef.current = true;
+        save();
+    };
+
+    const handleBlur = () => {
+        if (submitFiredRef.current) {
+            submitFiredRef.current = false;
+            return;
+        }
+        save();
+    };
+
+    const handleKeyPress = (e: TextInputKeyPressEvent) => {
+        if (isMultilineInput) {
+            return;
+        }
+
+        // For single-line inputs (merchant), prevent Shift+Enter from inserting newlines
+        if (e.nativeEvent.key === CONST.KEYBOARD_SHORTCUTS.ENTER.shortcutKey) {
+            e.preventDefault();
+            handleSubmitEditing();
+        }
+    };
+
     return (
-        <TextWithTooltip
-            shouldShowTooltip={shouldShowTooltip}
-            text={text}
-            numberOfLines={shouldUseNarrowLayout ? 1 : 2}
-            style={[shouldUseNarrowLayout ? styles.lh20 : styles.lineHeightLarge, shouldUseNarrowLayout ? styles.pre : styles.preWrap, styles.justifyContentCenter, styles.flex1]}
-        />
+        <EditableCell
+            canEdit={canEdit}
+            isEditing={isEditing}
+            onStartEditing={startEditing}
+            editContent={
+                <TextInput
+                    accessibilityLabel={isDescription ? 'Description input' : 'Merchant input'}
+                    value={localValue}
+                    onChangeText={handleChangeText}
+                    onKeyPress={handleKeyPress}
+                    onBlur={handleBlur}
+                    onSubmitEditing={handleSubmitEditing}
+                    autoFocus
+                    // We use a multiline TextInput for both merchant and description to keep editing behavior consistent.
+                    // Since merchants are single-line, we sanitize line breaks before storing.
+                    multiline
+                    submitBehavior="blurAndSubmit"
+                    // EditableCell is responsible for the cell's hover and focus styles (border, background).
+                    // Suppress TextInput's own border and background to avoid visual conflicts.
+                    textInputContainerStyles={styles.editableCellInputStyle}
+                    touchableInputWrapperStyle={styles.editableCellInputStyle}
+                    hideFocusedState
+                    shouldApplyPaddingToContainer={false}
+                />
+            }
+        >
+            <TextWithTooltip
+                shouldShowTooltip={shouldShowTooltip}
+                text={localValue}
+                numberOfLines={shouldUseNarrowLayout ? 1 : 2}
+                style={shouldUseNarrowLayout ? [styles.lh20, styles.pre, styles.justifyContentCenter, styles.flex1] : [styles.lineHeightXLarge, styles.preWrap]}
+            />
+        </EditableCell>
     );
 }
 
diff --git a/src/components/TransactionItemRow/DataCells/TagCell.tsx b/src/components/TransactionItemRow/DataCells/TagCell.tsx
index 00a741f52a141..f69df6d055962 100644
--- a/src/components/TransactionItemRow/DataCells/TagCell.tsx
+++ b/src/components/TransactionItemRow/DataCells/TagCell.tsx
@@ -1,29 +1,68 @@
 import React from 'react';
 import TextWithIconCell from '@components/SelectionListWithSections/Search/TextWithIconCell';
+import type {EditableProps} from '@components/Table/EditableCell';
+import {EditableCell, usePopoverEditState} from '@components/Table/EditableCell';
+import TagPickerModal from '@components/TagPicker/TagPickerModal';
 import TextWithTooltip from '@components/TextWithTooltip';
 import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
 import useThemeStyles from '@hooks/useThemeStyles';
 import {getTagForDisplay} from '@libs/TransactionUtils';
 import type TransactionDataCellProps from './TransactionDataCellProps';
 
-function TagCell({shouldUseNarrowLayout, shouldShowTooltip, transactionItem}: TransactionDataCellProps) {
+type TagCellProps = TransactionDataCellProps &
+    EditableProps<string> & {
+        policyID?: string;
+    };
+
+function TagCell({canEdit, onSave, shouldUseNarrowLayout, shouldShowTooltip, transactionItem, policyID}: TagCellProps) {
     const icons = useMemoizedLazyExpensifyIcons(['Tag']);
     const styles = useThemeStyles();
-    return shouldUseNarrowLayout ? (
+    const {isEditing, anchorRef, isPopoverVisible, popoverPosition, isInverted, startEditing, cancelEditing} = usePopoverEditState({canEdit});
+
+    const handleTagSelected = (tag: string) => {
+        onSave?.(tag);
+        cancelEditing();
+    };
+
+    const tagForDisplay = getTagForDisplay(transactionItem);
+
+    const displayContent = shouldUseNarrowLayout ? (
         <TextWithIconCell
             icon={icons.Tag}
             showTooltip={shouldShowTooltip}
-            text={getTagForDisplay(transactionItem)}
+            text={tagForDisplay}
             textStyle={[styles.textMicro, styles.mnh0]}
         />
     ) : (
         <TextWithTooltip
             shouldShowTooltip={shouldShowTooltip}
-            text={getTagForDisplay(transactionItem)}
+            text={tagForDisplay}
             numberOfLines={2}
             style={[styles.lineHeightLarge, styles.preWrap, styles.justifyContentCenter]}
         />
     );
+
+    return (
+        <EditableCell
+            canEdit={canEdit}
+            isEditing={isEditing}
+            onStartEditing={startEditing}
+            anchorRef={anchorRef}
+            popoverContent={
+                <TagPickerModal
+                    policyID={policyID}
+                    selectedTag={transactionItem?.tag ?? ''}
+                    isVisible={isPopoverVisible}
+                    onClose={cancelEditing}
+                    anchorPosition={popoverPosition}
+                    shouldMeasureAnchorPositionFromTop={!isInverted}
+                    onSelected={handleTagSelected}
+                />
+            }
+        >
+            {displayContent}
+        </EditableCell>
+    );
 }
 
 export default TagCell;
diff --git a/src/components/TransactionItemRow/DataCells/TotalCell.tsx b/src/components/TransactionItemRow/DataCells/TotalCell.tsx
index 5c5248cff7400..3338453c00b07 100644
--- a/src/components/TransactionItemRow/DataCells/TotalCell.tsx
+++ b/src/components/TransactionItemRow/DataCells/TotalCell.tsx
@@ -1,13 +1,21 @@
-import React from 'react';
+import React, {useRef} from 'react';
+import MoneyRequestAmountInput from '@components/MoneyRequestAmountInput';
+import {EditableCell, useInlineEditState} from '@components/Table/EditableCell';
+import type {EditableProps} from '@components/Table/EditableCell';
+import type {BaseTextInputRef} from '@components/TextInput/BaseTextInput/types';
 import TextWithTooltip from '@components/TextWithTooltip';
 import useLocalize from '@hooks/useLocalize';
 import useThemeStyles from '@hooks/useThemeStyles';
-import {convertToDisplayString} from '@libs/CurrencyUtils';
+import {convertToDisplayString, convertToFrontendAmountAsString} from '@libs/CurrencyUtils';
+import {parseFloatAnyLocale, roundToTwoDecimalPlaces} from '@libs/NumberUtils';
 import {getTransactionDetails} from '@libs/ReportUtils';
 import {getCurrency as getTransactionCurrency, isScanning} from '@libs/TransactionUtils';
+import variables from '@styles/variables';
 import type TransactionDataCellProps from './TransactionDataCellProps';
 
-function TotalCell({shouldShowTooltip, transactionItem}: TransactionDataCellProps) {
+type TotalCellProps = TransactionDataCellProps & EditableProps<number>;
+
+function TotalCell({shouldShowTooltip, transactionItem, canEdit, onSave}: TotalCellProps) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const currency = getTransactionCurrency(transactionItem);
@@ -18,13 +26,75 @@ function TotalCell({shouldShowTooltip, transactionItem}: TransactionDataCellProp
         amountToDisplay = translate('iou.receiptStatusTitle');
     }
 
-    return (
+    const absoluteAmount = Math.abs(amount ?? 0);
+
+    const handleAmountSave = (amountString: string) => {
+        const parsedValue = parseFloatAnyLocale(amountString);
+        if (!Number.isNaN(parsedValue) && parsedValue >= 0) {
+            const normalizedValue = roundToTwoDecimalPlaces(parsedValue);
+            // Convert back to cents for the save callback
+            onSave?.(Math.round(normalizedValue * 100));
+        }
+    };
+
+    // localValue tracks the frontend-format amount string (e.g. "12.34") while editing
+    const {isEditing, setLocalValue, startEditing, save} = useInlineEditState(canEdit, convertToFrontendAmountAsString(absoluteAmount, currency), handleAmountSave);
+
+    // Ref used to programmatically focus the input when edit mode starts
+    const inputRef = useRef<BaseTextInputRef | null>(null);
+
+    const focusOnMount = (ref: BaseTextInputRef | null) => {
+        inputRef.current = ref;
+        ref?.focus();
+    };
+
+    const handleAmountChange = (amountString: string) => {
+        setLocalValue(amountString);
+    };
+
+    const handleBlur = () => {
+        save();
+    };
+
+    const displayContent = (
         <TextWithTooltip
             shouldShowTooltip={shouldShowTooltip}
             text={amountToDisplay}
-            style={[styles.optionDisplayName, styles.justifyContentCenter, styles.flexShrink0]}
+            style={[styles.optionDisplayName, styles.justifyContentCenter, styles.flexShrink1, styles.textAlignRight]}
         />
     );
+
+    return (
+        <EditableCell
+            canEdit={canEdit}
+            isEditing={isEditing}
+            onStartEditing={startEditing}
+            editContent={
+                <MoneyRequestAmountInput
+                    ref={focusOnMount}
+                    amount={absoluteAmount}
+                    currency={currency}
+                    disableKeyboard={false}
+                    isCurrencyPressable={false}
+                    hideFocusedState
+                    shouldShowBigNumberPad={false}
+                    shouldWrapInputInContainer={false}
+                    shouldApplyPaddingToContainer={false}
+                    onAmountChange={handleAmountChange}
+                    onBlur={handleBlur}
+                    // EditableCell is responsible for the cell's hover and focus styles (border, background).
+                    // Suppress MoneyRequestAmountInput's own border and background to avoid visual conflicts.
+                    containerStyle={[styles.editableCellInputStyle]}
+                    inputStyle={[styles.textAlignRight]}
+                    touchableInputWrapperStyle={[styles.editableCellInputStyle]}
+                    scrollViewStyle={[styles.flexRow, styles.justifyContentEnd]}
+                    symbolTextStyle={[{fontSize: variables.fontSizeNormal}, styles.textSupporting]}
+                />
+            }
+        >
+            {displayContent}
+        </EditableCell>
+    );
 }
 
 export default TotalCell;
diff --git a/src/components/TransactionItemRow/index.tsx b/src/components/TransactionItemRow/index.tsx
index 13a5de8f1debd..5d3787aa0f188 100644
--- a/src/components/TransactionItemRow/index.tsx
+++ b/src/components/TransactionItemRow/index.tsx
@@ -16,6 +16,7 @@ import AmountCell from '@components/SelectionListWithSections/Search/TotalCell';
 import UserInfoCell from '@components/SelectionListWithSections/Search/UserInfoCell';
 import WorkspaceCell from '@components/SelectionListWithSections/Search/WorkspaceCell';
 import Text from '@components/Text';
+import useEffectivePolicyID from '@hooks/useEffectivePolicyID';
 import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
 import useLocalize from '@hooks/useLocalize';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
@@ -140,6 +141,22 @@ type TransactionItemRowProps = {
     customCardNames?: Record<number, string>;
     reportActions?: ReportAction[];
     checkboxSentryLabel?: string;
+
+    /** Callbacks for inline cell editing (desktop only) */
+    onEditDate?: (newDate: string) => void;
+    onEditMerchant?: (newMerchant: string) => void;
+    onEditDescription?: (newDescription: string) => void;
+    onEditCategory?: (newCategory: string) => void;
+    onEditAmount?: (newAmount: number) => void;
+    onEditTag?: (newTag: string) => void;
+
+    /** Per-field edit permissions — controls whether the cell shows editable affordance */
+    canEditDate?: boolean;
+    canEditMerchant?: boolean;
+    canEditDescription?: boolean;
+    canEditCategory?: boolean;
+    canEditAmount?: boolean;
+    canEditTag?: boolean;
 };
 
 const EMPTY_ACTIVE_STYLE: StyleProp<ViewStyle> = [];
@@ -192,6 +209,18 @@ function TransactionItemRow({
     customCardNames,
     reportActions,
     checkboxSentryLabel,
+    onEditDate,
+    onEditMerchant,
+    onEditDescription,
+    onEditCategory,
+    onEditAmount,
+    onEditTag,
+    canEditDate,
+    canEditMerchant,
+    canEditDescription,
+    canEditCategory,
+    canEditAmount,
+    canEditTag,
 }: TransactionItemRowProps) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
@@ -199,6 +228,10 @@ function TransactionItemRow({
     const theme = useTheme();
     const {isLargeScreenWidth} = useResponsiveLayout();
     const hasCategoryOrTag = !isCategoryMissing(transactionItem?.category) || !!transactionItem.tag;
+
+    // Compute effective policy ID once for all child components
+    // For unreported expenses (SelfDM), falls back to active policy
+    const effectivePolicyID = useEffectivePolicyID(report?.policyID ?? transactionItem.report?.policyID);
     const createdAt = getTransactionCreated(transactionItem);
     const expensicons = useMemoizedLazyExpensifyIcons(['ArrowRight']);
     const transactionThreadReportID = reportActions ? getIOUActionForTransactionID(reportActions, transactionItem.transactionID)?.childReportID : undefined;
@@ -303,6 +336,9 @@ function TransactionItemRow({
                             transactionItem={transactionItem}
                             shouldShowTooltip={shouldShowTooltip}
                             shouldUseNarrowLayout={shouldUseNarrowLayout}
+                            canEdit={canEditTag}
+                            onSave={onEditTag}
+                            policyID={effectivePolicyID}
                         />
                     </View>
                 );
@@ -313,7 +349,9 @@ function TransactionItemRow({
                         style={[StyleUtils.getReportTableColumnStyles(CONST.SEARCH.TABLE_COLUMNS.DATE, isDateColumnWide, false, false)]}
                     >
                         <DateCell
+                            canEdit={canEditDate}
                             date={createdAt}
+                            onSave={onEditDate}
                             showTooltip={shouldShowTooltip}
                             isLargeScreenWidth={!shouldUseNarrowLayout}
                         />
@@ -381,6 +419,9 @@ function TransactionItemRow({
                             transactionItem={transactionItem}
                             shouldShowTooltip={shouldShowTooltip}
                             shouldUseNarrowLayout={shouldUseNarrowLayout}
+                            canEdit={canEditCategory}
+                            onSave={onEditCategory}
+                            policyID={effectivePolicyID}
                         />
                     </View>
                 );
@@ -431,13 +472,13 @@ function TransactionItemRow({
                         key={column}
                         style={[StyleUtils.getReportTableColumnStyles(CONST.SEARCH.TABLE_COLUMNS.MERCHANT)]}
                     >
-                        {!!merchant && (
-                            <MerchantOrDescriptionCell
-                                merchantOrDescription={merchant}
-                                shouldShowTooltip={shouldShowTooltip}
-                                shouldUseNarrowLayout={false}
-                            />
-                        )}
+                        <MerchantOrDescriptionCell
+                            merchantOrDescription={merchant ?? ''}
+                            shouldShowTooltip={shouldShowTooltip}
+                            shouldUseNarrowLayout={false}
+                            canEdit={canEditMerchant}
+                            onSave={onEditMerchant}
+                        />
                     </View>
                 );
             case CONST.SEARCH.TABLE_COLUMNS.DESCRIPTION:
@@ -446,14 +487,14 @@ function TransactionItemRow({
                         key={column}
                         style={[StyleUtils.getReportTableColumnStyles(CONST.SEARCH.TABLE_COLUMNS.DESCRIPTION)]}
                     >
-                        {!!description && (
-                            <MerchantOrDescriptionCell
-                                merchantOrDescription={description}
-                                shouldShowTooltip={shouldShowTooltip}
-                                shouldUseNarrowLayout={false}
-                                isDescription
-                            />
-                        )}
+                        <MerchantOrDescriptionCell
+                            merchantOrDescription={description}
+                            shouldShowTooltip={shouldShowTooltip}
+                            shouldUseNarrowLayout={false}
+                            isDescription
+                            canEdit={canEditDescription}
+                            onSave={onEditDescription}
+                        />
                     </View>
                 );
             case CONST.SEARCH.TABLE_COLUMNS.TO:
@@ -526,6 +567,8 @@ function TransactionItemRow({
                             transactionItem={transactionItem}
                             shouldShowTooltip={shouldShowTooltip}
                             shouldUseNarrowLayout={shouldUseNarrowLayout}
+                            canEdit={canEditAmount}
+                            onSave={onEditAmount}
                         />
                     </View>
                 );
@@ -730,11 +773,13 @@ function TransactionItemRow({
                                         transactionItem={transactionItem}
                                         shouldShowTooltip={shouldShowTooltip}
                                         shouldUseNarrowLayout={shouldUseNarrowLayout}
+                                        policyID={effectivePolicyID}
                                     />
                                     <TagCell
                                         transactionItem={transactionItem}
                                         shouldShowTooltip={shouldShowTooltip}
                                         shouldUseNarrowLayout={shouldUseNarrowLayout}
+                                        policyID={effectivePolicyID}
                                     />
                                 </View>
                             )}
diff --git a/src/hooks/useEffectivePolicyID.ts b/src/hooks/useEffectivePolicyID.ts
new file mode 100644
index 0000000000000..014c77e35f0ef
--- /dev/null
+++ b/src/hooks/useEffectivePolicyID.ts
@@ -0,0 +1,15 @@
+import ONYXKEYS from '@src/ONYXKEYS';
+import useOnyx from './useOnyx';
+
+/**
+ * Returns the provided policyID or falls back to the active policy ID.
+ * Used for unreported expenses (SelfDM) to show policy-specific fields like categories and tags.
+ */
+export default function useEffectivePolicyID(policyID?: string): string | undefined {
+    const [activePolicyID] = useOnyx(ONYXKEYS.NVP_ACTIVE_POLICY_ID);
+
+    // NOTE: Using || instead of ?? to treat empty string "" as falsy
+    // This ensures empty strings fall back to active policy
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    return policyID || activePolicyID;
+}
diff --git a/src/hooks/useTransactionInlineEdit.ts b/src/hooks/useTransactionInlineEdit.ts
new file mode 100644
index 0000000000000..c477450d58e5b
--- /dev/null
+++ b/src/hooks/useTransactionInlineEdit.ts
@@ -0,0 +1,177 @@
+/**
+ * Centralizes inline-editing logic for a transaction row so that permission
+ * derivation, Onyx subscriptions, and edit handlers live in one place rather
+ * than being duplicated across every surface that renders a transaction.
+ */
+import {useCallback, useRef} from 'react';
+import type {OnyxEntry} from 'react-native-onyx';
+import type {SearchQueryJSON} from '@components/Search/types';
+import {
+    editTransactionAmountInline,
+    editTransactionCategoryInline,
+    editTransactionDateInline,
+    editTransactionDescriptionInline,
+    editTransactionMerchantInline,
+    editTransactionTagInline,
+    getTransactionEditPermissions,
+} from '@libs/actions/TransactionInlineEdit';
+import getNonEmptyStringOnyxID from '@libs/getNonEmptyStringOnyxID';
+import {getIOUActionForTransactionID} from '@libs/ReportActionsUtils';
+import {isExpenseUnreported} from '@libs/TransactionUtils';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {ReportAction, ReportActions} from '@src/types/onyx';
+import useOnyx from './useOnyx';
+import usePolicyForMovingExpenses from './usePolicyForMovingExpenses';
+
+type UseTransactionInlineEditParams = {
+    transactionID: string;
+    reportID: string | undefined;
+
+    /**
+     * When provided the action is looked up directly by ID (faster).
+     * If omitted, the hook scans all actions for the one matching this transaction.
+     * Ignored when `parentReportAction` is supplied directly.
+     */
+    reportActionID?: string;
+
+    /**
+     * Pre-fetched parent report action.
+     * When provided the hook skips its own Onyx subscription entirely, avoiding
+     * a duplicate subscription in components that already hold this data.
+     */
+    parentReportAction?: OnyxEntry<ReportAction>;
+
+    /**
+     * Search snapshot hash.
+     * When provided, edit functions will optimistically update the snapshot row.
+     * Omit (or pass undefined) when editing from outside the Search table.
+     */
+    hash?: number;
+
+    /**
+     * Search query context.
+     * When provided the editable-tab guard is applied — only tab types/statuses
+     * that support inline editing will return canEdit=true.
+     * Omit when editing from the Expense Report page (always editable by permissions alone).
+     */
+    queryJSON?: SearchQueryJSON;
+};
+
+type UseTransactionInlineEditReturn = {
+    canEditDate: boolean;
+    canEditMerchant: boolean;
+    canEditDescription: boolean;
+    canEditCategory: boolean;
+    canEditAmount: boolean;
+    canEditTag: boolean;
+    transactionThreadReportID: string | undefined;
+    onEditDate: (newDate: string) => void;
+    onEditMerchant: (newMerchant: string) => void;
+    onEditDescription: (newDescription: string) => void;
+    onEditCategory: (newCategory: string) => void;
+    onEditAmount: (newAmount: number) => void;
+    onEditTag: (newTag: string) => void;
+    /**
+     * Ref that should be written in onPressIn and checked in onPress to suppress
+     * row navigation when a cell edit is being dismissed.
+     */
+    wasEditingOnMouseDownRef: React.RefObject<boolean>;
+};
+
+function useTransactionInlineEdit({
+    transactionID,
+    reportID,
+    reportActionID,
+    parentReportAction: externalParentReportAction,
+    hash,
+    queryJSON,
+}: UseTransactionInlineEditParams): UseTransactionInlineEditReturn {
+    // Look up the parent IOU report action from live Onyx. If the caller already
+    // knows the action ID we can select it directly; otherwise we scan all actions.
+    // When the caller supplies `parentReportAction` directly we still must call
+    // useOnyx (rules of hooks) but we ignore its result and prefer the external value.
+    const parentReportActionSelector = useCallback(
+        (reportActions: ReportActions | undefined) => (reportActionID ? reportActions?.[reportActionID] : getIOUActionForTransactionID(Object.values(reportActions ?? {}), transactionID)),
+        [reportActionID, transactionID],
+    );
+
+    const [internalParentReportAction] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${getNonEmptyStringOnyxID(reportID)}`, {
+        selector: parentReportActionSelector,
+    });
+
+    const [transaction] = useOnyx(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
+    const [parentReport] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${getNonEmptyStringOnyxID(reportID)}`);
+
+    const parentReportAction = externalParentReportAction !== undefined ? externalParentReportAction : internalParentReportAction;
+
+    const transactionThreadReportID = parentReportAction?.childReportID;
+    const policyID = parentReport?.policyID;
+    const chatReportID = parentReport?.chatReportID;
+
+    const [policy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${getNonEmptyStringOnyxID(policyID)}`);
+    const [transactionThreadReport] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${getNonEmptyStringOnyxID(transactionThreadReportID)}`);
+    const [policyCategories] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY_CATEGORIES}${getNonEmptyStringOnyxID(policyID)}`);
+    const [policyTags] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY_TAGS}${getNonEmptyStringOnyxID(policyID)}`);
+    const [transactionThreadNVP] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${getNonEmptyStringOnyxID(transactionThreadReportID)}`);
+    const [chatReportNVP] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${getNonEmptyStringOnyxID(chatReportID)}`);
+
+    // For unreported expenses (SelfDM), get the user's default policy for moving expenses.
+    // This policy determines whether category/tag editing is allowed.
+    const isUnreported = isExpenseUnreported(transaction);
+    const {policyForMovingExpenses} = usePolicyForMovingExpenses(undefined, undefined);
+    const policyForPermissions = isUnreported ? policyForMovingExpenses : undefined;
+
+    const permissions = getTransactionEditPermissions({
+        transaction,
+        parentReportAction,
+        parentReport,
+        policyForMovingExpenses: policyForPermissions,
+        parentPolicy: policy,
+        transactionThreadReport,
+        policyCategories,
+        policyTags,
+        transactionThreadNVP,
+        chatReportNVP,
+        queryJSON,
+    });
+
+    const wasEditingOnMouseDownRef = useRef(false);
+
+    const onEditDate = (newDate: string) => {
+        editTransactionDateInline(hash, transactionID, transactionThreadReportID, newDate);
+    };
+
+    const onEditMerchant = (newMerchant: string) => {
+        editTransactionMerchantInline(hash, transactionID, transactionThreadReportID, newMerchant);
+    };
+
+    const onEditDescription = (newDescription: string) => {
+        editTransactionDescriptionInline(hash, transactionID, transactionThreadReportID, newDescription);
+    };
+
+    const onEditCategory = (newCategory: string) => {
+        editTransactionCategoryInline(hash, transactionID, transactionThreadReportID, newCategory);
+    };
+
+    const onEditAmount = (newAmount: number) => {
+        editTransactionAmountInline(hash, transactionID, transactionThreadReportID, newAmount);
+    };
+
+    const onEditTag = (newTag: string) => {
+        editTransactionTagInline(hash, transactionID, transactionThreadReportID, newTag);
+    };
+
+    return {
+        ...permissions,
+        transactionThreadReportID,
+        onEditDate,
+        onEditMerchant,
+        onEditDescription,
+        onEditCategory,
+        onEditAmount,
+        onEditTag,
+        wasEditingOnMouseDownRef,
+    };
+}
+
+export default useTransactionInlineEdit;
diff --git a/src/libs/StringUtils/index.ts b/src/libs/StringUtils/index.ts
index 2b6502a9cc8d6..8df6e3819ead4 100644
--- a/src/libs/StringUtils/index.ts
+++ b/src/libs/StringUtils/index.ts
@@ -120,6 +120,15 @@ function normalizeCRLF(value?: string): string | undefined {
     return value?.replaceAll('\r\n', '\n');
 }
 
+/**
+ * Remove all line breaks from a string
+ * @param text - The input string
+ * @returns The string with all line breaks removed
+ */
+function removeLineBreaks(text = '') {
+    return text.replaceAll(CONST.REGEX.LINE_BREAK, '');
+}
+
 /**
  * Replace all line breaks with white spaces
  */
@@ -211,6 +220,7 @@ export default {
     normalizeAccents,
     normalizeCRLF,
     lineBreaksToSpaces,
+    removeLineBreaks,
     getFirstLine,
     removeDoubleQuotes,
     removePreCodeBlock,
diff --git a/src/libs/actions/IOU/index.ts b/src/libs/actions/IOU/index.ts
index 99cd0f4e18713..45d4c700feabd 100644
--- a/src/libs/actions/IOU/index.ts
+++ b/src/libs/actions/IOU/index.ts
@@ -4677,12 +4677,19 @@ function getUpdateTrackExpenseParams(
     transactionChanges: TransactionChanges,
     policy: OnyxEntry<OnyxTypes.Policy>,
     shouldBuildOptimisticModifiedExpenseReportAction = true,
+    hash?: number,
 ): UpdateMoneyRequestData<
-    typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.TRANSACTION_DRAFT
+    | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
+    | typeof ONYXKEYS.COLLECTION.TRANSACTION
+    | typeof ONYXKEYS.COLLECTION.REPORT
+    | typeof ONYXKEYS.COLLECTION.TRANSACTION_DRAFT
+    | typeof ONYXKEYS.COLLECTION.SNAPSHOT
 > {
     const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.REPORT>> = [];
     const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION_DRAFT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.TRANSACTION>> = [];
-    const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.REPORT>> = [];
+    const failureData: Array<
+        OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.SNAPSHOT>
+    > = [];
 
     // Step 1: Set any "pending fields" (ones updated while the user was offline) to have error messages in the failureData
     const pendingFields = Object.fromEntries(Object.keys(transactionChanges).map((key) => [key, CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE]));
@@ -4840,6 +4847,20 @@ function getUpdateTrackExpenseParams(
         value: transactionThread,
     });
 
+    // Roll back the snapshot copy of the transaction so the search row reverts to its pre-edit state
+    if (hash) {
+        // @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
+        failureData.push({
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${hash}`,
+            value: {
+                data: {
+                    [`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`]: transaction ?? null,
+                },
+            },
+        });
+    }
+
     return {
         params: apiParams,
         onyxData: {optimisticData, successData, failureData},
@@ -4860,6 +4881,7 @@ type UpdateMoneyRequestDateParams = {
     currentUserEmailParam: string;
     isASAPSubmitBetaEnabled: boolean;
     parentReportNextStep: OnyxEntry<OnyxTypes.ReportNextStepDeprecated>;
+    hash?: number;
 };
 
 /** Updates the created date of an expense */
@@ -4877,6 +4899,7 @@ function updateMoneyRequestDate({
     currentUserEmailParam,
     isASAPSubmitBetaEnabled,
     parentReportNextStep,
+    hash,
 }: UpdateMoneyRequestDateParams) {
     const transactionChanges: TransactionChanges = {
         created: value,
@@ -4884,7 +4907,7 @@ function updateMoneyRequestDate({
     let data: UpdateMoneyRequestData<UpdateMoneyRequestDataKeys>;
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     if (isTrackExpenseReport(transactionThreadReport) && isSelfDM(parentReport)) {
-        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy);
+        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy, true, hash);
     } else {
         data = getUpdateMoneyRequestParams({
             transactionID,
@@ -4898,6 +4921,7 @@ function updateMoneyRequestDate({
             currentUserEmailParam,
             isASAPSubmitBetaEnabled,
             iouReportNextStep: parentReportNextStep,
+            hash,
         });
         removeTransactionFromDuplicateTransactionViolation(data.onyxData, transactionID, transactions, transactionViolations);
     }
@@ -5013,6 +5037,7 @@ function updateMoneyRequestMerchant({
     currentUserEmailParam,
     isASAPSubmitBetaEnabled,
     parentReportNextStep,
+    hash,
 }: {
     transactionID: string;
     transactionThreadReport: OnyxEntry<OnyxTypes.Report>;
@@ -5025,6 +5050,7 @@ function updateMoneyRequestMerchant({
     currentUserEmailParam: string;
     isASAPSubmitBetaEnabled: boolean;
     parentReportNextStep: OnyxEntry<OnyxTypes.ReportNextStepDeprecated>;
+    hash?: number;
 }) {
     const transactionChanges: TransactionChanges = {
         merchant: value,
@@ -5032,7 +5058,7 @@ function updateMoneyRequestMerchant({
     let data: UpdateMoneyRequestData<UpdateMoneyRequestDataKeys>;
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     if (isTrackExpenseReport(transactionThreadReport) && isSelfDM(parentReport)) {
-        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy);
+        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy, true, hash);
     } else {
         data = getUpdateMoneyRequestParams({
             transactionID,
@@ -5046,6 +5072,7 @@ function updateMoneyRequestMerchant({
             currentUserEmailParam,
             isASAPSubmitBetaEnabled,
             iouReportNextStep: parentReportNextStep,
+            hash,
         });
     }
     const {params, onyxData} = data;
@@ -5438,6 +5465,7 @@ function updateMoneyRequestDescription({
     currentUserEmailParam,
     isASAPSubmitBetaEnabled,
     parentReportNextStep,
+    hash,
 }: {
     transactionID: string;
     transactionThreadReport: OnyxEntry<OnyxTypes.Report>;
@@ -5450,6 +5478,7 @@ function updateMoneyRequestDescription({
     currentUserEmailParam: string;
     isASAPSubmitBetaEnabled: boolean;
     parentReportNextStep: OnyxEntry<OnyxTypes.ReportNextStepDeprecated>;
+    hash?: number;
 }) {
     const parsedComment = getParsedComment(comment);
     const transactionChanges: TransactionChanges = {
@@ -5458,7 +5487,7 @@ function updateMoneyRequestDescription({
     let data: UpdateMoneyRequestData<UpdateMoneyRequestDataKeys>;
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     if (isTrackExpenseReport(transactionThreadReport) && isSelfDM(parentReport)) {
-        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy);
+        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy, true, hash);
     } else {
         data = getUpdateMoneyRequestParams({
             transactionID,
@@ -5472,6 +5501,7 @@ function updateMoneyRequestDescription({
             currentUserEmailParam,
             isASAPSubmitBetaEnabled,
             iouReportNextStep: parentReportNextStep,
+            hash,
         });
     }
     const {params, onyxData} = data;
@@ -7821,6 +7851,7 @@ type UpdateMoneyRequestAmountAndCurrencyParams = {
     isASAPSubmitBetaEnabled: boolean;
     policyRecentlyUsedCurrencies: string[];
     parentReportNextStep: OnyxEntry<OnyxTypes.ReportNextStepDeprecated>;
+    hash?: number;
 };
 
 /** Updates the amount and currency fields of an expense */
@@ -7844,6 +7875,7 @@ function updateMoneyRequestAmountAndCurrency({
     isASAPSubmitBetaEnabled,
     policyRecentlyUsedCurrencies,
     parentReportNextStep,
+    hash,
 }: UpdateMoneyRequestAmountAndCurrencyParams) {
     const transactionChanges = {
         amount,
@@ -7856,7 +7888,7 @@ function updateMoneyRequestAmountAndCurrency({
     let data: UpdateMoneyRequestData<UpdateMoneyRequestDataKeys>;
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     if (isTrackExpenseReport(transactionThreadReport) && isSelfDM(parentReport)) {
-        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy);
+        data = getUpdateTrackExpenseParams(transactionID, transactionThreadReport?.reportID, transactionChanges, policy, true, hash);
     } else {
         data = getUpdateMoneyRequestParams({
             transactionID,
@@ -7872,6 +7904,7 @@ function updateMoneyRequestAmountAndCurrency({
             isASAPSubmitBetaEnabled,
             policyRecentlyUsedCurrencies,
             iouReportNextStep: parentReportNextStep,
+            hash,
         });
         removeTransactionFromDuplicateTransactionViolation(data.onyxData, transactionID, transactions, transactionViolations);
     }
diff --git a/src/libs/actions/TransactionInlineEdit.ts b/src/libs/actions/TransactionInlineEdit.ts
new file mode 100644
index 0000000000000..366dfb1170baa
--- /dev/null
+++ b/src/libs/actions/TransactionInlineEdit.ts
@@ -0,0 +1,428 @@
+/**
+ * Actions for inline editing of transactions from the Search results table and the Expense Report page.
+ *
+ * Each function optionally updates the search snapshot entry (when a hash is provided) so the row
+ * reflects the new value immediately, then delegates to the corresponding IOU action which owns
+ * the canonical Onyx record, the API write, and failure rollback.
+ */
+import Onyx from 'react-native-onyx';
+import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
+import type {ValueOf} from 'type-fest';
+import type {SearchQueryJSON} from '@components/Search/types';
+import {hasEnabledOptions} from '@libs/OptionsListUtils';
+import Permissions from '@libs/Permissions';
+import {getTagLists, isMultiLevelTags} from '@libs/PolicyUtils';
+import {isMoneyRequestAction} from '@libs/ReportActionsUtils';
+import {canEditFieldOfMoneyRequest, canEditMoneyRequest, canUserPerformWriteAction, isArchivedReport, isReportInGroupPolicy} from '@libs/ReportUtils';
+import {hasEnabledTags} from '@libs/TagsOptionsListUtils';
+import {isExpenseUnreported} from '@libs/TransactionUtils';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {
+    Beta,
+    Policy,
+    PolicyCategories,
+    PolicyTagLists,
+    RecentlyUsedCategories,
+    RecentlyUsedTags,
+    Report,
+    ReportAction,
+    ReportNameValuePairs,
+    ReportNextStepDeprecated,
+    SearchResults,
+    Transaction,
+    TransactionViolations,
+} from '@src/types/onyx';
+import {
+    updateMoneyRequestAmountAndCurrency,
+    updateMoneyRequestCategory,
+    updateMoneyRequestDate,
+    updateMoneyRequestDescription,
+    updateMoneyRequestMerchant,
+    updateMoneyRequestTag,
+} from './IOU';
+
+type TransactionEditPermissions = {
+    canEditDate: boolean;
+    canEditMerchant: boolean;
+    canEditDescription: boolean;
+    canEditCategory: boolean;
+    canEditAmount: boolean;
+    canEditTag: boolean;
+};
+
+let allTransactions: NonNullable<OnyxCollection<Transaction>> = {};
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.TRANSACTION,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allTransactions = value ?? {};
+    },
+});
+
+let allTransactionViolations: NonNullable<OnyxCollection<TransactionViolations>> = {};
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allTransactionViolations = value ?? {};
+    },
+});
+
+let allReports: OnyxCollection<Report>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.REPORT,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allReports = value;
+    },
+});
+
+let allPolicies: OnyxCollection<Policy>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.POLICY,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allPolicies = value;
+    },
+});
+
+let allPolicyTags: OnyxCollection<PolicyTagLists> = {};
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.POLICY_TAGS,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allPolicyTags = value ?? {};
+    },
+});
+
+let allPolicyCategories: OnyxCollection<PolicyCategories>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.POLICY_CATEGORIES,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allPolicyCategories = value;
+    },
+});
+
+let allPolicyRecentlyUsedCategories: OnyxCollection<RecentlyUsedCategories>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.POLICY_RECENTLY_USED_CATEGORIES,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allPolicyRecentlyUsedCategories = value;
+    },
+});
+
+let allPolicyRecentlyUsedTags: OnyxCollection<RecentlyUsedTags> = {};
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.POLICY_RECENTLY_USED_TAGS,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allPolicyRecentlyUsedTags = value ?? {};
+    },
+});
+
+let allNextSteps: OnyxCollection<ReportNextStepDeprecated>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.NEXT_STEP,
+    waitForCollectionCallback: true,
+    callback: (value) => {
+        allNextSteps = value;
+    },
+});
+
+let currentUserAccountID: number = CONST.DEFAULT_NUMBER_ID;
+let currentUserEmail = '';
+Onyx.connectWithoutView({
+    key: ONYXKEYS.SESSION,
+    callback: (value) => {
+        currentUserEmail = value?.email ?? '';
+        currentUserAccountID = value?.accountID ?? CONST.DEFAULT_NUMBER_ID;
+    },
+});
+
+let allBetas: Beta[] | undefined;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.BETAS,
+    callback: (value) => {
+        allBetas = value ?? undefined;
+    },
+});
+
+const NO_EDIT: Readonly<TransactionEditPermissions> = Object.freeze({
+    canEditDate: false,
+    canEditMerchant: false,
+    canEditDescription: false,
+    canEditCategory: false,
+    canEditAmount: false,
+    canEditTag: false,
+});
+
+type TransactionEditPermissionsParams = {
+    transaction: OnyxEntry<Transaction>;
+
+    parentReportAction: OnyxEntry<ReportAction>;
+
+    parentReport: OnyxEntry<Report>;
+
+    policyForMovingExpenses?: OnyxEntry<Policy>;
+
+    parentPolicy?: OnyxEntry<Policy>;
+
+    transactionThreadReport?: OnyxEntry<Report>;
+
+    policyCategories?: OnyxEntry<PolicyCategories>;
+
+    policyTags?: OnyxEntry<PolicyTagLists>;
+
+    transactionThreadNVP?: OnyxEntry<ReportNameValuePairs>;
+
+    chatReportNVP?: OnyxEntry<ReportNameValuePairs>;
+
+    /** Search query context. When provided, applies editable-tab guard for Search table. */
+    queryJSON?: SearchQueryJSON;
+};
+
+/**
+ * @private
+ * Optimistically write a partial transaction update into the search snapshot so
+ * the table row reflects the new value before the server responds.
+ */
+function optimisticallyUpdateSnapshotTransaction(hash: number, transactionID: string, partialTransaction: Partial<Transaction>) {
+    Onyx.merge(`${ONYXKEYS.COLLECTION.SNAPSHOT}${hash}`, {
+        data: {[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`]: partialTransaction as Transaction} as unknown as SearchResults['data'],
+    });
+}
+
+/**
+ * @private
+ * Builds all params needed for IOU action calls from module-level Onyx caches.
+ * The returned object can be spread directly into any updateMoneyRequest* call
+ * (all shared fields are at the top level); field-specific extras like
+ * policyTagList, policyRecentlyUsedCategories, and transaction are also included.
+ */
+function getIouParamsForTransaction(transactionID: string, transactionThreadReportID: string | undefined) {
+    const transaction = allTransactions[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
+    const reportID = transaction?.reportID;
+    const parentReport = reportID ? allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`] : undefined;
+    const policyID = parentReport?.policyID;
+    const policy = policyID ? allPolicies?.[`${ONYXKEYS.COLLECTION.POLICY}${policyID}`] : undefined;
+    const policyTagList = policyID ? allPolicyTags?.[`${ONYXKEYS.COLLECTION.POLICY_TAGS}${policyID}`] : undefined;
+    const policyCategories = policyID ? allPolicyCategories?.[`${ONYXKEYS.COLLECTION.POLICY_CATEGORIES}${policyID}`] : undefined;
+    const policyRecentlyUsedCategories = policyID ? allPolicyRecentlyUsedCategories?.[`${ONYXKEYS.COLLECTION.POLICY_RECENTLY_USED_CATEGORIES}${policyID}`] : undefined;
+    const parentReportNextStep = reportID ? allNextSteps?.[`${ONYXKEYS.COLLECTION.NEXT_STEP}${reportID}`] : undefined;
+    const transactionThreadReport = transactionThreadReportID ? allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${transactionThreadReportID}`] : undefined;
+
+    return {
+        // Shared base fields — spread directly into any updateMoneyRequest* call
+        transactionID,
+        transactionThreadReport,
+        parentReport,
+        policy,
+        policyCategories,
+        parentReportNextStep,
+        currentUserAccountIDParam: currentUserAccountID,
+        currentUserEmailParam: currentUserEmail,
+        isASAPSubmitBetaEnabled: Permissions.isBetaEnabled(CONST.BETAS.ASAP_SUBMIT, allBetas),
+        // Field-specific extras
+        transaction,
+        policyTagList,
+        policyRecentlyUsedCategories,
+        policyRecentlyUsedTags: policyID ? allPolicyRecentlyUsedTags?.[`${ONYXKEYS.COLLECTION.POLICY_RECENTLY_USED_TAGS}${policyID}`] : undefined,
+    };
+}
+
+/** Updates the date of an expense from the Search results table or the Expense Report page. */
+function editTransactionDateInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newDate: string) {
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {modifiedCreated: newDate});
+    }
+    updateMoneyRequestDate({
+        ...iouParams,
+        // updateMoneyRequestDate uses 'policyTags' (not policyTagList)
+        policyTags: iouParams.policyTagList,
+        value: newDate,
+        transactions: allTransactions,
+        transactionViolations: allTransactionViolations,
+        hash,
+    });
+}
+
+/** Updates the merchant of an expense from the Search results table or the Expense Report page. */
+function editTransactionMerchantInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newMerchant: string) {
+    // Merchant must be a non-empty string. An empty merchant is not a valid
+    // state and the IOU action would save it as a blank row label.
+    if (!newMerchant.trim()) {
+        return;
+    }
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {modifiedMerchant: newMerchant});
+    }
+    updateMoneyRequestMerchant({
+        ...iouParams,
+        value: newMerchant,
+        hash,
+    });
+}
+
+/** Updates the description of an expense from the Search results table or the Expense Report page. */
+function editTransactionDescriptionInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newDescription: string) {
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {comment: {comment: newDescription}});
+    }
+    updateMoneyRequestDescription({
+        ...iouParams,
+        comment: newDescription,
+        hash,
+    });
+}
+
+/** Updates the category of an expense from the Search results table or the Expense Report page. */
+function editTransactionCategoryInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newCategory: string) {
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {category: newCategory});
+    }
+    updateMoneyRequestCategory({
+        ...iouParams,
+        category: newCategory,
+        hash,
+    });
+}
+
+/** Updates the amount and currency of an expense from the Search results table or the Expense Report page. */
+function editTransactionAmountInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newAmount: number) {
+    if (newAmount <= 0) {
+        return;
+    }
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    // Keep the existing currency — only the amount is changing from the search table
+    const currency = iouParams.transaction?.modifiedCurrency ?? iouParams.transaction?.currency ?? CONST.CURRENCY.USD;
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {modifiedAmount: newAmount, modifiedCurrency: currency});
+    }
+    updateMoneyRequestAmountAndCurrency({
+        ...iouParams,
+        amount: newAmount,
+        currency,
+        // Preserve existing tax values from the live transaction record
+        taxAmount: iouParams.transaction?.taxAmount ?? 0,
+        taxCode: iouParams.transaction?.taxCode ?? '',
+        taxValue: '',
+        allowNegative: false,
+        transactions: allTransactions,
+        transactionViolations: allTransactionViolations,
+        policyRecentlyUsedCurrencies: [],
+        hash,
+    });
+}
+
+/** Updates the tag of an expense from the Search results table or the Expense Report page. */
+function editTransactionTagInline(hash: number | undefined, transactionID: string, transactionThreadReportID: string | undefined, newTag: string) {
+    const iouParams = getIouParamsForTransaction(transactionID, transactionThreadReportID);
+    if (hash !== undefined) {
+        optimisticallyUpdateSnapshotTransaction(hash, transactionID, {tag: newTag});
+    }
+    updateMoneyRequestTag({
+        ...iouParams,
+        tag: newTag,
+        policyRecentlyUsedTags: iouParams.policyRecentlyUsedTags,
+        hash,
+    });
+}
+
+/**
+ * Core inline-edit permission check, shared by the Search table and the Expense Report page.
+ * Mirrors MoneyRequestView's permission logic:
+ * 1. isEditable = canUserPerformWriteAction(transactionThreadReport)
+ * 2. canEdit = isMoneyRequestAction(parentReportAction) && canEditMoneyRequest(...) && isEditable
+ * 3. Restricted fields (date, merchant, amount): canEditFieldOfMoneyRequest per field
+ * 4. Non-restricted fields (description, category, tag): canEdit + policy feature flags
+ */
+function getTransactionEditPermissions({
+    transaction,
+    parentReportAction,
+    parentReport,
+    policyForMovingExpenses,
+    parentPolicy,
+    transactionThreadReport,
+    policyCategories,
+    policyTags,
+    transactionThreadNVP,
+    chatReportNVP,
+    queryJSON,
+}: TransactionEditPermissionsParams): TransactionEditPermissions {
+    // Search-table tab guard
+    if (queryJSON !== undefined) {
+        const isEditableTab = queryJSON.type === CONST.SEARCH.DATA_TYPES.EXPENSE && CONST.SEARCH.INLINE_EDITABLE_EXPENSE_STATUSES.has((queryJSON.status as string) ?? '');
+        if (!isEditableTab) {
+            return NO_EDIT;
+        }
+    }
+
+    if (!transaction) {
+        return NO_EDIT;
+    }
+
+    const isUnreported = isExpenseUnreported(transaction);
+    const isChatReportArchived = isArchivedReport(chatReportNVP);
+    const isTransactionThreadArchived = isArchivedReport(transactionThreadNVP);
+
+    // Matches MoneyRequestView's isEditable.
+    // For unreported expenses the user always owns these. When the transaction
+    // thread report hasn't been loaded into Onyx yet (common in Search), we
+    // can't evaluate canUserPerformWriteAction — skip the check and let
+    // canEditMoneyRequest be the gatekeeper instead of blocking all editing.
+    const isEditable = isUnreported || !transactionThreadReport || !!canUserPerformWriteAction(transactionThreadReport, isTransactionThreadArchived);
+    if (!isEditable) {
+        return NO_EDIT;
+    }
+
+    // Matches MoneyRequestView's canEdit.
+    // For unreported expenses, parentReportAction may not be loaded; they are
+    // always editable by the owner.
+    const canEdit = isUnreported || (isMoneyRequestAction(parentReportAction) && canEditMoneyRequest(parentReportAction, isChatReportArchived, parentReport, parentPolicy, transaction));
+    if (!canEdit) {
+        return NO_EDIT;
+    }
+
+    const policyTagLists = getTagLists(policyTags);
+    const isPolicyExpenseChat = isReportInGroupPolicy(parentReport, parentPolicy);
+    const categoryForDisplay = transaction?.category ?? '';
+
+    // For restricted fields, delegate to canEditFieldOfMoneyRequest.
+    // Unreported expenses bypass this (all restricted fields editable by owner).
+    const canEditRestricted = (field: string) =>
+        isUnreported ||
+        canEditFieldOfMoneyRequest(parentReportAction, field as ValueOf<typeof CONST.EDIT_REQUEST_FIELD>, false, isChatReportArchived, undefined, transaction, parentReport, parentPolicy);
+
+    return {
+        canEditDate: canEditRestricted(CONST.EDIT_REQUEST_FIELD.DATE),
+        canEditMerchant: canEditRestricted(CONST.EDIT_REQUEST_FIELD.MERCHANT),
+        // Non-restricted; always editable when canEdit is true
+        canEditDescription: true,
+        // Matches MoneyRequestView's shouldShowCategory logic
+        canEditCategory:
+            (isPolicyExpenseChat && (!!categoryForDisplay || hasEnabledOptions(policyCategories ?? {}))) ||
+            (isUnreported && (!policyForMovingExpenses || hasEnabledOptions(policyCategories ?? {}))),
+        canEditAmount: canEditRestricted(CONST.EDIT_REQUEST_FIELD.AMOUNT),
+        // single-level tags only (multi-level needs a picker UI not available inline).
+        canEditTag: !isMultiLevelTags(policyTags) && (!!transaction?.tag || hasEnabledTags(policyTagLists)),
+    };
+}
+
+export {
+    editTransactionDateInline,
+    editTransactionMerchantInline,
+    editTransactionDescriptionInline,
+    editTransactionCategoryInline,
+    editTransactionAmountInline,
+    editTransactionTagInline,
+    getTransactionEditPermissions,
+};
+
+export type {TransactionEditPermissions};
diff --git a/src/styles/index.ts b/src/styles/index.ts
index ed4e012c65104..2902c3f9b8239 100644
--- a/src/styles/index.ts
+++ b/src/styles/index.ts
@@ -1097,6 +1097,51 @@ const staticStyles = (theme: ThemeColors) =>
             borderColor: theme.border,
         },
 
+        /**
+         * Matches the border and padding of editableCell so column headers stay
+         * visually aligned with their editable cells.
+         */
+        editableCellHeader: {
+            borderWidth: 1,
+            borderRadius: variables.componentBorderRadius,
+            borderColor: 'transparent',
+            paddingHorizontal: 4,
+        },
+
+        editableCell: {
+            width: '100%',
+            borderWidth: 1,
+            borderRadius: variables.componentBorderRadius,
+            borderColor: 'transparent',
+            padding: 4,
+            height: 'auto',
+            minHeight: variables.editableCellHeight,
+            maxHeight: variables.editableCellMaxHeight,
+            overflow: 'hidden',
+            justifyContent: 'center',
+        },
+
+        editableCellHover: {
+            borderColor: theme.buttonHoveredBG,
+        },
+
+        editableCellFocus: {
+            borderColor: theme.borderFocus,
+            backgroundColor: theme.appBG,
+        },
+
+        /** Suppresses all visual styling on TextInput when rendered inside EditableCell */
+        editableCellInputStyle: {
+            padding: 0,
+            borderWidth: 0,
+            borderColor: 'transparent',
+            borderRadius: 0,
+            backgroundColor: 'transparent',
+            height: '100%',
+            minHeight: 0,
+            fontSize: variables.fontSizeNormal,
+        },
+
         borderColorFocus: {
             borderColor: theme.borderFocus,
         },
diff --git a/src/styles/utils/index.ts b/src/styles/utils/index.ts
index 8b0cb4c11c404..1116a71c69adf 100644
--- a/src/styles/utils/index.ts
+++ b/src/styles/utils/index.ts
@@ -1825,7 +1825,7 @@ const createStyleUtils = (theme: ThemeColors, styles: ThemeStyles) => ({
                 columnWidth = {...getWidthStyle(isExportedColumnWide ? variables.w92 : variables.w72)};
                 break;
             case CONST.SEARCH.TABLE_COLUMNS.DATE:
-                columnWidth = {...getWidthStyle(isDateColumnWide ? variables.w92 : variables.w52)};
+                columnWidth = {...getWidthStyle(isDateColumnWide ? variables.w92 : variables.w62)};
                 break;
             case CONST.SEARCH.TABLE_COLUMNS.WITHDRAWN:
             case CONST.SEARCH.TABLE_COLUMNS.GROUP_WITHDRAWN:
diff --git a/src/styles/variables.ts b/src/styles/variables.ts
index bb3e46c13c2d0..0216e1d9c9c9f 100644
--- a/src/styles/variables.ts
+++ b/src/styles/variables.ts
@@ -139,6 +139,8 @@ export default {
     inputPaddingTop: getValueUsingPixelRatio(15, 21),
     inputPaddingBottom: getValueUsingPixelRatio(8, 11),
     inputHeightSmall: 28,
+    editableCellHeight: 32,
+    editableCellMaxHeight: 48,
     inputIconMarginTopSmall: getValueUsingPixelRatio(8, 11),
     inputIconMarginTopLarge: getValueUsingPixelRatio(16, 21),
     formErrorLineHeight: getValueUsingPixelRatio(18, 23),
@@ -362,6 +364,7 @@ export default {
     w44: 44,
     w46: 46,
     w52: 52,
+    w62: 62,
     w72: 72,
     w80: 80,
     w92: 92,
diff --git a/tests/unit/hooks/useInlineEditState.test.ts b/tests/unit/hooks/useInlineEditState.test.ts
new file mode 100644
index 0000000000000..0b7de2838160d
--- /dev/null
+++ b/tests/unit/hooks/useInlineEditState.test.ts
@@ -0,0 +1,137 @@
+import {act, renderHook} from '@testing-library/react-native';
+import useInlineEditState from '@components/Table/EditableCell/useInlineEditState';
+
+describe('useInlineEditState', () => {
+    it('starts with isEditing=false and localValue equal to the initial value', () => {
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello'));
+
+        expect(result.current.isEditing).toBe(false);
+        expect(result.current.localValue).toBe('hello');
+    });
+
+    it('startEditing sets isEditing to true', () => {
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello'));
+
+        act(() => {
+            result.current.startEditing();
+        });
+
+        expect(result.current.isEditing).toBe(true);
+    });
+
+    it('save calls onSave with the new value when localValue differs from original', () => {
+        const onSave = jest.fn();
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello', onSave));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.setLocalValue('world');
+        });
+        act(() => {
+            result.current.save();
+        });
+
+        expect(onSave).toHaveBeenCalledWith('world');
+        expect(result.current.isEditing).toBe(false);
+    });
+
+    it('save does NOT call onSave when localValue equals the original value', () => {
+        const onSave = jest.fn();
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello', onSave));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.save();
+        });
+
+        expect(onSave).not.toHaveBeenCalled();
+        expect(result.current.isEditing).toBe(false);
+    });
+
+    it('save works without an onSave callback (no crash)', () => {
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello'));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.setLocalValue('changed');
+        });
+
+        expect(() => {
+            act(() => {
+                result.current.save();
+            });
+        }).not.toThrow();
+        expect(result.current.isEditing).toBe(false);
+    });
+
+    it('cancel resets localValue to the original and sets isEditing to false', () => {
+        const onSave = jest.fn();
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello', onSave));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.setLocalValue('modified');
+        });
+        expect(result.current.localValue).toBe('modified');
+
+        act(() => {
+            result.current.cancelEditing();
+        });
+
+        expect(result.current.localValue).toBe('hello');
+        expect(result.current.isEditing).toBe(false);
+        expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('cancel without prior edits still sets isEditing to false', () => {
+        const {result} = renderHook(() => useInlineEditState<string>(true, 'hello'));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.cancelEditing();
+        });
+
+        expect(result.current.isEditing).toBe(false);
+        expect(result.current.localValue).toBe('hello');
+    });
+
+    it('syncs localValue when the external value prop changes', () => {
+        let externalValue = 'initial';
+        const {result, rerender} = renderHook(() => useInlineEditState<string>(true, externalValue));
+
+        expect(result.current.localValue).toBe('initial');
+
+        externalValue = 'updated';
+        rerender({});
+
+        expect(result.current.localValue).toBe('updated');
+    });
+
+    it('works with numeric values', () => {
+        const onSave = jest.fn();
+        const {result} = renderHook(() => useInlineEditState<number>(true, 42, onSave));
+
+        act(() => {
+            result.current.startEditing();
+        });
+        act(() => {
+            result.current.setLocalValue(99);
+        });
+        act(() => {
+            result.current.save();
+        });
+
+        expect(onSave).toHaveBeenCalledWith(99);
+        expect(result.current.isEditing).toBe(false);
+    });
+});