diff --git a/web/account/log-in-form.react.js b/web/account/log-in-form.react.js
index 5e406c7fe..5869a3427 100644
--- a/web/account/log-in-form.react.js
+++ b/web/account/log-in-form.react.js
@@ -1,162 +1,167 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { logInActionTypes, logIn } from 'lib/actions/user-actions';
 import { useModalContext } from 'lib/components/modal-provider.react';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import {
   oldValidUsernameRegex,
   validEmailRegex,
 } from 'lib/shared/account-utils';
 import {
   type LogInExtraInfo,
   type LogInStartingPayload,
   loginActionSources,
 } from 'lib/types/account-types';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
 import Button from '../components/button.react';
 import LoadingIndicator from '../loading-indicator.react';
 import Input from '../modals/input.react';
 import { useSelector } from '../redux/redux-utils';
 import { webLogInExtraInfoSelector } from '../selectors/account-selectors';
 import css from './log-in-form.css';
 
 const loadingStatusSelector = createLoadingStatusSelector(logInActionTypes);
 function LoginForm(): React.Node {
   const inputDisabled = useSelector(loadingStatusSelector) === 'loading';
   const loginExtraInfo = useSelector(webLogInExtraInfoSelector);
   const callLogIn = useServerCall(logIn);
   const dispatchActionPromise = useDispatchActionPromise();
   const modalContext = useModalContext();
 
   const [username, setUsername] = React.useState<string>('');
   const [password, setPassword] = React.useState<string>('');
   const [errorMessage, setErrorMessage] = React.useState<string>('');
 
   const usernameInputRef = React.useRef();
 
   React.useEffect(() => {
     usernameInputRef.current?.focus();
   }, []);
 
   const onUsernameChange = React.useCallback(e => {
     invariant(e.target instanceof HTMLInputElement, 'target not input');
     setUsername(e.target.value);
   }, []);
 
   const onUsernameBlur = React.useCallback(() => {
     setUsername(untrimmedUsername => untrimmedUsername.trim());
   }, []);
 
   const onPasswordChange = React.useCallback(e => {
     invariant(e.target instanceof HTMLInputElement, 'target not input');
     setPassword(e.target.value);
   }, []);
 
   const logInAction = React.useCallback(
     async (extraInfo: LogInExtraInfo) => {
       try {
         const result = await callLogIn({
           ...extraInfo,
           username,
           password,
           source: loginActionSources.logInFromWebForm,
         });
         modalContext.popModal();
         return result;
       } catch (e) {
         setUsername('');
         setPassword('');
         if (e.message === 'invalid_credentials') {
           setErrorMessage('incorrect username or password');
         } else {
           setErrorMessage('unknown error');
         }
         usernameInputRef.current?.focus();
         throw e;
       }
     },
     [callLogIn, modalContext, password, username],
   );
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
 
       if (username.search(validEmailRegex) > -1) {
         setUsername('');
         setErrorMessage('usernames only, not emails');
         usernameInputRef.current?.focus();
         return;
       } else if (username.search(oldValidUsernameRegex) === -1) {
         setUsername('');
         setErrorMessage('alphanumeric usernames only');
         usernameInputRef.current?.focus();
         return;
       }
 
       const extraInfo = loginExtraInfo();
       dispatchActionPromise(
         logInActionTypes,
         logInAction(extraInfo),
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
     },
     [dispatchActionPromise, logInAction, loginExtraInfo, username],
   );
 
   const loginButtonContent = React.useMemo(() => {
     if (inputDisabled) {
       return <LoadingIndicator status="loading" />;
     }
     return 'Log in';
   }, [inputDisabled]);
 
   return (
     <div className={css['modal-body']}>
       <form method="POST">
         <div>
           <div className={css['form-title']}>Username</div>
           <div className={css['form-content']}>
             <Input
               type="text"
               placeholder="Username"
               value={username}
               onChange={onUsernameChange}
               onBlur={onUsernameBlur}
               ref={usernameInputRef}
               disabled={inputDisabled}
             />
           </div>
         </div>
         <div>
           <div className={css['form-title']}>Password</div>
           <div className={css['form-content']}>
             <Input
               type="password"
               placeholder="Password"
               value={password}
               onChange={onPasswordChange}
               disabled={inputDisabled}
             />
           </div>
         </div>
         <div className={css['form-footer']}>
-          <Button type="submit" disabled={inputDisabled} onClick={onSubmit}>
+          <Button
+            variant="filled"
+            type="submit"
+            disabled={inputDisabled}
+            onClick={onSubmit}
+          >
             {loginButtonContent}
           </Button>
           <div className={css['modal-form-error']}>{errorMessage}</div>
         </div>
       </form>
     </div>
   );
 }
 
 export default LoginForm;
diff --git a/web/chat/chat-thread-list.react.js b/web/chat/chat-thread-list.react.js
index b2af2a791..0dd48b0d5 100644
--- a/web/chat/chat-thread-list.react.js
+++ b/web/chat/chat-thread-list.react.js
@@ -1,76 +1,80 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { emptyItemText } from 'lib/shared/thread-utils';
 
 import BackgroundIllustration from '../assets/background-illustration.react';
 import Button from '../components/button.react';
 import Search from '../components/search.react';
 import { useSelector } from '../redux/redux-utils';
 import { useOnClickNewThread } from '../selectors/nav-selectors';
 import ChatThreadListItem from './chat-thread-list-item.react';
 import css from './chat-thread-list.css';
 import { ThreadListContext } from './thread-list-provider';
 
 function ChatThreadList(): React.Node {
   const threadListContext = React.useContext(ThreadListContext);
   invariant(
     threadListContext,
     'threadListContext should be set in ChatThreadList',
   );
   const {
     activeTab,
     threadList,
     setSearchText,
     searchText,
   } = threadListContext;
 
   const onClickNewThread = useOnClickNewThread();
 
   const isThreadCreation = useSelector(
     state => state.navInfo.chatMode === 'create',
   );
 
   const isBackground = activeTab === 'Background';
 
   const threadComponents: React.Node[] = React.useMemo(() => {
     const threads = threadList.map(item => (
       <ChatThreadListItem item={item} key={item.threadInfo.id} />
     ));
     if (threads.length === 0 && isBackground) {
       threads.push(<EmptyItem key="emptyItem" />);
     }
     return threads;
   }, [threadList, isBackground]);
 
   return (
     <>
       <div className={css.threadListContainer}>
         <Search
           onChangeText={setSearchText}
           searchText={searchText}
           placeholder="Search chats"
         />
         <div>{threadComponents}</div>
       </div>
       <div className={css.createNewThread}>
-        <Button disabled={isThreadCreation} onClick={onClickNewThread}>
+        <Button
+          variant="filled"
+          disabled={isThreadCreation}
+          onClick={onClickNewThread}
+        >
           Create new chat
         </Button>
       </div>
     </>
   );
 }
 
 function EmptyItem() {
   return (
     <div className={css.emptyItemContainer}>
       <BackgroundIllustration />
       <div className={css.emptyItemText}>{emptyItemText}</div>
     </div>
   );
 }
 
 export default ChatThreadList;
diff --git a/web/components/button.css b/web/components/button.css
index 0b631348f..679de6cf6 100644
--- a/web/components/button.css
+++ b/web/components/button.css
@@ -1,72 +1,76 @@
+.plain {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  background: none;
+  border: none;
+}
+
 .btn {
   --border-width: 1px;
   --border-radius: 4px;
 
   position: relative;
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  justify-content: center;
-  border: var(--border-width) solid transparent;
   font-size: var(--m-font-16);
   padding: 12px 24px;
   color: var(--fg);
+  border: var(--border-width) solid transparent;
   border-radius: var(--border-radius);
-  cursor: pointer;
 }
 
 .btn.outline {
   border: var(--border-width) solid var(--btn-outline-border);
 }
 
 .btn > * {
   position: relative;
 }
 
 .btn::before {
   content: '';
   border: inherit;
   border-radius: inherit;
   background: inherit;
   position: absolute;
   top: calc(-1 * var(--border-width));
   left: calc(-1 * var(--border-width));
   width: 100%;
   height: 100%;
 }
 
 .btn.outline::before {
   top: 0;
   left: 0;
   border: none;
   border-radius: calc(var(--border-radius) - var(--border-width));
 }
 
 .btn:hover::before {
   transition-duration: 200ms;
   transition-property: filter;
 }
 
 .btn:hover:not(:disabled)::before {
   filter: brightness(0.8);
 }
 
 .btn.outline:hover:not(:disabled)::before {
   filter: brightness(2);
 }
 
 .btn:disabled {
   cursor: not-allowed;
   color: var(--btn-disabled-color);
 }
 
 .btn:not(.outline):disabled::before {
   background-color: var(--btn-bg-disabled);
 }
 
 .text {
+  font-size: var(--m-font-16);
   background: transparent;
   white-space: nowrap;
-  padding: 0;
-  border: none;
 }
diff --git a/web/components/button.react.js b/web/components/button.react.js
index 7abf01a0b..13d7529af 100644
--- a/web/components/button.react.js
+++ b/web/components/button.react.js
@@ -1,81 +1,85 @@
 // @flow
 
 import classnames from 'classnames';
 import * as React from 'react';
 
 import css from './button.css';
 
-export type ButtonVariant = 'filled' | 'outline' | 'text';
+export type ButtonVariant = 'plain' | 'filled' | 'outline' | 'text';
 export type ButtonColor = {
   +backgroundColor?: string,
   +color?: string,
 };
 
 export const buttonThemes: { [string]: ButtonColor } = {
   standard: {
     backgroundColor: 'var(--btn-bg-filled)',
   },
   danger: {
     backgroundColor: 'var(--btn-bg-danger)',
   },
   success: {
     backgroundColor: 'var(--btn-bg-success)',
   },
   outline: {
     backgroundColor: 'var(--btn-bg-outline)',
   },
 };
 
 export type ButtonProps = {
-  +onClick: (event: SyntheticEvent<HTMLButtonElement>) => mixed,
+  +onClick: ?(event: SyntheticEvent<HTMLButtonElement>) => mixed,
   +children: React.Node,
   +variant?: ButtonVariant,
   +buttonColor?: ButtonColor,
   +type?: string,
   +disabled?: boolean,
   +className?: string,
 };
 
 function Button(props: ButtonProps): React.Node {
   const {
     onClick,
     children,
-    variant = 'filled',
+    variant = 'plain',
     buttonColor,
-    type,
+    type = 'button',
     disabled = false,
     className = '',
   } = props;
 
-  const btnCls = classnames(css.btn, css[variant]);
+  const btnCls = classnames({
+    [css.plain]: true,
+    [css.btn]: variant === 'filled' || variant === 'outline',
+    [css[variant]]: true,
+  });
 
   let style = {};
   if (buttonColor) {
     style = buttonColor;
   } else if (variant === 'outline') {
     style = buttonThemes.outline;
   } else if (variant === 'filled') {
     style = buttonThemes.standard;
   }
 
   const wrappedChildren = React.Children.map(children, child => {
     if (typeof child === 'string' || typeof child === 'number') {
       return <span>{child}</span>;
     }
     return child;
   });
 
   return (
     <button
       type={type}
       className={`${btnCls} ${className}`}
       onClick={onClick}
       disabled={disabled}
       style={style}
     >
       {wrappedChildren}
     </button>
   );
 }
 
 export default Button;
diff --git a/web/modals/concurrent-modification-modal.react.js b/web/modals/concurrent-modification-modal.react.js
index 870a8051f..b3cf587ae 100644
--- a/web/modals/concurrent-modification-modal.react.js
+++ b/web/modals/concurrent-modification-modal.react.js
@@ -1,35 +1,36 @@
 // @flow
 
 import * as React from 'react';
 
 import { useModalContext } from 'lib/components/modal-provider.react';
 
 import Button from '../components/button.react';
 import css from './concurrent-modification-modal.css';
 import Modal from './modal.react';
 
 type Props = {
   +onRefresh: () => void,
 };
 
 export default function ConcurrentModificationModal(props: Props): React.Node {
   const modalContext = useModalContext();
 
   return (
     <Modal name="Concurrent modification" onClose={modalContext.popModal}>
       <div className={css.modal_body}>
         <p>
           It looks like somebody is attempting to modify that field at the same
           time as you! Please refresh the entry and try again.
         </p>
         <Button
+          variant="filled"
           onClick={props.onRefresh}
           type="submit"
           className={css.refresh_button}
         >
           Refresh entry
         </Button>
       </div>
     </Modal>
   );
 }
diff --git a/web/modals/threads/members/members-modal.react.js b/web/modals/threads/members/members-modal.react.js
index 2ebea95d7..ffbea08c0 100644
--- a/web/modals/threads/members/members-modal.react.js
+++ b/web/modals/threads/members/members-modal.react.js
@@ -1,141 +1,143 @@
 // @flow
 
 import * as React from 'react';
 
 import { useModalContext } from 'lib/components/modal-provider.react';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { userStoreSearchIndex } from 'lib/selectors/user-selectors';
 import {
   memberHasAdminPowers,
   memberIsAdmin,
   threadHasPermission,
 } from 'lib/shared/thread-utils';
 import {
   type RelativeMemberInfo,
   threadPermissions,
 } from 'lib/types/thread-types';
 
 import Button from '../../../components/button.react';
 import Tabs from '../../../components/tabs.react';
 import { useSelector } from '../../../redux/redux-utils';
 import SearchModal from '../../search-modal.react';
 import AddMembersModal from './add-members-modal.react';
 import ThreadMembersList from './members-list.react';
 import css from './members-modal.css';
 
 type ContentProps = {
   +searchText: string,
   +threadID: string,
 };
 function ThreadMembersModalContent(props: ContentProps): React.Node {
   const { threadID, searchText } = props;
 
   const [tab, setTab] = React.useState<'All Members' | 'Admins'>('All Members');
 
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
   const { members: threadMembersNotFiltered } = threadInfo;
 
   const userSearchIndex = useSelector(userStoreSearchIndex);
   const userIDs = React.useMemo(
     () => userSearchIndex.getSearchResults(searchText),
     [searchText, userSearchIndex],
   );
 
   const allMembers = React.useMemo(
     () =>
       threadMembersNotFiltered.filter(
         (member: RelativeMemberInfo) =>
           searchText.length === 0 || userIDs.includes(member.id),
       ),
     [searchText.length, threadMembersNotFiltered, userIDs],
   );
   const adminMembers = React.useMemo(
     () =>
       allMembers.filter(
         (member: RelativeMemberInfo) =>
           memberIsAdmin(member, threadInfo) || memberHasAdminPowers(member),
       ),
     [allMembers, threadInfo],
   );
 
   const allUsersTab = React.useMemo(
     () => (
       <Tabs.Item id="All Members" header="All Members">
         <ThreadMembersList threadInfo={threadInfo} threadMembers={allMembers} />
       </Tabs.Item>
     ),
     [allMembers, threadInfo],
   );
 
   const allAdminsTab = React.useMemo(
     () => (
       <Tabs.Item id="Admins" header="Admins">
         <ThreadMembersList
           threadInfo={threadInfo}
           threadMembers={adminMembers}
         />
       </Tabs.Item>
     ),
     [adminMembers, threadInfo],
   );
 
   const { pushModal, popModal } = useModalContext();
 
   const onClickAddMembers = React.useCallback(() => {
     pushModal(<AddMembersModal onClose={popModal} threadID={threadID} />);
   }, [popModal, pushModal, threadID]);
 
   const canAddMembers = threadHasPermission(
     threadInfo,
     threadPermissions.ADD_MEMBERS,
   );
 
   const addMembersButton = React.useMemo(() => {
     if (!canAddMembers) {
       return null;
     }
     return (
       <div className={css.addNewMembers}>
-        <Button onClick={onClickAddMembers}>Add members</Button>
+        <Button variant="filled" onClick={onClickAddMembers}>
+          Add members
+        </Button>
       </div>
     );
   }, [canAddMembers, onClickAddMembers]);
 
   return (
     <div className={css.modalContentContainer}>
       <div className={css.membersListTabs}>
         <Tabs.Container activeTab={tab} setTab={setTab}>
           {allUsersTab}
           {allAdminsTab}
         </Tabs.Container>
       </div>
       {addMembersButton}
     </div>
   );
 }
 
 type Props = {
   +threadID: string,
   +onClose: () => void,
 };
 function ThreadMembersModal(props: Props): React.Node {
   const { onClose, threadID } = props;
   const renderModalContent = React.useCallback(
     (searchText: string) => (
       <ThreadMembersModalContent threadID={threadID} searchText={searchText} />
     ),
     [threadID],
   );
   return (
     <SearchModal
       name="Members"
       searchPlaceholder="Search members"
       onClose={onClose}
       size="fit-content"
     >
       {renderModalContent}
     </SearchModal>
   );
 }
 
 export default ThreadMembersModal;
diff --git a/web/modals/threads/notifications/notifications-modal.react.js b/web/modals/threads/notifications/notifications-modal.react.js
index 034a2a918..392e60acf 100644
--- a/web/modals/threads/notifications/notifications-modal.react.js
+++ b/web/modals/threads/notifications/notifications-modal.react.js
@@ -1,271 +1,271 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   updateSubscription,
   updateSubscriptionActionTypes,
 } from 'lib/actions/user-actions';
 import { canPromoteSidebar } from 'lib/hooks/promote-sidebar.react';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { threadIsSidebar } from 'lib/shared/thread-utils';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import AllNotifsIllustration from '../../../assets/all-notifs.react.js';
 import BadgeNotifsIllustration from '../../../assets/badge-notifs.react.js';
 import MutedNotifsIllustration from '../../../assets/muted-notifs.react.js';
 import Button from '../../../components/button.react';
 import EnumSettingsOption from '../../../components/enum-settings-option.react';
 import { useSelector } from '../../../redux/redux-utils';
 import Modal from '../../modal.react';
 import css from './notifications-modal.css';
 
 type NotificationSettings = 'focused' | 'badge-only' | 'background';
 
 const BANNER_NOTIFS = 'Banner notifs';
 const BADGE_COUNT = 'Badge count';
 const IN_FOCUSED_TAB = 'Lives in Focused tab';
 const IN_BACKGROUND_TAB = 'Lives in Background tab';
 
 const focusedStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_FOCUSED_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 const badgeOnlyStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_FOCUSED_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 const backgroundStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_BACKGROUND_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 type Props = {
   +threadID: string,
   +onClose: () => void,
 };
 function NotificationsModal(props: Props): React.Node {
   const { onClose, threadID } = props;
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
   const { subscription } = threadInfo.currentUser;
   const { parentThreadID } = threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
   const isSidebar = threadIsSidebar(threadInfo);
 
   const initialThreadSetting = React.useMemo<NotificationSettings>(() => {
     if (!subscription.home) {
       return 'background';
     }
     if (!subscription.pushNotifs) {
       return 'badge-only';
     }
     return 'focused';
   }, [subscription.home, subscription.pushNotifs]);
 
   const [
     notificationSettings,
     setNotificationSettings,
   ] = React.useState<NotificationSettings>(initialThreadSetting);
 
   const onFocusedSelected = React.useCallback(
     () => setNotificationSettings('focused'),
     [],
   );
   const onBadgeOnlySelected = React.useCallback(
     () => setNotificationSettings('badge-only'),
     [],
   );
   const onBackgroundSelected = React.useCallback(
     () => setNotificationSettings('background'),
     [],
   );
 
   const isFocusedSelected = notificationSettings === 'focused';
   const focusedItem = React.useMemo(() => {
     const icon = <AllNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isFocusedSelected}
         title="Focused (enabled)"
         statements={focusedStatements}
         icon={icon}
         onSelect={onFocusedSelected}
       />
     );
   }, [isFocusedSelected, onFocusedSelected]);
 
   const isFocusedBadgeOnlySelected = notificationSettings === 'badge-only';
   const focusedBadgeOnlyItem = React.useMemo(() => {
     const icon = <BadgeNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isFocusedBadgeOnlySelected}
         title="Focused (badge only)"
         statements={badgeOnlyStatements}
         icon={icon}
         onSelect={onBadgeOnlySelected}
       />
     );
   }, [isFocusedBadgeOnlySelected, onBadgeOnlySelected]);
 
   const isBackgroundSelected = notificationSettings === 'background';
   const backgroundItem = React.useMemo(() => {
     const icon = <MutedNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isBackgroundSelected}
         title="Background"
         statements={backgroundStatements}
         icon={icon}
         disabled={isSidebar}
         onSelect={onBackgroundSelected}
       />
     );
   }, [isBackgroundSelected, onBackgroundSelected, isSidebar]);
 
   const dispatchActionPromise = useDispatchActionPromise();
 
   const callUpdateSubscription = useServerCall(updateSubscription);
 
   const onClickSave = React.useCallback(() => {
     dispatchActionPromise(
       updateSubscriptionActionTypes,
       callUpdateSubscription({
         threadID: threadID,
         updatedFields: {
           home: notificationSettings !== 'background',
           pushNotifs: notificationSettings === 'focused',
         },
       }),
     );
     onClose();
   }, [
     callUpdateSubscription,
     dispatchActionPromise,
     notificationSettings,
     onClose,
     threadID,
   ]);
 
   const modalName = isSidebar
     ? 'Thread notifications'
     : 'Channel notifications';
 
   let modalContent;
   if (isSidebar && !parentThreadInfo?.currentUser.subscription.home) {
     modalContent = (
       <>
         <p>
           {'It’s not possible to change the notif settings for a thread ' +
             'whose parent is in Background. That’s because Comm’s design ' +
             'always shows threads underneath their parent in the Inbox, ' +
             'which means that if a thread’s parent is in Background, the ' +
             'thread must also be there.'}
         </p>
         <p>
           {canPromoteSidebar(threadInfo, parentThreadInfo)
             ? 'If you want to change the notif settings for this thread, ' +
               'you can either change the notif settings for the parent, ' +
               'or you can promote the thread to a channel.'
             : 'If you want to change the notif settings for this thread, ' +
               'you’ll have to change the notif settings for the parent.'}
         </p>
       </>
     );
   } else {
     let noticeText = null;
     if (isSidebar) {
       noticeText = (
         <>
           <p className={css.notice}>
             {'It’s not possible to move this thread to Background. ' +
               'That’s because Comm’s design always shows threads ' +
               'underneath their parent in the Inbox, which means ' +
               'that if a thread’s parent is in Focused, the thread ' +
               'must also be there.'}
           </p>
           <p className={css.notice}>
             {canPromoteSidebar(threadInfo, parentThreadInfo)
               ? 'If you want to move this thread to Background, ' +
                 'you can either move the parent to Background, ' +
                 'or you can promote the thread to a channel.'
               : 'If you want to move this thread to Background, ' +
                 'you’ll have to move the parent to Background.'}
           </p>
         </>
       );
     }
 
     modalContent = (
       <>
         <div className={css.optionsContainer}>
           {focusedItem}
           {focusedBadgeOnlyItem}
           {backgroundItem}
         </div>
         <Button
-          type="primary"
+          variant="filled"
           onClick={onClickSave}
           disabled={notificationSettings === initialThreadSetting}
         >
           Save
         </Button>
         {noticeText}
       </>
     );
   }
 
   return (
     <Modal name={modalName} size="fit-content" onClose={onClose}>
       <div className={css.container}>{modalContent}</div>
     </Modal>
   );
 }
 
 export default NotificationsModal;
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 2e11809b9..30352f9ab 100644
--- a/web/modals/threads/settings/thread-settings-general-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-general-tab.react.js
@@ -1,198 +1,199 @@
 // @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 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>,
   +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" 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>
       <SubmitSection
+        variant="filled"
         errorMessage={errorMessage}
         onClick={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
       >
         {saveButtonContent}
       </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsGeneralTab;
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 b7be398f4..1d5c6271e 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
@@ -1,178 +1,179 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions';
 import { useModalContext } from 'lib/components/modal-provider.react';
 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 EnumSettingsOption from '../../../components/enum-settings-option.react';
 import SWMansionIcon from '../../../SWMansionIcon.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>,
   +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" 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={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
         errorMessage={errorMessage}
       >
         Save
       </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsPrivacyTab;
diff --git a/web/settings/relationship/user-list-modal.react.js b/web/settings/relationship/user-list-modal.react.js
index 82385c9d8..d464571e9 100644
--- a/web/settings/relationship/user-list-modal.react.js
+++ b/web/settings/relationship/user-list-modal.react.js
@@ -1,66 +1,68 @@
 // @flow
 
 import * as React from 'react';
 
 import type { AccountUserInfo } from 'lib/types/user-types';
 
 import Button from '../../components/button.react.js';
 import SearchModal from '../../modals/search-modal.react';
 import css from './user-list.css';
 import { UserList, type UserRowProps } from './user-list.react';
 
 type Props = {
   +onClose: () => void,
   +name: string,
   +userRowComponent: React.ComponentType<UserRowProps>,
   +filterUser: (userInfo: AccountUserInfo) => boolean,
   +usersComparator: (user1: AccountUserInfo, user2: AccountUserInfo) => number,
   +buttonLabel: string,
   +onAddUsersClick: () => void,
 };
 
 function UserListModal(props: Props): React.Node {
   const {
     onClose,
     name,
     userRowComponent,
     filterUser,
     usersComparator,
     buttonLabel,
     onAddUsersClick,
   } = props;
 
   const searchModalChildGenerator = React.useCallback(
     (searchText: string) => (
       <div className={css.searchModalContent}>
         <UserList
           userRowComponent={userRowComponent}
           filterUser={filterUser}
           usersComparator={usersComparator}
           searchText={searchText}
         />
-        <Button onClick={onAddUsersClick}>{buttonLabel}</Button>
+        <Button variant="filled" onClick={onAddUsersClick}>
+          {buttonLabel}
+        </Button>
       </div>
     ),
     [
       buttonLabel,
       filterUser,
       onAddUsersClick,
       userRowComponent,
       usersComparator,
     ],
   );
 
   return (
     <SearchModal
       name={name}
       size="large"
       searchPlaceholder="Search by name"
       onClose={onClose}
     >
       {searchModalChildGenerator}
     </SearchModal>
   );
 }
 
 export default UserListModal;