diff --git a/web/chat/chat-input-text-area.react.js b/web/chat/chat-input-text-area.react.js
index c9b672bcf..5e41c4a51 100644
--- a/web/chat/chat-input-text-area.react.js
+++ b/web/chat/chat-input-text-area.react.js
@@ -1,94 +1,98 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import css from './chat-input-bar.css';
 
 type Props = {
   +send?: () => mixed,
   +escape?: () => void,
   +focus: boolean,
   +currentText: string,
+  +setCurrentText: (text: string) => void,
 };
 
 const ChatInputTextArea: React.ComponentType<Props> = React.memo<Props>(
   function ChatInputTextArea(props: Props) {
-    const { currentText, focus, escape, send } = props;
+    const { currentText, focus, escape, send, setCurrentText } = props;
     const textareaRef = React.useRef(null);
 
     const focusAndUpdateText = React.useCallback(() => {
       if (!focus) {
         return;
       }
 
       // We need to call focus() first on Safari, otherwise the cursor
       // ends up at the start instead of the end for some reason
       const textarea = textareaRef.current;
       invariant(textarea, 'textarea should be set');
       textarea.focus();
 
       // We reset the textarea to an empty string at the start so that
       // the cursor always ends up at the end, even if the text doesn't
       // actually change
       textarea.value = '';
       if (currentText) {
         textarea.value = currentText;
       }
       // The above strategies make sure the cursor is at the end,
       // but we also need to make sure that we're scrolled to the bottom
       textarea.scrollTop = textarea.scrollHeight;
     }, [currentText, focus]);
 
     const updateHeight = React.useCallback(() => {
       const textarea = textareaRef.current;
       if (textarea) {
         textarea.style.height = 'auto';
         const newHeight = Math.min(textarea.scrollHeight, 150);
         textarea.style.height = `${newHeight}px`;
       }
     }, []);
 
     React.useEffect(() => {
       updateHeight();
       focusAndUpdateText();
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [currentText]);
 
     const onKeyDown = (event: SyntheticKeyboardEvent<HTMLTextAreaElement>) => {
       if (event.key === 'Escape') {
         event.preventDefault();
         if (!escape) {
           return;
         }
         escape();
       } else if (event.key === 'Enter' && !event.shiftKey) {
         event.preventDefault();
         if (!send) {
           return;
         }
         send();
       }
     };
 
-    const onChangeMessageText = () => {
+    const onChangeMessageText = (
+      event: SyntheticEvent<HTMLTextAreaElement>,
+    ) => {
+      setCurrentText(event.currentTarget.value);
       updateHeight();
     };
 
     return (
       <div className={css.inputBarTextInput}>
         <textarea
           rows="1"
           placeholder="Type your message"
           value={currentText}
           onChange={onChangeMessageText}
           onKeyDown={onKeyDown}
           ref={textareaRef}
           autoFocus
         />
       </div>
     );
   },
 );
 
 export default ChatInputTextArea;
diff --git a/web/chat/edit-message-provider.js b/web/chat/edit-message-provider.js
index f6d21a318..139d9e7f9 100644
--- a/web/chat/edit-message-provider.js
+++ b/web/chat/edit-message-provider.js
@@ -1,81 +1,97 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import ModalOverlay from 'lib/components/modal-overlay.react.js';
 import type { ChatMessageInfoItem } from 'lib/selectors/chat-selectors.js';
 import type { ThreadInfo } from 'lib/types/thread-types';
 
 export type EditState = {
   +messageInfo: ChatMessageInfoItem,
   +threadInfo: ThreadInfo,
   +editedMessageDraft: ?string,
   +isError: boolean,
 };
 
 type EditModalContextType = {
   +renderEditModal: (params: EditState) => void,
   +clearEditModal: () => void,
   +editState: ?EditState,
+  +setDraft: string => void,
 };
 
 const EditModalContext: React.Context<EditModalContextType> =
   React.createContext<EditModalContextType>({
     renderEditModal: () => {},
     clearEditModal: () => {},
     editState: null,
+    setDraft: () => {},
   });
 
 type Props = {
   +children: React.Node,
 };
 function EditModalProvider(props: Props): React.Node {
   const { children } = props;
 
   const [editState, setEditState] = React.useState<?EditState>(null);
 
   const clearEditModal = React.useCallback(() => {
     setEditState(null);
   }, []);
 
   const renderEditModal = React.useCallback((newEditState: EditState): void => {
     setEditState(newEditState);
   }, []);
 
   const modal = React.useMemo(() => {
     // TODO: Add modal
     return null;
   }, []);
 
+  const setDraft = React.useCallback(
+    (draft: ?string) => {
+      if (!editState) {
+        return;
+      }
+      setEditState({
+        ...editState,
+        editedMessageDraft: draft,
+      });
+    },
+    [editState, setEditState],
+  );
+
   const value = React.useMemo(
     () => ({
       renderEditModal,
       clearEditModal: clearEditModal,
       editState,
+      setDraft,
     }),
-    [renderEditModal, clearEditModal, editState],
+    [renderEditModal, clearEditModal, editState, setDraft],
   );
 
   const modalOverlay = React.useMemo(() => {
     if (!modal) {
       return null;
     }
     return <ModalOverlay onClose={clearEditModal}>{modal}</ModalOverlay>;
   }, [clearEditModal, modal]);
 
   return (
     <EditModalContext.Provider value={value}>
       {children}
       {modalOverlay}
     </EditModalContext.Provider>
   );
 }
 
 function useEditModalContext(): EditModalContextType {
   const context = React.useContext(EditModalContext);
   invariant(context, 'EditModalContext not found');
   return context;
 }
 
 export { EditModalProvider, useEditModalContext };
diff --git a/web/chat/edit-text-message.react.js b/web/chat/edit-text-message.react.js
index acdbce082..765c35fc6 100644
--- a/web/chat/edit-text-message.react.js
+++ b/web/chat/edit-text-message.react.js
@@ -1,102 +1,103 @@
 // @flow
 
 import classNames from 'classnames';
 import * as React from 'react';
 import { XCircle as XCircleIcon } from 'react-feather';
 
 import type { ChatMessageInfoItem } from 'lib/selectors/chat-selectors.js';
 import { type ThreadInfo } from 'lib/types/thread-types.js';
 
 import cssInputBar from './chat-input-bar.css';
 import ChatInputTextArea from './chat-input-text-area.react.js';
 import ComposedMessage from './composed-message.react.js';
 import { useEditModalContext } from './edit-message-provider.js';
 import css from './edit-text-message.css';
 import type { ButtonColor } from '../components/button.react.js';
 import Button from '../components/button.react.js';
 
 type Props = {
   +item: ChatMessageInfoItem,
   +threadInfo: ThreadInfo,
   +background: boolean,
 };
 
 const cancelButtonColor: ButtonColor = {
   backgroundColor: 'transparent',
 };
 
 function EditTextMessage(props: Props): React.Node {
   const { background, threadInfo } = props;
-  const { editState, clearEditModal } = useEditModalContext();
+  const { editState, clearEditModal, setDraft } = useEditModalContext();
 
   const editedMessageDraft = editState?.editedMessageDraft ?? '';
   const threadColor = threadInfo.color;
   const saveButtonColor: ButtonColor = React.useMemo(
     () => ({
       backgroundColor: `#${threadColor}`,
     }),
     [threadColor],
   );
   let editFailed;
   if (editState?.isError) {
     editFailed = (
       <div className={css.failedText}>
         <XCircleIcon className={css.icon} />
         <div className={css.errorColor}>Edit failed.</div>
         <div className={css.whiteColor}>Please try again.</div>
       </div>
     );
   }
 
   const containerStyle = classNames(css.editMessage, {
     [css.backgroundEditMessage]: background,
   });
 
   return (
     <div className={containerStyle}>
       <div className={cssInputBar.inputBarTextInput}>
         <ChatInputTextArea
           focus={!background}
           currentText={editedMessageDraft}
+          setCurrentText={setDraft}
         />
       </div>
       <div className={css.bottomRow}>
         {editFailed}
         <div className={css.buttons}>
           <Button
             className={[css.saveButton, css.smallButton]}
             variant="filled"
             buttonColor={saveButtonColor}
           >
             Save (enter)
           </Button>
           <Button
             className={css.smallButton}
             variant="filled"
             buttonColor={cancelButtonColor}
             onClick={clearEditModal}
           >
             Cancel (esc)
           </Button>
         </div>
       </div>
     </div>
   );
 }
 
 const ComposedEditTextMessage: React.ComponentType<Props> = React.memo<Props>(
   function ComposedEditTextMessage(props) {
     const { background, ...restProps } = props;
     return (
       <ComposedMessage
         {...restProps}
         sendFailed={false}
         shouldDisplayPinIndicator={false}
       >
         <EditTextMessage {...props} />
       </ComposedMessage>
     );
   },
 );
 
 export { EditTextMessage, ComposedEditTextMessage };