diff --git a/web/modals/threads/thread-settings-general-tab.css b/web/modals/threads/thread-settings-general-tab.css
index a6b5dc690..70a6ed961 100644
--- a/web/modals/threads/thread-settings-general-tab.css
+++ b/web/modals/threads/thread-settings-general-tab.css
@@ -1,38 +1,42 @@
 div.form_title {
   padding: 6px 6px 0 0;
   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: 4px;
   margin-bottom: 8px;
 }
 div.form_content input {
   margin-bottom: 4px;
 }
 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.form_textarea_container {
   margin-top: 1px;
 }
 
 div.edit_thread_color_container {
   margin-top: -5px;
 }
 
 div.color_title {
   margin-top: 4px;
 }
+
+.save_button {
+  width: 100%;
+}
diff --git a/web/modals/threads/thread-settings-general-tab.react.js b/web/modals/threads/thread-settings-general-tab.react.js
index e6e937c05..1266e72f3 100644
--- a/web/modals/threads/thread-settings-general-tab.react.js
+++ b/web/modals/threads/thread-settings-general-tab.react.js
@@ -1,115 +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(
         Object.freeze({
           ...queuedChanges,
           name: firstLine(
             target.value !== threadInfo.name ? target.value : undefined,
           ),
         }),
       );
     },
     [queuedChanges, setQueuedChanges, threadInfo.name],
   );
 
   const onChangeDescription = React.useCallback(
     (event: SyntheticEvent<HTMLTextAreaElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(
         Object.freeze({
           ...queuedChanges,
           description:
             target.value !== threadInfo.description ? target.value : undefined,
         }),
       );
     },
     [queuedChanges, setQueuedChanges, threadInfo.description],
   );
 
   const onChangeColor = React.useCallback(
     (color: string) => {
       setQueuedChanges(
         Object.freeze({
           ...queuedChanges,
           color: color !== threadInfo.color ? color : undefined,
         }),
       );
     },
     [queuedChanges, 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>
       <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>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/thread-settings-modal.react.js b/web/modals/threads/thread-settings-modal.react.js
index ce52a692f..3ecb74f57 100644
--- a/web/modals/threads/thread-settings-modal.react.js
+++ b/web/modals/threads/thread-settings-modal.react.js
@@ -1,288 +1,289 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } 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 {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
 import Button from '../../components/button.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 TabProps = {
   +name: string,
   +tabType: TabType,
   +selected: boolean,
   +onClick: (tabType: TabType) => void,
 };
 class Tab extends React.PureComponent<TabProps> {
   render() {
     const classNamesForTab = classNames({
       [css['current-tab']]: this.props.selected,
       [css['delete-tab']]:
         this.props.selected && this.props.tabType === 'delete',
     });
     return (
       <li className={classNamesForTab} onClick={this.onClick}>
         <a>{this.props.name}</a>
       </li>
     );
   }
 
   onClick = () => {
     return this.props.onClick(this.props.tabType);
   };
 }
 
 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 callChangeThreadSettings = useServerCall(changeThreadSettings);
     const dispatchActionPromise = useDispatchActionPromise();
     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 changeQueued: boolean = React.useMemo(
       () =>
         Object.values(queuedChanges).some(v => v !== null && v !== undefined),
       [queuedChanges],
     );
 
     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}`);
       },
       [],
     );
 
     const changeThreadSettingsAction = React.useCallback(async () => {
       invariant(
         threadInfo,
         'threadInfo should exist in changeThreadSettingsAction',
       );
       try {
         const response = await callChangeThreadSettings({
           threadID: threadInfo.id,
           changes: queuedChanges,
         });
         modalContext.popModal();
         return response;
       } catch (e) {
         setErrorMessage('unknown_error');
         setCurrentTabType('general');
         setQueuedChanges(Object.freeze({}));
         throw e;
       }
     }, [callChangeThreadSettings, modalContext, queuedChanges, threadInfo]);
 
     const onSubmit = React.useCallback(
       (event: SyntheticEvent<HTMLElement>) => {
         event.preventDefault();
         dispatchActionPromise(
           changeThreadSettingsActionTypes,
           changeThreadSettingsAction(),
         );
       },
       [changeThreadSettingsAction, dispatchActionPromise],
     );
 
     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);
 
     let mainContent;
     if (currentTabType === 'general') {
       mainContent = (
         <ThreadSettingsGeneralTab
           inputDisabled={inputDisabled}
           threadInfo={threadInfo}
           threadNamePlaceholder={namePlaceholder}
           queuedChanges={queuedChanges}
           setQueuedChanges={setQueuedChanges}
+          setErrorMessage={setErrorMessage}
         />
       );
     } else if (currentTabType === 'privacy') {
       mainContent = (
         <ThreadSettingsPrivacyTab
           inputDisabled={inputDisabled}
           threadInfo={threadInfo}
           queuedChanges={queuedChanges}
           setQueuedChanges={setQueuedChanges}
         />
       );
     } else if (currentTabType === 'delete') {
       mainContent = (
         <ThreadSettingsDeleteTab
           inputDisabled={inputDisabled}
           threadInfo={threadInfo}
           setErrorMessage={setErrorMessage}
         />
       );
     }
 
     let buttons;
-    if (currentTabType !== 'delete') {
+    if (currentTabType === 'privacy') {
       buttons = (
         <Button
           type="submit"
           onClick={onSubmit}
           disabled={inputDisabled || !changeQueued}
           className={css.save_button}
         >
           Save
         </Button>
       );
     }
 
     const tabs = [
       <Tab
         name="General"
         tabType="general"
         onClick={setCurrentTabType}
         selected={currentTabType === 'general'}
         key="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) {
       tabs.push(
         <Tab
           name="Privacy"
           tabType="privacy"
           onClick={setCurrentTabType}
           selected={currentTabType === 'privacy'}
           key="privacy"
         />,
       );
     }
 
     const canDeleteThread = hasPermissionForTab(threadInfo, 'delete');
     if (canDeleteThread) {
       tabs.push(
         <Tab
           name="Delete"
           tabType="delete"
           onClick={setCurrentTabType}
           selected={currentTabType === 'delete'}
           key="delete"
         />,
       );
     }
 
     return (
       <Modal name="Thread settings" onClose={modalContext.popModal}>
         <ul className={css.tab_panel}>{tabs}</ul>
         <div className={css.modal_body}>
           <form method="POST">
             {mainContent}
             <div className={css.form_footer}>
               {buttons}
               <div className={css.modal_form_error}>{errorMessage}</div>
             </div>
           </form>
         </div>
       </Modal>
     );
   },
 );
 
 export default ConnectedThreadSettingsModal;