diff --git a/web/modals/threads/settings/thread-settings-general-tab.react.js b/web/modals/threads/settings/thread-settings-general-tab.react.js
index 51c1d938b..9a047a062 100644
--- a/web/modals/threads/settings/thread-settings-general-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-general-tab.react.js
@@ -1,168 +1,134 @@
 // @flow
 
 import * as React from 'react';
 import tinycolor from 'tinycolor2';
 
 import { threadHasPermission } from 'lib/shared/thread-utils.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { type ThreadChanges } from 'lib/types/thread-types.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 import { chatNameMaxLength } from 'lib/utils/validation-utils.js';
 
-import SubmitSection from './submit-section.react.js';
 import css from './thread-settings-general-tab.css';
-import { useOnSaveGeneralThreadSettings } from './thread-settings-utils.js';
 import EditThreadAvatar from '../../../avatars/edit-thread-avatar.react.js';
-import LoadingIndicator from '../../../loading-indicator.react.js';
 import Input from '../../input.react.js';
 import ColorSelector from '../color-selector.react.js';
 
 type ThreadSettingsGeneralTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +threadNamePlaceholder: string,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
-  +setErrorMessage: SetState<?string>,
-  +errorMessage?: ?string,
 };
 function ThreadSettingsGeneralTab(
   props: ThreadSettingsGeneralTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     threadNamePlaceholder,
     queuedChanges,
     setQueuedChanges,
-    setErrorMessage,
-    errorMessage,
   } = props;
 
   const nameInputRef = React.useRef<?HTMLInputElement>();
 
   React.useEffect(() => {
     nameInputRef.current?.focus();
   }, [threadSettingsOperationInProgress]);
 
-  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;
       const newName = firstLine(target.value);
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           name: newName !== threadInfo.name ? newName : 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: !tinycolor.equals(color, threadInfo.color) ? color : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.color],
   );
 
-  const onSaveGeneralThreadSettings = useOnSaveGeneralThreadSettings({
-    threadInfo,
-    queuedChanges,
-    setQueuedChanges,
-    setErrorMessage,
-  });
-
   const threadNameInputDisabled = !threadHasPermission(
     threadInfo,
     threadPermissions.EDIT_THREAD_NAME,
   );
 
-  const saveButtonContent = React.useMemo(() => {
-    if (threadSettingsOperationInProgress) {
-      return <LoadingIndicator status="loading" />;
-    }
-    return 'Save';
-  }, [threadSettingsOperationInProgress]);
-
   return (
-    <form method="POST" className={css.container}>
+    <div className={css.container}>
       <div>
         <div className={css.editAvatarContainer}>
           <EditThreadAvatar threadInfo={threadInfo} />
         </div>
         <div className={css.form_title}>Chat name</div>
         <div className={css.form_content}>
           <Input
             type="text"
             maxLength={chatNameMaxLength}
             value={firstLine(queuedChanges.name ?? threadInfo.name)}
             placeholder={threadNamePlaceholder}
             onChange={onChangeName}
             disabled={
               threadSettingsOperationInProgress || threadNameInputDisabled
             }
             ref={nameInputRef}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Description</div>
         <div className={css.form_content}>
           <textarea
             value={queuedChanges.description ?? threadInfo.description ?? ''}
             placeholder="Chat description"
             onChange={onChangeDescription}
             disabled={threadSettingsOperationInProgress}
             rows={3}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Color</div>
         <div className={css.colorSelectorContainer}>
           <ColorSelector
             currentColor={queuedChanges.color ?? threadInfo.color}
             onColorSelection={onChangeColor}
           />
         </div>
       </div>
-      <SubmitSection
-        variant="filled"
-        errorMessage={errorMessage}
-        onClick={onSaveGeneralThreadSettings}
-        disabled={threadSettingsOperationInProgress || !changeQueued}
-      >
-        {saveButtonContent}
-      </SubmitSection>
-    </form>
+    </div>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/settings/thread-settings-modal.react.js b/web/modals/threads/settings/thread-settings-modal.react.js
index 713fc8ffd..76fcbf836 100644
--- a/web/modals/threads/settings/thread-settings-modal.react.js
+++ b/web/modals/threads/settings/thread-settings-modal.react.js
@@ -1,283 +1,292 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { getAvailableRelationshipButtons } from 'lib/shared/relationship-utils.js';
 import {
   getSingleOtherUser,
   threadHasPermission,
   threadUIName,
 } from 'lib/shared/thread-utils.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import type { RelationshipButton } from 'lib/types/relationship-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { type ThreadChanges } from 'lib/types/thread-types.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import ThreadSettingsDeleteButton from './thread-settings-delete-button.react.js';
 import ThreadSettingsDeleteTab from './thread-settings-delete-tab.react.js';
 import ThreadSettingsGeneralTab from './thread-settings-general-tab.react.js';
 import css from './thread-settings-modal.css';
 import ThreadSettingsPrivacyTab from './thread-settings-privacy-tab.react.js';
 import ThreadSettingsRelationshipTab from './thread-settings-relationship-tab.react.js';
+import ThreadSettingsSaveButton from './thread-settings-save-button.react.js';
 import Tabs, { type TabData } from '../../../components/tabs.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 import Modal from '../../modal.react.js';
 
 type TabType = 'general' | 'privacy' | 'delete' | 'relationship';
 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 threadInfo: ?ThreadInfo = useSelector(
       state => threadInfoSelector(state)[props.threadID],
     );
     const modalContext = useModalContext();
+    // eslint-disable-next-line no-unused-vars
     const [errorMessage, setErrorMessage] = React.useState<?string>('');
     const [currentTabType, setCurrentTabType] =
       React.useState<TabType>('general');
     const [queuedChanges, setQueuedChanges] = React.useState<ThreadChanges>(
       Object.freeze({}),
     );
 
     const threadInfoWithNoName = React.useMemo(() => {
       invariant(threadInfo, 'threadInfo should exist in threadInfoWithNoName');
       if (threadInfo.name === null || threadInfo.name === undefined) {
         return threadInfo;
       }
       const withNoName = { ...threadInfo, name: undefined };
       return {
         ...withNoName,
         uiName: threadUIName(withNoName),
       };
     }, [threadInfo]);
     const resolvedThreadInfo = useResolvedThreadInfo(threadInfoWithNoName);
     const namePlaceholder = resolvedThreadInfo.uiName;
 
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const userInfos = useSelector(state => state.userStore.userInfos);
     const otherMemberID = React.useMemo(() => {
       if (!threadInfo) {
         return null;
       }
       return getSingleOtherUser(threadInfo, viewerID);
     }, [threadInfo, viewerID]);
     const otherUserInfo = otherMemberID ? userInfos[otherMemberID] : null;
 
     const availableRelationshipActions = React.useMemo(() => {
       if (!otherUserInfo) {
         return ([]: RelationshipButton[]);
       }
       return getAvailableRelationshipButtons(otherUserInfo);
     }, [otherUserInfo]);
 
     const hasPermissionForTab = React.useCallback(
       // ESLint doesn't recognize that invariant always throws
       // eslint-disable-next-line consistent-return
       (thread: ThreadInfo, tab: TabType) => {
         if (tab === 'general') {
           return (
             threadHasPermission(thread, threadPermissions.EDIT_THREAD_NAME) ||
             threadHasPermission(thread, threadPermissions.EDIT_THREAD_COLOR) ||
             threadHasPermission(
               thread,
               threadPermissions.EDIT_THREAD_DESCRIPTION,
             )
           );
         } else if (tab === 'privacy') {
           return threadHasPermission(
             thread,
             threadPermissions.EDIT_PERMISSIONS,
           );
         } else if (tab === 'delete') {
           return threadHasPermission(thread, threadPermissions.DELETE_THREAD);
         } else if (tab === 'relationship') {
           return true;
         }
         invariant(false, `invalid tab: ${tab}`);
       },
       [],
     );
 
     React.useEffect(() => {
       if (
         threadInfo &&
         currentTabType !== 'general' &&
         !hasPermissionForTab(threadInfo, currentTabType)
       ) {
         setCurrentTabType('general');
       }
     }, [currentTabType, hasPermissionForTab, threadInfo]);
 
     React.useEffect(() => () => setErrorMessage(''), [currentTabType]);
 
     const tabsData: $ReadOnlyArray<TabData<TabType>> = React.useMemo(() => {
       if (!threadInfo) {
         return [];
       }
 
       const result = [{ id: 'general', header: 'General' }];
 
       // 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) {
         result.push({ id: 'privacy', header: 'Privacy' });
       }
 
       if (availableRelationshipActions.length > 0 && otherUserInfo) {
         result.push({ id: 'relationship', header: 'Relationship' });
       }
 
       if (hasPermissionForTab(threadInfo, 'delete')) {
         result.push({ id: 'delete', header: 'Delete' });
       }
 
       return result;
     }, [
       availableRelationshipActions.length,
       hasPermissionForTab,
       otherUserInfo,
       queuedChanges,
       threadInfo,
     ]);
 
     const tabs = React.useMemo(
       () => (
         <Tabs
           tabItems={tabsData}
           activeTab={currentTabType}
           setTab={setCurrentTabType}
         />
       ),
       [currentTabType, tabsData],
     );
 
     const tabContent = React.useMemo(() => {
       if (!threadInfo) {
         return null;
       }
       if (currentTabType === 'general') {
         return (
           <ThreadSettingsGeneralTab
             threadSettingsOperationInProgress={changeInProgress}
             threadInfo={threadInfo}
             threadNamePlaceholder={namePlaceholder}
             queuedChanges={queuedChanges}
             setQueuedChanges={setQueuedChanges}
-            setErrorMessage={setErrorMessage}
-            errorMessage={errorMessage}
           />
         );
       }
       if (currentTabType === 'privacy') {
         return (
           <ThreadSettingsPrivacyTab
-            threadSettingsOperationInProgress={changeInProgress}
             threadInfo={threadInfo}
             queuedChanges={queuedChanges}
             setQueuedChanges={setQueuedChanges}
-            setErrorMessage={setErrorMessage}
-            errorMessage={errorMessage}
           />
         );
       }
       if (currentTabType === 'relationship') {
         invariant(otherUserInfo, 'otherUserInfo should be set');
         return (
           <ThreadSettingsRelationshipTab
             setErrorMessage={setErrorMessage}
             relationshipButtons={availableRelationshipActions}
             otherUserInfo={otherUserInfo}
           />
         );
       }
       return <ThreadSettingsDeleteTab />;
     }, [
       availableRelationshipActions,
       changeInProgress,
       currentTabType,
-      errorMessage,
       namePlaceholder,
       otherUserInfo,
       queuedChanges,
       threadInfo,
     ]);
 
     const primaryButton = React.useMemo(() => {
       if (!threadInfo) {
         return null;
       }
 
+      if (currentTabType === 'general' || currentTabType === 'privacy') {
+        return (
+          <ThreadSettingsSaveButton
+            activeTab={currentTabType}
+            threadInfo={threadInfo}
+            queuedChanges={queuedChanges}
+            setQueuedChanges={setQueuedChanges}
+            setErrorMessage={setErrorMessage}
+            threadSettingsOperationInProgress={changeInProgress}
+          />
+        );
+      }
+
       if (currentTabType === 'relationship') {
         return <div className={css.relationshipPrimaryButtonPlaceholder} />;
       }
 
       return (
         <ThreadSettingsDeleteButton
           threadInfo={threadInfo}
           threadSettingsOperationInProgress={changeInProgress}
           setErrorMessage={setErrorMessage}
         />
       );
-    }, [changeInProgress, currentTabType, threadInfo]);
+    }, [changeInProgress, currentTabType, queuedChanges, threadInfo]);
 
     if (!threadInfo) {
       return (
         <Modal onClose={modalContext.popModal} name="Invalid chat">
           <div className={css.modal_body}>
             <p>You no longer have permission to view this chat</p>
           </div>
         </Modal>
       );
     }
 
     return (
       <Modal
         name="Chat settings"
         onClose={modalContext.popModal}
         icon="settings"
         size="fit-content"
         subheader={tabs}
         primaryButton={primaryButton}
       >
         <div className={css.modal_body}>
           <div className={css.tab_body}>{tabContent}</div>
         </div>
       </Modal>
     );
   });
 
 export default ConnectedThreadSettingsModal;
diff --git a/web/modals/threads/settings/thread-settings-privacy-tab.css b/web/modals/threads/settings/thread-settings-privacy-tab.css
index b300100d7..cc0dbc82c 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.css
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.css
@@ -1,15 +1,16 @@
 div.form_title {
   padding-top: 6px;
   font-size: var(--s-font-14);
   font-weight: 600;
 }
 
 div.enum_container {
   padding: 12px 0;
 }
 
-form.container {
+div.container {
   display: flex;
   flex-direction: column;
   flex: 1;
+  color: var(--text-background-primary-default);
 }
diff --git a/web/modals/threads/settings/thread-settings-privacy-tab.react.js b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
index 6882029a4..ab3e447be 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
@@ -1,138 +1,105 @@
 // @flow
 
 import * as React from 'react';
 
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { threadTypeDescriptions } from 'lib/shared/thread-utils.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { type ThreadChanges } from 'lib/types/thread-types.js';
 
-import SubmitSection from './submit-section.react.js';
 import css from './thread-settings-privacy-tab.css';
-import { useOnSavePrivacyThreadSettings } from './thread-settings-utils.js';
 import EnumSettingsOption from '../../../components/enum-settings-option.react.js';
 
 const { COMMUNITY_OPEN_SUBTHREAD, COMMUNITY_SECRET_SUBTHREAD } = threadTypes;
 
 const openStatements = [
   {
     statement: threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD],
     isStatementValid: true,
     styleStatementBasedOnValidity: false,
   },
 ];
 
 const secretStatements = [
   {
     statement: threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD],
     isStatementValid: true,
     styleStatementBasedOnValidity: false,
   },
 ];
 
 type ThreadSettingsPrivacyTabProps = {
-  +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
-  +setErrorMessage: SetState<?string>,
-  +errorMessage?: ?string,
 };
 function ThreadSettingsPrivacyTab(
   props: ThreadSettingsPrivacyTabProps,
 ): React.Node {
-  const {
-    threadSettingsOperationInProgress,
-    threadInfo,
-    queuedChanges,
-    setQueuedChanges,
-    setErrorMessage,
-    errorMessage,
-  } = props;
-
-  const changeQueued: boolean = React.useMemo(
-    () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
-    [queuedChanges],
-  );
-
-  const onSavePrivacyThreadSettings = useOnSavePrivacyThreadSettings({
-    threadInfo,
-    queuedChanges,
-    setQueuedChanges,
-    setErrorMessage,
-  });
+  const { threadInfo, queuedChanges, setQueuedChanges } = props;
 
   const onOpenSelected = React.useCallback(() => {
     setQueuedChanges(prevQueuedChanges =>
       Object.freeze({
         ...prevQueuedChanges,
         type:
           COMMUNITY_OPEN_SUBTHREAD !== threadInfo.type
             ? COMMUNITY_OPEN_SUBTHREAD
             : undefined,
       }),
     );
   }, [setQueuedChanges, threadInfo.type]);
 
   const onSecretSelected = React.useCallback(() => {
     setQueuedChanges(prevQueuedChanges =>
       Object.freeze({
         ...prevQueuedChanges,
         type:
           COMMUNITY_SECRET_SUBTHREAD !== threadInfo.type
             ? COMMUNITY_SECRET_SUBTHREAD
             : undefined,
       }),
     );
   }, [setQueuedChanges, threadInfo.type]);
 
   const globeIcon = React.useMemo(
     () => <SWMansionIcon icon="globe-1" size={24} />,
     [],
   );
 
   const lockIcon = React.useMemo(
     () => <SWMansionIcon icon="lock-on" size={24} />,
     [],
   );
 
   return (
-    <form method="POST" className={css.container}>
+    <div className={css.container}>
       <div className={css.form_title}>Chat type</div>
       <div className={css.enum_container}>
         <EnumSettingsOption
           selected={
             (queuedChanges.type ?? threadInfo.type) === COMMUNITY_OPEN_SUBTHREAD
           }
           onSelect={onOpenSelected}
           icon={globeIcon}
           title="Open"
           statements={openStatements}
         />
         <EnumSettingsOption
           selected={
             (queuedChanges.type ?? threadInfo.type) ===
             COMMUNITY_SECRET_SUBTHREAD
           }
           onSelect={onSecretSelected}
           icon={lockIcon}
           title="Secret"
           statements={secretStatements}
         />
       </div>
-
-      <SubmitSection
-        variant="filled"
-        onClick={onSavePrivacyThreadSettings}
-        disabled={threadSettingsOperationInProgress || !changeQueued}
-        errorMessage={errorMessage}
-      >
-        Save
-      </SubmitSection>
-    </form>
+    </div>
   );
 }
 
 export default ThreadSettingsPrivacyTab;
diff --git a/web/modals/threads/settings/thread-settings-save-button.react.js b/web/modals/threads/settings/thread-settings-save-button.react.js
new file mode 100644
index 000000000..c0358d731
--- /dev/null
+++ b/web/modals/threads/settings/thread-settings-save-button.react.js
@@ -0,0 +1,79 @@
+// @flow
+
+import * as React from 'react';
+
+import type { SetState } from 'lib/types/hook-types.js';
+import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
+import type { ThreadChanges } from 'lib/types/thread-types.js';
+
+import {
+  useOnSaveGeneralThreadSettings,
+  useOnSavePrivacyThreadSettings,
+} from './thread-settings-utils.js';
+import Button from '../../../components/button.react.js';
+
+type Props = {
+  +activeTab: 'general' | 'privacy',
+  +threadInfo: ThreadInfo,
+  +queuedChanges: ThreadChanges,
+  +setQueuedChanges: SetState<ThreadChanges>,
+  +setErrorMessage: SetState<?string>,
+  +threadSettingsOperationInProgress: boolean,
+};
+
+function ThreadSettingsSaveButton(props: Props): React.Node {
+  const {
+    activeTab,
+    threadInfo,
+    queuedChanges,
+    setQueuedChanges,
+    setErrorMessage,
+    threadSettingsOperationInProgress,
+  } = props;
+
+  const onSaveGeneralThreadSettings = useOnSaveGeneralThreadSettings({
+    threadInfo,
+    queuedChanges,
+    setQueuedChanges,
+    setErrorMessage,
+  });
+
+  const onSavePrivacyThreadSettings = useOnSavePrivacyThreadSettings({
+    threadInfo,
+    queuedChanges,
+    setQueuedChanges,
+    setErrorMessage,
+  });
+
+  const changeQueued: boolean = React.useMemo(
+    () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
+    [queuedChanges],
+  );
+
+  const threadSettingsSaveButton = React.useMemo(
+    () => (
+      <Button
+        onClick={
+          activeTab === 'general'
+            ? onSaveGeneralThreadSettings
+            : onSavePrivacyThreadSettings
+        }
+        disabled={threadSettingsOperationInProgress || !changeQueued}
+        variant="filled"
+      >
+        Save
+      </Button>
+    ),
+    [
+      activeTab,
+      changeQueued,
+      onSaveGeneralThreadSettings,
+      onSavePrivacyThreadSettings,
+      threadSettingsOperationInProgress,
+    ],
+  );
+
+  return threadSettingsSaveButton;
+}
+
+export default ThreadSettingsSaveButton;