diff --git a/web/modals/threads/thread-settings-delete-tab.react.js b/web/modals/threads/thread-settings-delete-tab.react.js
index b2e744a31..818ce5796 100644
--- a/web/modals/threads/thread-settings-delete-tab.react.js
+++ b/web/modals/threads/thread-settings-delete-tab.react.js
@@ -1,109 +1,109 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   deleteThread,
 } from 'lib/actions/thread-actions';
 import { type SetState } from 'lib/types/hook-types.js';
 import { type ThreadInfo } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
 import Button from '../../components/button.react.js';
 import { useModalContext } from '../modal-provider.react.js';
 import css from './thread-settings-modal.css';
 
 type ThreadSettingsDeleteTabProps = {
   +inputDisabled: boolean,
   +threadInfo: ThreadInfo,
   +setErrorMessage: SetState<string>,
 };
 
 function ThreadSettingsDeleteTab(
   props: ThreadSettingsDeleteTabProps,
 ): React.Node {
   const { inputDisabled, threadInfo, setErrorMessage } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callDeleteThread = useServerCall(deleteThread);
 
   const accountPasswordInputRef = React.useRef();
   const [accountPassword, setAccountPassword] = React.useState('');
 
   const onChangeAccountPassword = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       const target = event.currentTarget;
       setAccountPassword(target.value);
     },
     [],
   );
 
   const deleteThreadAction = React.useCallback(async () => {
     try {
       const response = await callDeleteThread(threadInfo.id, accountPassword);
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage(
         e.message === 'invalid_credentials'
           ? 'wrong password'
           : 'unknown error',
       );
       setAccountPassword('');
       accountPasswordInputRef.current?.focus();
       throw e;
     }
   }, [
     accountPassword,
     callDeleteThread,
     modalContext,
     setAccountPassword,
     setErrorMessage,
     threadInfo.id,
   ]);
 
   const onDelete = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       dispatchActionPromise(deleteThreadActionTypes, deleteThreadAction());
     },
     [deleteThreadAction, dispatchActionPromise],
   );
 
   return (
-    <>
+    <form method="POST">
       <div>
         <p className={css.italic}>
           Your thread will be permanently deleted. There is no way to reverse
           this.
         </p>
       </div>
       <div className={css.edit_thread_account_password}>
         <p className={css.confirm_account_password}>
           Please enter your account password to confirm your identity
         </p>
         <div className={css.form_title}>Account password</div>
         <div className={css.form_content}>
           <input
             type="password"
             placeholder="Personal account password"
             value={accountPassword}
             onChange={onChangeAccountPassword}
             disabled={inputDisabled}
             ref={accountPasswordInputRef}
           />
         </div>
       </div>
       <Button onClick={onDelete} variant="danger" disabled={inputDisabled}>
         Delete
       </Button>
-    </>
+    </form>
   );
 }
 
 export default ThreadSettingsDeleteTab;
diff --git a/web/modals/threads/thread-settings-general-tab.react.js b/web/modals/threads/thread-settings-general-tab.react.js
index 569dae923..4a9babf56 100644
--- a/web/modals/threads/thread-settings-general-tab.react.js
+++ b/web/modals/threads/thread-settings-general-tab.react.js
@@ -1,177 +1,177 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } from 'lib/actions/thread-actions';
 import { type SetState } from 'lib/types/hook-types.js';
 import { type ThreadInfo, type ThreadChanges } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 import { firstLine } from 'lib/utils/string-utils';
 
 import Button from '../../components/button.react';
 import Input from '../input.react.js';
 import { useModalContext } from '../modal-provider.react.js';
 import ColorSelector from './color-selector.react.js';
 import css from './thread-settings-general-tab.css';
 
 type ThreadSettingsGeneralTabProps = {
   +inputDisabled: boolean,
   +threadInfo: ThreadInfo,
   +threadNamePlaceholder: string,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<string>,
 };
 function ThreadSettingsGeneralTab(
   props: ThreadSettingsGeneralTabProps,
 ): React.Node {
   const {
     inputDisabled,
     threadInfo,
     threadNamePlaceholder,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
   } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useServerCall(changeThreadSettings);
 
   const nameInputRef = React.useRef();
 
   React.useEffect(() => {
     nameInputRef.current?.focus();
   }, [inputDisabled]);
 
   const changeQueued: boolean = React.useMemo(
     () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
     [queuedChanges],
   );
 
   const onChangeName = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           name: firstLine(
             target.value !== threadInfo.name ? target.value : undefined,
           ),
         }),
       );
     },
     [setQueuedChanges, threadInfo.name],
   );
 
   const onChangeDescription = React.useCallback(
     (event: SyntheticEvent<HTMLTextAreaElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           description:
             target.value !== threadInfo.description ? target.value : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.description],
   );
 
   const onChangeColor = React.useCallback(
     (color: string) => {
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           color: color !== threadInfo.color ? color : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.color],
   );
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       const response = await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage('unknown_error');
       setQueuedChanges(Object.freeze({}));
       throw e;
     }
   }, [
     callChangeThreadSettings,
     modalContext,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   return (
-    <div>
+    <form method="POST">
       <div>
         <div className={css.form_title}>Thread name</div>
         <div className={css.form_content}>
           <Input
             type="text"
             value={firstLine(queuedChanges.name ?? threadInfo.name)}
             placeholder={threadNamePlaceholder}
             onChange={onChangeName}
             disabled={inputDisabled}
             ref={nameInputRef}
           />
         </div>
       </div>
       <div className={css.form_textarea_container}>
         <div className={css.form_title}>Description</div>
         <div className={css.form_content}>
           <textarea
             value={queuedChanges.description ?? threadInfo.description ?? ''}
             placeholder="Thread description"
             onChange={onChangeDescription}
             disabled={inputDisabled}
           />
         </div>
       </div>
       <div className={css.edit_thread_color_container}>
         <div className={`${css.form_title} ${css.color_title}`}>Color</div>
         <ColorSelector
           currentColor={queuedChanges.color ?? threadInfo.color}
           onColorSelection={onChangeColor}
         />
       </div>
       <Button
         type="submit"
         onClick={onSubmit}
         disabled={inputDisabled || !changeQueued}
         className={css.save_button}
       >
         Save
       </Button>
-    </div>
+    </form>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/thread-settings-modal.react.js b/web/modals/threads/thread-settings-modal.react.js
index 092d55fc1..1367ca997 100644
--- a/web/modals/threads/thread-settings-modal.react.js
+++ b/web/modals/threads/thread-settings-modal.react.js
@@ -1,183 +1,178 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { threadHasPermission, robotextName } from 'lib/shared/thread-utils';
 import {
   type ThreadInfo,
   threadTypes,
   threadPermissions,
   type ThreadChanges,
 } from 'lib/types/thread-types';
 
 import Tabs from '../../components/tabs.react';
 import { useModalContext } from '../../modals/modal-provider.react';
 import { useSelector } from '../../redux/redux-utils';
 import Modal from '../modal.react';
 import ThreadSettingsDeleteTab from './thread-settings-delete-tab.react';
 import ThreadSettingsGeneralTab from './thread-settings-general-tab.react';
 import css from './thread-settings-modal.css';
 import ThreadSettingsPrivacyTab from './thread-settings-privacy-tab.react';
 
 type TabType = 'general' | 'privacy' | 'delete';
 type BaseProps = {
   +threadID: string,
 };
 
 const deleteThreadLoadingStatusSelector = createLoadingStatusSelector(
   deleteThreadActionTypes,
 );
 const changeThreadSettingsLoadingStatusSelector = createLoadingStatusSelector(
   changeThreadSettingsActionTypes,
 );
 
 const ConnectedThreadSettingsModal: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadSettingsModal(props) {
     const changeInProgress = useSelector(
       state =>
         deleteThreadLoadingStatusSelector(state) === 'loading' ||
         changeThreadSettingsLoadingStatusSelector(state) === 'loading',
     );
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const userInfos = useSelector(state => state.userStore.userInfos);
     const threadInfo: ?ThreadInfo = useSelector(
       state => threadInfoSelector(state)[props.threadID],
     );
     const modalContext = useModalContext();
     const [errorMessage, setErrorMessage] = React.useState('');
     const [currentTabType, setCurrentTabType] = React.useState<TabType>(
       'general',
     );
     const [queuedChanges, setQueuedChanges] = React.useState<ThreadChanges>(
       Object.freeze({}),
     );
 
     const namePlaceholder: string = React.useMemo(() => {
       invariant(threadInfo, 'threadInfo should exist in namePlaceholder');
       return robotextName(threadInfo, viewerID, userInfos);
     }, [threadInfo, userInfos, viewerID]);
 
     const hasPermissionForTab = React.useCallback(
       (thread: ThreadInfo, tab: TabType) => {
         if (tab === 'general') {
           return threadHasPermission(
             thread,
             threadPermissions.EDIT_THREAD_NAME,
           );
         } else if (tab === 'privacy') {
           return threadHasPermission(
             thread,
             threadPermissions.EDIT_PERMISSIONS,
           );
         } else if (tab === 'delete') {
           return threadHasPermission(thread, threadPermissions.DELETE_THREAD);
         }
         invariant(false, `invalid tab: ${tab}`);
       },
       [],
     );
 
     React.useEffect(() => {
       if (
         threadInfo &&
         currentTabType !== 'general' &&
         !hasPermissionForTab(threadInfo, currentTabType)
       ) {
         setCurrentTabType('general');
       }
     }, [currentTabType, hasPermissionForTab, threadInfo]);
 
     if (!threadInfo) {
       return (
         <Modal onClose={modalContext.popModal} name="Invalid thread">
           <div className={css.modal_body}>
             <p>You no longer have permission to view this thread</p>
           </div>
         </Modal>
       );
     }
 
     const inputDisabled =
       changeInProgress || !hasPermissionForTab(threadInfo, currentTabType);
 
     const tabs = [
       <Tabs.Item id="general" header="General" key="general">
         <ThreadSettingsGeneralTab
           inputDisabled={inputDisabled}
           threadInfo={threadInfo}
           threadNamePlaceholder={namePlaceholder}
           queuedChanges={queuedChanges}
           setQueuedChanges={setQueuedChanges}
           setErrorMessage={setErrorMessage}
         />
       </Tabs.Item>,
     ];
 
     // This UI needs to be updated to handle sidebars but we haven't gotten
     // there yet. We'll probably end up ripping it out anyways, so for now we
     // are just hiding the privacy tab for any thread that was created as a
     // sidebar
     const canSeePrivacyTab =
       (queuedChanges['parentThreadID'] ?? threadInfo['parentThreadID']) &&
       threadInfo.sourceMessageID &&
       (threadInfo.type === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
         threadInfo.type === threadTypes.COMMUNITY_SECRET_SUBTHREAD);
     if (canSeePrivacyTab) {
       tabs.push(
         <Tabs.Item id="privacy" header="Privacy" key="privacy">
           <ThreadSettingsPrivacyTab
             inputDisabled={inputDisabled}
             threadInfo={threadInfo}
             queuedChanges={queuedChanges}
             setQueuedChanges={setQueuedChanges}
             setErrorMessage={setErrorMessage}
           />
         </Tabs.Item>,
       );
     }
 
     const canDeleteThread = hasPermissionForTab(threadInfo, 'delete');
     if (canDeleteThread) {
       tabs.push(
         <Tabs.Item id="delete" header="Delete" key="delete">
           <ThreadSettingsDeleteTab
             inputDisabled={inputDisabled}
             threadInfo={threadInfo}
             setErrorMessage={setErrorMessage}
           />
         </Tabs.Item>,
       );
     }
 
     return (
       <Modal
         name="Thread settings"
         onClose={modalContext.popModal}
         icon="settings"
       >
         <div className={css.modal_body}>
-          <form method="POST">
-            <Tabs.Container
-              activeTab={currentTabType}
-              setTab={setCurrentTabType}
-            >
-              {tabs}
-            </Tabs.Container>
-            <div className={css.modal_form_error}>{errorMessage}</div>
-          </form>
+          <Tabs.Container activeTab={currentTabType} setTab={setCurrentTabType}>
+            {tabs}
+          </Tabs.Container>
+          <div className={css.modal_form_error}>{errorMessage}</div>
         </div>
       </Modal>
     );
   },
 );
 
 export default ConnectedThreadSettingsModal;
diff --git a/web/modals/threads/thread-settings-privacy-tab.react.js b/web/modals/threads/thread-settings-privacy-tab.react.js
index 727de6b09..d95e99e7a 100644
--- a/web/modals/threads/thread-settings-privacy-tab.react.js
+++ b/web/modals/threads/thread-settings-privacy-tab.react.js
@@ -1,164 +1,166 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { threadTypeDescriptions } from 'lib/shared/thread-utils';
 import { type SetState } from 'lib/types/hook-types';
 import {
   type ThreadInfo,
   type ThreadChanges,
   assertThreadType,
   threadTypes,
 } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import Button from '../../components/button.react.js';
 import { useModalContext } from '../modal-provider.react.js';
 import css from './thread-settings-privacy-tab.css';
 
 const { COMMUNITY_OPEN_SUBTHREAD, COMMUNITY_SECRET_SUBTHREAD } = threadTypes;
 
 type ThreadSettingsPrivacyTabProps = {
   +inputDisabled: boolean,
   +threadInfo: ThreadInfo,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<string>,
 };
 function ThreadSettingsPrivacyTab(
   props: ThreadSettingsPrivacyTabProps,
 ): React.Node {
   const {
     inputDisabled,
     threadInfo,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
   } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useServerCall(changeThreadSettings);
 
   const changeQueued: boolean = React.useMemo(
     () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
     [queuedChanges],
   );
 
   const onChangeThreadType = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       const uiValue = assertThreadType(parseInt(event.currentTarget.value, 10));
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           type: uiValue !== threadInfo.type ? uiValue : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.type],
   );
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       const response = await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage('unknown_error');
       setQueuedChanges(Object.freeze({}));
       throw e;
     }
   }, [
     callChangeThreadSettings,
     modalContext,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   return (
-    <div className={css.edit_thread_privacy_container}>
-      <div className={css['modal-radio-selector']}>
-        <div className={css.form_title}>Thread type</div>
-        <div className={css.form_enum_selector}>
-          <div className={css.form_enum_container}>
-            <input
-              type="radio"
-              name="edit-thread-type"
-              id="edit-thread-open"
-              value={COMMUNITY_OPEN_SUBTHREAD}
-              checked={
-                (queuedChanges.type ?? threadInfo.type) ===
-                COMMUNITY_OPEN_SUBTHREAD
-              }
-              onChange={onChangeThreadType}
-              disabled={inputDisabled}
-            />
-            <div className={css.form_enum_option}>
-              <label htmlFor="edit-thread-open">
-                Open
-                <span className={css.form_enum_description}>
-                  {threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD]}
-                </span>
-              </label>
+    <form method="POST">
+      <div className={css.edit_thread_privacy_container}>
+        <div className={css['modal-radio-selector']}>
+          <div className={css.form_title}>Thread type</div>
+          <div className={css.form_enum_selector}>
+            <div className={css.form_enum_container}>
+              <input
+                type="radio"
+                name="edit-thread-type"
+                id="edit-thread-open"
+                value={COMMUNITY_OPEN_SUBTHREAD}
+                checked={
+                  (queuedChanges.type ?? threadInfo.type) ===
+                  COMMUNITY_OPEN_SUBTHREAD
+                }
+                onChange={onChangeThreadType}
+                disabled={inputDisabled}
+              />
+              <div className={css.form_enum_option}>
+                <label htmlFor="edit-thread-open">
+                  Open
+                  <span className={css.form_enum_description}>
+                    {threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD]}
+                  </span>
+                </label>
+              </div>
             </div>
-          </div>
-          <div className={css.form_enum_container}>
-            <input
-              type="radio"
-              name="edit-thread-type"
-              id="edit-thread-closed"
-              value={COMMUNITY_SECRET_SUBTHREAD}
-              checked={
-                (queuedChanges.type ?? threadInfo.type) ===
-                COMMUNITY_SECRET_SUBTHREAD
-              }
-              onChange={onChangeThreadType}
-              disabled={inputDisabled}
-            />
-            <div className={css.form_enum_option}>
-              <label htmlFor="edit-thread-closed">
-                Secret
-                <span className={css.form_enum_description}>
-                  {threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD]}
-                </span>
-              </label>
+            <div className={css.form_enum_container}>
+              <input
+                type="radio"
+                name="edit-thread-type"
+                id="edit-thread-closed"
+                value={COMMUNITY_SECRET_SUBTHREAD}
+                checked={
+                  (queuedChanges.type ?? threadInfo.type) ===
+                  COMMUNITY_SECRET_SUBTHREAD
+                }
+                onChange={onChangeThreadType}
+                disabled={inputDisabled}
+              />
+              <div className={css.form_enum_option}>
+                <label htmlFor="edit-thread-closed">
+                  Secret
+                  <span className={css.form_enum_description}>
+                    {threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD]}
+                  </span>
+                </label>
+              </div>
             </div>
           </div>
         </div>
+        <Button
+          type="submit"
+          onClick={onSubmit}
+          disabled={inputDisabled || !changeQueued}
+          className={css.save_button}
+        >
+          Save
+        </Button>
       </div>
-      <Button
-        type="submit"
-        onClick={onSubmit}
-        disabled={inputDisabled || !changeQueued}
-        className={css.save_button}
-      >
-        Save
-      </Button>
-    </div>
+    </form>
   );
 }
 
 export default ThreadSettingsPrivacyTab;