diff --git a/web/components/button.react.js b/web/components/button.react.js
index e6f0ad240..20d6e89d3 100644
--- a/web/components/button.react.js
+++ b/web/components/button.react.js
@@ -1,47 +1,47 @@
 // @flow
 
 import classnames from 'classnames';
 import * as React from 'react';
 
 import css from './button.css';
 
 export type ButtonVariant =
   | 'primary'
   | 'secondary'
   | 'success'
   | 'danger'
   | 'round';
 
-type Props = {
+export type ButtonProps = {
   +onClick: (event: SyntheticEvent<HTMLButtonElement>) => mixed,
   +children: React.Node,
   +variant?: ButtonVariant,
   +type?: string,
   +disabled?: boolean,
   +className?: string,
 };
 
-function Button(props: Props): React.Node {
+function Button(props: ButtonProps): React.Node {
   const {
     onClick,
     children,
     variant = 'primary',
     type,
     disabled = false,
     className = '',
   } = props;
   const btnCls = classnames(css.btn, css[variant]);
 
   return (
     <button
       type={type}
       className={`${btnCls} ${className}`}
       onClick={onClick}
       disabled={disabled}
     >
       {children}
     </button>
   );
 }
 
 export default Button;
diff --git a/web/modals/threads/settings/submit-section.css b/web/modals/threads/settings/submit-section.css
new file mode 100644
index 000000000..216c11ee0
--- /dev/null
+++ b/web/modals/threads/settings/submit-section.css
@@ -0,0 +1,22 @@
+.container {
+  height: 100%;
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.error {
+  text-align: center;
+  font-size: 16px;
+  color: var(--error);
+  font-style: italic;
+
+  margin-top: auto;
+  padding: 5px;
+}
+
+.button {
+  width: 100%;
+  align-self: flex-end;
+  min-height: 45px;
+}
diff --git a/web/modals/threads/settings/submit-section.react.js b/web/modals/threads/settings/submit-section.react.js
new file mode 100644
index 000000000..838ba1176
--- /dev/null
+++ b/web/modals/threads/settings/submit-section.react.js
@@ -0,0 +1,46 @@
+// @flow
+
+import classnames from 'classnames';
+import * as React from 'react';
+
+import type { ButtonProps } from '../../../components/button.react';
+import Button from '../../../components/button.react';
+import css from './submit-section.css';
+
+type Props = {
+  ...ButtonProps,
+  +errorMessage?: ?string,
+  +containerClassName?: string,
+};
+
+function SubmitSection(props: Props): React.Node {
+  const {
+    children,
+    containerClassName = '',
+    errorMessage,
+    onClick,
+    variant,
+    disabled = false,
+    className = '',
+  } = props;
+
+  const containerStyle = classnames(css.container, containerClassName);
+  const buttonStyle = classnames(css.button, className);
+
+  return (
+    <div className={containerStyle}>
+      <div className={css.error}>{errorMessage}</div>
+      <Button
+        type="submit"
+        className={buttonStyle}
+        onClick={onClick}
+        disabled={disabled}
+        variant={variant}
+      >
+        {children}
+      </Button>
+    </div>
+  );
+}
+
+export default SubmitSection;
diff --git a/web/modals/threads/settings/thread-settings-delete-tab.css b/web/modals/threads/settings/thread-settings-delete-tab.css
index a5fc533ee..42c1a1ea0 100644
--- a/web/modals/threads/settings/thread-settings-delete-tab.css
+++ b/web/modals/threads/settings/thread-settings-delete-tab.css
@@ -1,31 +1,33 @@
 p.confirm_account_password {
   margin-bottom: 4px;
   color: var(--fg);
   font-size: var(--s-font-14);
 }
 
 div.form_title {
   padding-top: 6px;
   font-size: var(--s-font-14);
   font-weight: 600;
   vertical-align: top;
   color: var(--fg);
 }
 div.form_content {
   display: flex;
   font-family: var(--font-stack);
   color: var(--fg);
   margin-top: 8px;
   margin-bottom: 12px;
 }
 
+form.container {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+}
+
 .deletion_warning {
   font-weight: var(--bold);
   color: var(--fg);
   font-size: var(--s-font-14);
   margin-bottom: 16px;
 }
-
-.delete_button {
-  width: 100%;
-}
diff --git a/web/modals/threads/settings/thread-settings-delete-tab.react.js b/web/modals/threads/settings/thread-settings-delete-tab.react.js
index 9deb0e7c5..c04798389 100644
--- a/web/modals/threads/settings/thread-settings-delete-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-delete-tab.react.js
@@ -1,124 +1,126 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   deleteThread,
 } from 'lib/actions/thread-actions';
 import { type SetState } from 'lib/types/hook-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
-import Button from '../../../components/button.react';
 import SWMansionIcon from '../../../SWMansionIcon.react';
 import Input from '../../input.react';
 import { useModalContext } from '../../modal-provider.react';
+import SubmitSection from './submit-section.react';
 import css from './thread-settings-delete-tab.css';
 
 type ThreadSettingsDeleteTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
-  +setErrorMessage: SetState<string>,
+  +setErrorMessage: SetState<?string>,
+  +errorMessage?: ?string,
 };
 
 function ThreadSettingsDeleteTab(
   props: ThreadSettingsDeleteTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     setErrorMessage,
+    errorMessage,
   } = 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 {
       setErrorMessage('');
       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">
+    <form method="POST" className={css.container}>
       <div>
         <SWMansionIcon icon="warning-circle" size={22} />
         <p className={css.deletion_warning}>
           Your chat will be permanently deleted. There is no way to reverse
           this.
         </p>
       </div>
       <div>
         <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="Password"
             value={accountPassword}
             onChange={onChangeAccountPassword}
             disabled={threadSettingsOperationInProgress}
             ref={accountPasswordInputRef}
           />
         </div>
       </div>
-      <Button
+      <SubmitSection
+        errorMessage={errorMessage}
         onClick={onDelete}
         variant="danger"
         disabled={
           threadSettingsOperationInProgress || accountPassword.length === 0
         }
-        className={css.delete_button}
       >
         Delete
-      </Button>
+      </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsDeleteTab;
diff --git a/web/modals/threads/settings/thread-settings-general-tab.css b/web/modals/threads/settings/thread-settings-general-tab.css
index 689b3a88a..7fe08877c 100644
--- a/web/modals/threads/settings/thread-settings-general-tab.css
+++ b/web/modals/threads/settings/thread-settings-general-tab.css
@@ -1,33 +1,34 @@
 div.form_title {
   padding-top: 6px;
   font-size: 14px;
   font-weight: 600;
   vertical-align: top;
   color: var(--fg);
 }
 div.form_content {
   display: flex;
   font-family: var(--font-stack);
   color: var(--fg);
   margin-top: 8px;
   margin-bottom: 12px;
 }
 div.form_content textarea {
   padding: 12px;
   background: var(--modal-bg);
   color: var(--fg);
   border: 1px solid var(--border-color);
   font-size: var(--m-font-16);
   border-radius: 4px;
   width: 100%;
 }
 
 div.colorSelectorContainer {
   margin-top: 8px;
   margin-bottom: 12px;
 }
 
-.save_button {
-  width: 100%;
-  min-height: 46px;
+form.container {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
 }
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 4de7cdc2a..2e11809b9 100644
--- a/web/modals/threads/settings/thread-settings-general-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-general-tab.react.js
@@ -1,197 +1,198 @@
 // @flow
 
 import * as React from 'react';
 import tinycolor from 'tinycolor2';
 
 import {
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } from 'lib/actions/thread-actions';
 import { threadHasPermission } from 'lib/shared/thread-utils';
 import { type SetState } from 'lib/types/hook-types';
 import {
   type ThreadInfo,
   type ThreadChanges,
   threadPermissions,
 } 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 LoadingIndicator from '../../../loading-indicator.react';
 import Input from '../../input.react';
 import ColorSelector from '../color-selector.react';
+import SubmitSection from './submit-section.react';
 import css from './thread-settings-general-tab.css';
 
 type ThreadSettingsGeneralTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +threadNamePlaceholder: string,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
-  +setErrorMessage: SetState<string>,
+  +setErrorMessage: SetState<?string>,
+  +errorMessage?: ?string,
 };
 function ThreadSettingsGeneralTab(
   props: ThreadSettingsGeneralTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     threadNamePlaceholder,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
+    errorMessage,
   } = props;
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useServerCall(changeThreadSettings);
 
   const nameInputRef = React.useRef();
 
   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 changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       return await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
     } catch (e) {
       setErrorMessage('unknown_error');
       throw e;
     } finally {
       setQueuedChanges(Object.freeze({}));
     }
   }, [
     callChangeThreadSettings,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   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">
+    <form method="POST" className={css.container}>
       <div>
         <div className={css.form_title}>Chat name</div>
         <div className={css.form_content}>
           <Input
             type="text"
             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>
-      <Button
-        type="submit"
+      <SubmitSection
+        errorMessage={errorMessage}
         onClick={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
-        className={css.save_button}
       >
         {saveButtonContent}
-      </Button>
+      </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/settings/thread-settings-modal.css b/web/modals/threads/settings/thread-settings-modal.css
index 73df5420a..5d116a0ff 100644
--- a/web/modals/threads/settings/thread-settings-modal.css
+++ b/web/modals/threads/settings/thread-settings-modal.css
@@ -1,19 +1,25 @@
 div.modal_body {
   display: flex;
   flex-direction: column;
   width: 383px;
-  height: 539px;
+  height: 560px;
   overflow: hidden;
 }
 div.tab_body {
   padding: 20px;
   overflow: auto;
+  flex: 1;
+  display: flex;
+  flex-direction: column;
 }
 div.modal_form_error {
   display: flex;
+  align-items: flex-end;
   justify-content: center;
-  padding-top: 8px;
-  font-size: 16px;
-  color: red;
+  font-size: var(--s-font-16);
+  color: var(--error);
   font-style: italic;
+  min-height: 26px;
+  flex: 1;
+  padding: 5px;
 }
diff --git a/web/modals/threads/settings/thread-settings-modal.react.js b/web/modals/threads/settings/thread-settings-modal.react.js
index 8274f1c9a..d82cf424f 100644
--- a/web/modals/threads/settings/thread-settings-modal.react.js
+++ b/web/modals/threads/settings/thread-settings-modal.react.js
@@ -1,227 +1,227 @@
 // @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 { getAvailableRelationshipButtons } from 'lib/shared/relationship-utils';
 import {
   threadHasPermission,
   robotextName,
   getSingleOtherUser,
 } from 'lib/shared/thread-utils';
 import {
   type ThreadInfo,
   threadTypes,
   threadPermissions,
   type ThreadChanges,
 } from 'lib/types/thread-types';
 
 import Tabs from '../../../components/tabs.react';
 import { useSelector } from '../../../redux/redux-utils';
 import { useModalContext } from '../../modal-provider.react';
 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';
 import ThreadSettingsRelationshipTab from './thread-settings-relationship-tab.react';
 
 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 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 [errorMessage, setErrorMessage] = React.useState<?string>('');
     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 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 [];
       }
       return getAvailableRelationshipButtons(otherUserInfo);
     }, [otherUserInfo]);
 
     const hasPermissionForTab = React.useCallback(
       (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]);
 
     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>
       );
     }
 
     const tabs = [
       <Tabs.Item id="general" header="General" key="general">
         <div className={css.tab_body}>
           <ThreadSettingsGeneralTab
             threadSettingsOperationInProgress={changeInProgress}
             threadInfo={threadInfo}
             threadNamePlaceholder={namePlaceholder}
             queuedChanges={queuedChanges}
             setQueuedChanges={setQueuedChanges}
             setErrorMessage={setErrorMessage}
+            errorMessage={errorMessage}
           />
-          <div className={css.modal_form_error}>{errorMessage}</div>
         </div>
       </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">
           <div className={css.tab_body}>
             <ThreadSettingsPrivacyTab
               threadSettingsOperationInProgress={changeInProgress}
               threadInfo={threadInfo}
               queuedChanges={queuedChanges}
               setQueuedChanges={setQueuedChanges}
               setErrorMessage={setErrorMessage}
+              errorMessage={errorMessage}
             />
-            <div className={css.modal_form_error}>{errorMessage}</div>
           </div>
         </Tabs.Item>,
       );
     }
 
     if (availableRelationshipActions.length > 0 && otherUserInfo) {
       tabs.push(
         <Tabs.Item id="relationship" header="Relationship" key="relationship">
           <div className={css.tab_body}>
             <ThreadSettingsRelationshipTab
               setErrorMessage={setErrorMessage}
               relationshipButtons={availableRelationshipActions}
               otherUserInfo={otherUserInfo}
             />
             <div className={css.modal_form_error}>{errorMessage}</div>
           </div>
         </Tabs.Item>,
       );
     }
 
     const canDeleteThread = hasPermissionForTab(threadInfo, 'delete');
     if (canDeleteThread) {
       tabs.push(
         <Tabs.Item id="delete" header="Delete" key="delete">
           <div className={css.tab_body}>
             <ThreadSettingsDeleteTab
               threadSettingsOperationInProgress={changeInProgress}
               threadInfo={threadInfo}
               setErrorMessage={setErrorMessage}
+              errorMessage={errorMessage}
             />
-            <div className={css.modal_form_error}>{errorMessage}</div>
           </div>
         </Tabs.Item>,
       );
     }
 
     return (
       <Modal
         name="Chat settings"
         onClose={modalContext.popModal}
         icon="settings"
         size="fit-content"
       >
         <div className={css.modal_body}>
           <Tabs.Container activeTab={currentTabType} setTab={setCurrentTabType}>
             {tabs}
           </Tabs.Container>
         </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 cde0b13a3..b300100d7 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.css
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.css
@@ -1,13 +1,15 @@
 div.form_title {
   padding-top: 6px;
   font-size: var(--s-font-14);
   font-weight: 600;
 }
 
 div.enum_container {
   padding: 12px 0;
 }
 
-.save_button {
-  width: 100%;
+form.container {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
 }
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 2175e0f0b..2fb29af98 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
@@ -1,177 +1,178 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions';
 import { threadTypeDescriptions } from 'lib/shared/thread-utils';
 import { type SetState } from 'lib/types/hook-types';
 import {
   type ThreadInfo,
   type ThreadChanges,
   threadTypes,
 } from 'lib/types/thread-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
-import Button from '../../../components/button.react';
 import EnumSettingsOption from '../../../components/enum-settings-option.react';
 import SWMansionIcon from '../../../SWMansionIcon.react';
 import { useModalContext } from '../../modal-provider.react';
+import SubmitSection from './submit-section.react';
 import css from './thread-settings-privacy-tab.css';
 
 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>,
+  +setErrorMessage: SetState<?string>,
+  +errorMessage?: ?string,
 };
 function ThreadSettingsPrivacyTab(
   props: ThreadSettingsPrivacyTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
+    errorMessage,
   } = 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 changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       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],
   );
 
   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">
+    <form method="POST" 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>
 
-      <Button
-        type="submit"
+      <SubmitSection
         onClick={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
-        className={css.save_button}
+        errorMessage={errorMessage}
       >
         Save
-      </Button>
+      </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsPrivacyTab;
diff --git a/web/modals/threads/settings/thread-settings-relationship-button.react.js b/web/modals/threads/settings/thread-settings-relationship-button.react.js
index 645135190..5d3bd491c 100644
--- a/web/modals/threads/settings/thread-settings-relationship-button.react.js
+++ b/web/modals/threads/settings/thread-settings-relationship-button.react.js
@@ -1,139 +1,139 @@
 // @flow
 import {
   faUserMinus,
   faUserPlus,
   faUserShield,
   faUserSlash,
 } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   updateRelationships,
   updateRelationshipsActionTypes,
 } from 'lib/actions/relationship-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import {
   getRelationshipActionText,
   getRelationshipDispatchAction,
 } from 'lib/shared/relationship-utils';
 import type { SetState } from 'lib/types/hook-types';
 import {
   relationshipButtons,
   type RelationshipButton,
 } from 'lib/types/relationship-types';
 import type { UserInfo } from 'lib/types/user-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
 import Button from '../../../components/button.react';
 import { useSelector } from '../../../redux/redux-utils';
 import css from './thread-settings-relationship-tab.css';
 
 const loadingStatusSelector = createLoadingStatusSelector(
   updateRelationshipsActionTypes,
 );
 
 type ButtonProps = {
   +relationshipButton: RelationshipButton,
   +otherUserInfo: UserInfo,
-  +setErrorMessage?: SetState<string>,
+  +setErrorMessage?: SetState<?string>,
 };
 
 function ThreadSettingsRelationshipButton(props: ButtonProps): React.Node {
   const { relationshipButton, otherUserInfo, setErrorMessage } = props;
 
   const disabled = useSelector(loadingStatusSelector) === 'loading';
 
   const { username } = otherUserInfo;
   invariant(username, 'Other username should be specified');
 
   let variant = 'primary';
   if (relationshipButton === relationshipButtons.FRIEND) {
     variant = 'success';
   } else if (relationshipButton === relationshipButtons.UNFRIEND) {
     variant = 'danger';
   } else if (relationshipButton === relationshipButtons.BLOCK) {
     variant = 'danger';
   } else if (relationshipButton === relationshipButtons.UNBLOCK) {
     variant = 'success';
   } else if (relationshipButton === relationshipButtons.ACCEPT) {
     variant = 'success';
   } else if (relationshipButton === relationshipButtons.REJECT) {
     variant = 'danger';
   } else if (relationshipButton === relationshipButtons.WITHDRAW) {
     variant = 'danger';
   }
 
   const { text, action } = React.useMemo(() => {
     return {
       text: getRelationshipActionText(relationshipButton, username),
       action: getRelationshipDispatchAction(relationshipButton),
     };
   }, [relationshipButton, username]);
 
   const icon = React.useMemo(() => {
     let buttonIcon = null;
 
     if (relationshipButton === relationshipButtons.FRIEND) {
       buttonIcon = faUserPlus;
     } else if (relationshipButton === relationshipButtons.UNFRIEND) {
       buttonIcon = faUserMinus;
     } else if (relationshipButton === relationshipButtons.BLOCK) {
       buttonIcon = faUserShield;
     } else if (relationshipButton === relationshipButtons.UNBLOCK) {
       buttonIcon = faUserShield;
     } else if (relationshipButton === relationshipButtons.ACCEPT) {
       buttonIcon = faUserPlus;
     } else if (relationshipButton === relationshipButtons.REJECT) {
       buttonIcon = faUserSlash;
     } else if (relationshipButton === relationshipButtons.WITHDRAW) {
       buttonIcon = faUserMinus;
     }
 
     if (buttonIcon) {
       return (
         <FontAwesomeIcon
           icon={buttonIcon}
           className={css.relationshipButtonIcon}
         />
       );
     }
   }, [relationshipButton]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callUpdateRelationships = useServerCall(updateRelationships);
 
   const updateRelationshipsActionPromise = React.useCallback(async () => {
     try {
       setErrorMessage?.('');
       return await callUpdateRelationships({
         action,
         userIDs: [otherUserInfo.id],
       });
     } catch (e) {
       setErrorMessage?.('Error updating relationship');
       throw e;
     }
   }, [action, callUpdateRelationships, otherUserInfo.id, setErrorMessage]);
   const onClick = React.useCallback(() => {
     dispatchActionPromise(
       updateRelationshipsActionTypes,
       updateRelationshipsActionPromise(),
     );
   }, [dispatchActionPromise, updateRelationshipsActionPromise]);
 
   return (
     <Button variant={variant} onClick={onClick} disabled={disabled}>
       <div className={css.relationshipButtonContent}>
         {icon}
         <div className={css.relationshipButtonText}>{text}</div>
       </div>
     </Button>
   );
 }
 
 export default ThreadSettingsRelationshipButton;
diff --git a/web/modals/threads/settings/thread-settings-relationship-tab.react.js b/web/modals/threads/settings/thread-settings-relationship-tab.react.js
index 8e04e2344..0f30aea47 100644
--- a/web/modals/threads/settings/thread-settings-relationship-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-relationship-tab.react.js
@@ -1,35 +1,35 @@
 // @flow
 
 import * as React from 'react';
 
 import { type SetState } from 'lib/types/hook-types';
 import { type RelationshipButton } from 'lib/types/relationship-types';
 import type { UserInfo } from 'lib/types/user-types';
 
 import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
 import css from './thread-settings-relationship-tab.css';
 
 type Props = {
-  +setErrorMessage: SetState<string>,
+  +setErrorMessage: SetState<?string>,
   +relationshipButtons: $ReadOnlyArray<RelationshipButton>,
   +otherUserInfo: UserInfo,
 };
 
 function ThreadSettingsRelationshipTab(props: Props): React.Node {
   const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
   const buttons = React.useMemo(
     () =>
       relationshipButtons.map(action => (
         <ThreadSettingsRelationshipButton
           key={action}
           relationshipButton={action}
           otherUserInfo={otherUserInfo}
           setErrorMessage={setErrorMessage}
         />
       )),
     [otherUserInfo, relationshipButtons, setErrorMessage],
   );
   return <div className={css.container}>{buttons}</div>;
 }
 
 export default ThreadSettingsRelationshipTab;