diff --git a/web/modals/concurrent-modification-modal.react.js b/web/modals/concurrent-modification-modal.react.js
index 3b3349cdc..be5760cf3 100644
--- a/web/modals/concurrent-modification-modal.react.js
+++ b/web/modals/concurrent-modification-modal.react.js
@@ -1,33 +1,32 @@
 // @flow
 
 import * as React from 'react';
 
+import Button from '../components/button.react';
 import css from '../style.css';
 import { useModalContext } from './modal-provider.react';
 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.clearModal}>
       <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>
         <div className={css['form-footer']}>
-          <input
-            type="submit"
-            value="Refresh entry"
-            onClick={props.onRefresh}
-          />
+          <Button onClick={props.onRefresh} type="submit">
+            Refresh entry
+          </Button>
         </div>
       </div>
     </Modal>
   );
 }
diff --git a/web/modals/threads/confirm-leave-thread-modal.react.js b/web/modals/threads/confirm-leave-thread-modal.react.js
index d76fea143..2fa4b6619 100644
--- a/web/modals/threads/confirm-leave-thread-modal.react.js
+++ b/web/modals/threads/confirm-leave-thread-modal.react.js
@@ -1,32 +1,35 @@
 // @flow
 
 import * as React from 'react';
 
 import { type ThreadInfo } from 'lib/types/thread-types';
 
+import Button from '../../components/button.react';
 import css from '../../style.css';
 import Modal from '../modal.react';
 
 type Props = {
   +threadInfo: ThreadInfo,
   +onClose: () => void,
   +onConfirm: () => void,
 };
 function ConfirmLeaveThreadModal(props: Props): React.Node {
   return (
     <Modal name="Confirm leave thread" onClose={props.onClose}>
       <div className={css['modal-body']}>
         <p>
           {'Are you sure you want to leave "'}
           <span className={css['thread-name']}>{props.threadInfo.uiName}</span>
           {'"?'}
         </p>
         <div className={css['form-footer']}>
-          <input type="submit" value="Leave thread" onClick={props.onConfirm} />
+          <Button onClick={props.onConfirm} type="submit">
+            Leave Thread
+          </Button>
         </div>
       </div>
     </Modal>
   );
 }
 
 export default ConfirmLeaveThreadModal;
diff --git a/web/modals/threads/new-thread-modal.react.js b/web/modals/threads/new-thread-modal.react.js
index aad066243..30f9c6af8 100644
--- a/web/modals/threads/new-thread-modal.react.js
+++ b/web/modals/threads/new-thread-modal.react.js
@@ -1,319 +1,321 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { newThreadActionTypes, newThread } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import {
   generateRandomColor,
   threadTypeDescriptions,
 } from 'lib/shared/thread-utils';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import {
   type ThreadInfo,
   threadTypes,
   assertThreadType,
   type ThreadType,
   type ClientNewThreadRequest,
   type NewThreadResult,
 } from 'lib/types/thread-types';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 import { firstLine } from 'lib/utils/string-utils';
 
+import Button from '../../components/button.react';
 import { useSelector } from '../../redux/redux-utils';
 import { nonThreadCalendarQuery } from '../../selectors/nav-selectors';
 import css from '../../style.css';
 import Modal from '../modal.react';
 import ColorPicker from './color-picker.react';
 
 type BaseProps = {
   +onClose: () => void,
   +parentThreadID?: ?string,
 };
 type Props = {
   ...BaseProps,
   +inputDisabled: boolean,
   +calendarQuery: () => CalendarQuery,
   +parentThreadInfo: ?ThreadInfo,
   +dispatchActionPromise: DispatchActionPromise,
   +newThread: (request: ClientNewThreadRequest) => Promise<NewThreadResult>,
 };
 type State = {
   +threadType: ?ThreadType,
   +name: string,
   +description: string,
   +color: string,
   +errorMessage: string,
 };
 
 const { COMMUNITY_OPEN_SUBTHREAD, COMMUNITY_SECRET_SUBTHREAD } = threadTypes;
 
 class NewThreadModal extends React.PureComponent<Props, State> {
   nameInput: ?HTMLInputElement;
   openPrivacyInput: ?HTMLInputElement;
   threadPasswordInput: ?HTMLInputElement;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       threadType: props.parentThreadID ? undefined : COMMUNITY_SECRET_SUBTHREAD,
       name: '',
       description: '',
       color: props.parentThreadInfo
         ? props.parentThreadInfo.color
         : generateRandomColor(),
       errorMessage: '',
     };
   }
 
   componentDidMount() {
     invariant(this.nameInput, 'nameInput ref unset');
     this.nameInput.focus();
   }
 
   render() {
     let threadTypeSection = null;
     if (this.props.parentThreadID) {
       threadTypeSection = (
         <div className={css['new-thread-privacy-container']}>
           <div className={css['modal-radio-selector']}>
             <div className={css['form-title']}>Thread type</div>
             <div className={css['form-enum-selector']}>
               <div className={css['form-enum-container']}>
                 <input
                   type="radio"
                   name="new-thread-type"
                   id="new-thread-open"
                   value={COMMUNITY_OPEN_SUBTHREAD}
                   checked={this.state.threadType === COMMUNITY_OPEN_SUBTHREAD}
                   onChange={this.onChangeThreadType}
                   disabled={this.props.inputDisabled}
                   ref={this.openPrivacyInputRef}
                 />
                 <div className={css['form-enum-option']}>
                   <label htmlFor="new-thread-open">
                     Open
                     <span className={css['form-enum-description']}>
                       {threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD]}
                     </span>
                   </label>
                 </div>
               </div>
               <div className={css['form-enum-container']}>
                 <input
                   type="radio"
                   name="new-thread-type"
                   id="new-thread-closed"
                   value={COMMUNITY_SECRET_SUBTHREAD}
                   checked={this.state.threadType === COMMUNITY_SECRET_SUBTHREAD}
                   onChange={this.onChangeThreadType}
                   disabled={this.props.inputDisabled}
                 />
                 <div className={css['form-enum-option']}>
                   <label htmlFor="new-thread-closed">
                     Secret
                     <span className={css['form-enum-description']}>
                       {threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD]}
                     </span>
                   </label>
                 </div>
               </div>
             </div>
           </div>
         </div>
       );
     }
     return (
       <Modal name="New thread" onClose={this.props.onClose} size="large">
         <div className={css['modal-body']}>
           <form method="POST">
             <div>
               <div className={css['form-title']}>Thread name</div>
               <div className={css['form-content']}>
                 <input
                   type="text"
                   value={firstLine(this.state.name)}
                   placeholder="Thread name"
                   onChange={this.onChangeName}
                   disabled={this.props.inputDisabled}
                   ref={this.nameInputRef}
                 />
               </div>
             </div>
             <div className={css['form-textarea-container']}>
               <div className={css['form-title']}>Description</div>
               <div className={css['form-content']}>
                 <textarea
                   value={this.state.description}
                   placeholder="Thread description"
                   onChange={this.onChangeDescription}
                   disabled={this.props.inputDisabled}
                 />
               </div>
             </div>
             {threadTypeSection}
             <div>
               <div className={`${css['form-title']} ${css['color-title']}`}>
                 Color
               </div>
               <div className={css['form-content']}>
                 <ColorPicker
                   id="new-thread-color"
                   value={this.state.color}
                   disabled={this.props.inputDisabled}
                   onChange={this.onChangeColor}
                 />
               </div>
             </div>
             <div className={css['form-footer']}>
-              <input
-                type="submit"
-                value="Save"
+              <Button
                 onClick={this.onSubmit}
                 disabled={this.props.inputDisabled}
-              />
+                type="submit"
+              >
+                Save
+              </Button>
               <div className={css['modal-form-error']}>
                 {this.state.errorMessage}
               </div>
             </div>
           </form>
         </div>
       </Modal>
     );
   }
 
   nameInputRef = (nameInput: ?HTMLInputElement) => {
     this.nameInput = nameInput;
   };
 
   openPrivacyInputRef = (openPrivacyInput: ?HTMLInputElement) => {
     this.openPrivacyInput = openPrivacyInput;
   };
 
   onChangeName = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLInputElement, 'target not input');
     this.setState({ name: firstLine(target.value) });
   };
 
   onChangeDescription = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLTextAreaElement, 'target not textarea');
     this.setState({ description: target.value });
   };
 
   onChangeColor = (color: string) => {
     this.setState({ color: color });
   };
 
   onChangeThreadType = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLInputElement, 'target not input');
     this.setState({
       threadType: assertThreadType(parseInt(target.value, 10)),
     });
   };
 
-  onSubmit = (event: SyntheticEvent<HTMLInputElement>) => {
+  onSubmit = (event: SyntheticEvent<HTMLElement>) => {
     event.preventDefault();
 
     const threadType = this.state.threadType;
     invariant(
       threadType !== null,
       'threadType state should never be set to null',
     );
     if (threadType === undefined) {
       this.setState(
         {
           errorMessage: 'thread type unspecified',
         },
         () => {
           invariant(this.openPrivacyInput, 'openPrivacyInput ref unset');
           this.openPrivacyInput.focus();
         },
       );
       return;
     }
 
     this.props.dispatchActionPromise(
       newThreadActionTypes,
       this.newThreadAction(threadType),
     );
   };
 
   async newThreadAction(threadType: ThreadType) {
     const name = this.state.name.trim();
     try {
       invariant(
         threadType === 3 ||
           threadType === 4 ||
           threadType === 6 ||
           threadType === 7,
         "Sidebars and communities can't be created from the thread composer",
       );
       const query = this.props.calendarQuery();
       const response = await this.props.newThread({
         type: threadType,
         name,
         description: this.state.description,
         color: this.state.color,
         calendarQuery: query,
       });
       this.props.onClose();
       return response;
     } catch (e) {
       this.setState(
         {
           threadType: undefined,
           name: '',
           description: '',
           color: '',
           errorMessage: 'unknown error',
         },
         () => {
           invariant(this.nameInput, 'nameInput ref unset');
           this.nameInput.focus();
         },
       );
       throw e;
     }
   }
 }
 
 const loadingStatusSelector = createLoadingStatusSelector(newThreadActionTypes);
 
 const ConnectedNewThreadModal: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedNewThreadModal(props) {
     const { parentThreadID } = props;
     const parentThreadInfo: ?ThreadInfo = useSelector(state =>
       parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
     );
     invariant(
       !parentThreadID || parentThreadInfo,
       'parent thread should exist',
     );
     const inputDisabled = useSelector(loadingStatusSelector) === 'loading';
     const calendarQuery = useSelector(nonThreadCalendarQuery);
     const callNewThread = useServerCall(newThread);
     const dispatchActionPromise = useDispatchActionPromise();
 
     return (
       <NewThreadModal
         {...props}
         parentThreadInfo={parentThreadInfo}
         inputDisabled={inputDisabled}
         calendarQuery={calendarQuery}
         newThread={callNewThread}
         dispatchActionPromise={dispatchActionPromise}
       />
     );
   },
 );
 
 export default ConnectedNewThreadModal;
diff --git a/web/modals/threads/thread-settings-modal.react.js b/web/modals/threads/thread-settings-modal.react.js
index ccecf8d86..9c6dd264a 100644
--- a/web/modals/threads/thread-settings-modal.react.js
+++ b/web/modals/threads/thread-settings-modal.react.js
@@ -1,596 +1,599 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import _pickBy from 'lodash/fp/pickBy';
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   deleteThread,
   changeThreadSettingsActionTypes,
   changeThreadSettings,
 } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import {
   threadHasPermission,
   threadTypeDescriptions,
   robotextName,
 } from 'lib/shared/thread-utils';
 import {
   type ThreadInfo,
   threadTypes,
   assertThreadType,
   type ChangeThreadSettingsPayload,
   type UpdateThreadRequest,
   type LeaveThreadPayload,
   threadPermissions,
   type ThreadChanges,
 } from 'lib/types/thread-types';
 import type { UserInfos } from 'lib/types/user-types';
 import {
   useDispatchActionPromise,
   useServerCall,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils';
 import { firstLine } from 'lib/utils/string-utils';
 
+import Button from '../../components/button.react';
 import { useModalContext } from '../../modals/modal-provider.react';
 import { useSelector } from '../../redux/redux-utils';
 import css from '../../style.css';
 import Modal from '../modal.react';
 import ColorPicker from './color-picker.react';
 
 const { COMMUNITY_OPEN_SUBTHREAD, COMMUNITY_SECRET_SUBTHREAD } = threadTypes;
 
 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,
 };
 type Props = {
   ...BaseProps,
   +threadInfo: ThreadInfo,
   +changeInProgress: boolean,
   +viewerID: ?string,
   +userInfos: UserInfos,
   +dispatchActionPromise: DispatchActionPromise,
   +deleteThread: (
     threadID: string,
     currentAccountPassword: string,
   ) => Promise<LeaveThreadPayload>,
   +changeThreadSettings: (
     update: UpdateThreadRequest,
   ) => Promise<ChangeThreadSettingsPayload>,
   +onClose: () => void,
 };
 type State = {
   +queuedChanges: ThreadChanges,
   +errorMessage: string,
   +accountPassword: string,
   +currentTabType: TabType,
 };
 class ThreadSettingsModal extends React.PureComponent<Props, State> {
   nameInput: ?HTMLInputElement;
   newThreadPasswordInput: ?HTMLInputElement;
   accountPasswordInput: ?HTMLInputElement;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       queuedChanges: Object.freeze({}),
       errorMessage: '',
       accountPassword: '',
       currentTabType: 'general',
     };
   }
 
   componentDidMount() {
     invariant(this.nameInput, 'nameInput ref unset');
     this.nameInput.focus();
   }
 
   componentDidUpdate(prevProps: Props) {
     if (this.state.currentTabType !== 'delete') {
       return;
     }
 
     const permissionForDeleteTab = this.hasPermissionForTab(
       this.props.threadInfo,
       'delete',
     );
     const prevPermissionForDeleteTab = this.hasPermissionForTab(
       prevProps.threadInfo,
       'delete',
     );
 
     if (!permissionForDeleteTab && prevPermissionForDeleteTab) {
       this.setTab('general');
     }
   }
 
   hasPermissionForTab(threadInfo: ThreadInfo, tab: TabType) {
     if (tab === 'general') {
       return threadHasPermission(
         threadInfo,
         threadPermissions.EDIT_THREAD_NAME,
       );
     } else if (tab === 'privacy') {
       return threadHasPermission(
         threadInfo,
         threadPermissions.EDIT_PERMISSIONS,
       );
     } else if (tab === 'delete') {
       return threadHasPermission(threadInfo, threadPermissions.DELETE_THREAD);
     }
     invariant(false, `invalid tab ${tab}`);
   }
 
   possiblyChangedValue(key: string) {
     const valueChanged =
       this.state.queuedChanges[key] !== null &&
       this.state.queuedChanges[key] !== undefined;
     return valueChanged
       ? this.state.queuedChanges[key]
       : this.props.threadInfo[key];
   }
 
   namePlaceholder() {
     return robotextName(
       this.props.threadInfo,
       this.props.viewerID,
       this.props.userInfos,
     );
   }
 
   changeQueued() {
     return (
       Object.keys(
         _pickBy(
           value => value !== null && value !== undefined,
           // the lodash/fp libdef coerces the returned object's properties to the
           // same type, which means it only works for object-as-maps $FlowFixMe
         )(this.state.queuedChanges),
       ).length > 0
     );
   }
 
   render() {
     const { threadInfo } = this.props;
     const inputDisabled =
       this.props.changeInProgress ||
       !this.hasPermissionForTab(threadInfo, this.state.currentTabType);
 
     let mainContent = null;
     if (this.state.currentTabType === 'general') {
       mainContent = (
         <div>
           <div>
             <div className={css['form-title']}>Thread name</div>
             <div className={css['form-content']}>
               <input
                 type="text"
                 value={firstLine(this.possiblyChangedValue('name'))}
                 placeholder={this.namePlaceholder()}
                 onChange={this.onChangeName}
                 disabled={inputDisabled}
                 ref={this.nameInputRef}
               />
             </div>
           </div>
           <div className={css['form-textarea-container']}>
             <div className={css['form-title']}>Description</div>
             <div className={css['form-content']}>
               <textarea
                 value={this.possiblyChangedValue('description')}
                 placeholder="Thread description"
                 onChange={this.onChangeDescription}
                 disabled={inputDisabled}
               ></textarea>
             </div>
           </div>
           <div className={css['edit-thread-color-container']}>
             <div className={`${css['form-title']} ${css['color-title']}`}>
               Color
             </div>
             <div className={css['form-content']}>
               <ColorPicker
                 id="edit-thread-color"
                 value={this.possiblyChangedValue('color')}
                 disabled={inputDisabled}
                 onChange={this.onChangeColor}
               />
             </div>
           </div>
         </div>
       );
     } else if (this.state.currentTabType === 'privacy') {
       mainContent = (
         <div className={css['edit-thread-privacy-container']}>
           <div className={css['modal-radio-selector']}>
             <div className={css['form-title']}>Thread type</div>
             <div className={css['form-enum-selector']}>
               <div className={css['form-enum-container']}>
                 <input
                   type="radio"
                   name="edit-thread-type"
                   id="edit-thread-open"
                   value={COMMUNITY_OPEN_SUBTHREAD}
                   checked={
                     this.possiblyChangedValue('type') ===
                     COMMUNITY_OPEN_SUBTHREAD
                   }
                   onChange={this.onChangeThreadType}
                   disabled={inputDisabled}
                 />
                 <div className={css['form-enum-option']}>
                   <label htmlFor="edit-thread-open">
                     Open
                     <span className={css['form-enum-description']}>
                       {threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD]}
                     </span>
                   </label>
                 </div>
               </div>
               <div className={css['form-enum-container']}>
                 <input
                   type="radio"
                   name="edit-thread-type"
                   id="edit-thread-closed"
                   value={COMMUNITY_SECRET_SUBTHREAD}
                   checked={
                     this.possiblyChangedValue('type') ===
                     COMMUNITY_SECRET_SUBTHREAD
                   }
                   onChange={this.onChangeThreadType}
                   disabled={inputDisabled}
                 />
                 <div className={css['form-enum-option']}>
                   <label htmlFor="edit-thread-closed">
                     Secret
                     <span className={css['form-enum-description']}>
                       {threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD]}
                     </span>
                   </label>
                 </div>
               </div>
             </div>
           </div>
         </div>
       );
     } else if (this.state.currentTabType === 'delete') {
       mainContent = (
         <>
           <div>
             <p className={css['italic']}>
               Your thread will be permanently deleted. There is no way to
               reverse this.
             </p>
           </div>
           <div className={css['edit-thread-account-password']}>
             <p className={css['confirm-account-password']}>
               Please enter your account password to confirm your identity
             </p>
             <div className={css['form-title']}>Account password</div>
             <div className={css['form-content']}>
               <input
                 type="password"
                 placeholder="Personal account password"
                 value={this.state.accountPassword}
                 onChange={this.onChangeAccountPassword}
                 disabled={inputDisabled}
                 ref={this.accountPasswordInputRef}
               />
             </div>
           </div>
         </>
       );
     }
 
     let buttons = null;
     if (this.state.currentTabType === 'delete') {
       buttons = (
-        <input
-          type="submit"
-          value="Delete"
+        <Button
           onClick={this.onDelete}
+          variant="danger"
           disabled={inputDisabled}
-        />
+        >
+          Delete
+        </Button>
       );
     } else {
       buttons = (
-        <input
+        <Button
           type="submit"
-          value="Save"
           onClick={this.onSubmit}
           disabled={inputDisabled || !this.changeQueued()}
-        />
+        >
+          Save
+        </Button>
       );
     }
 
     const tabs = [
       <Tab
         name="General"
         tabType="general"
         onClick={this.setTab}
         selected={this.state.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 =
       this.possiblyChangedValue('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={this.setTab}
           selected={this.state.currentTabType === 'privacy'}
           key="privacy"
         />,
       );
     }
     const canDeleteThread = this.hasPermissionForTab(threadInfo, 'delete');
     if (canDeleteThread) {
       tabs.push(
         <Tab
           name="Delete"
           tabType="delete"
           onClick={this.setTab}
           selected={this.state.currentTabType === 'delete'}
           key="delete"
         />,
       );
     }
 
     return (
       <Modal name="Thread settings" onClose={this.props.onClose} size="large">
         <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']}>
                 {this.state.errorMessage}
               </div>
             </div>
           </form>
         </div>
       </Modal>
     );
   }
 
   setTab = (tabType: TabType) => {
     this.setState({ currentTabType: tabType });
   };
 
   nameInputRef = (nameInput: ?HTMLInputElement) => {
     this.nameInput = nameInput;
   };
 
   newThreadPasswordInputRef = (newThreadPasswordInput: ?HTMLInputElement) => {
     this.newThreadPasswordInput = newThreadPasswordInput;
   };
 
   accountPasswordInputRef = (accountPasswordInput: ?HTMLInputElement) => {
     this.accountPasswordInput = accountPasswordInput;
   };
 
   onChangeName = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.currentTarget;
     const newValue =
       target.value !== this.props.threadInfo.name ? target.value : undefined;
     this.setState((prevState: State) => ({
       ...prevState,
       queuedChanges: {
         ...prevState.queuedChanges,
         name: firstLine(newValue),
       },
     }));
   };
 
   onChangeDescription = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     const target = event.currentTarget;
     const newValue =
       target.value !== this.props.threadInfo.description
         ? target.value
         : undefined;
     this.setState((prevState: State) => ({
       ...prevState,
       queuedChanges: {
         ...prevState.queuedChanges,
         description: newValue,
       },
     }));
   };
 
   onChangeColor = (color: string) => {
     const newValue = color !== this.props.threadInfo.color ? color : undefined;
     this.setState((prevState: State) => ({
       ...prevState,
       queuedChanges: {
         ...prevState.queuedChanges,
         color: newValue,
       },
     }));
   };
 
   onChangeThreadType = (event: SyntheticEvent<HTMLInputElement>) => {
     const uiValue = assertThreadType(parseInt(event.currentTarget.value, 10));
     const newValue =
       uiValue !== this.props.threadInfo.type ? uiValue : undefined;
     this.setState((prevState: State) => ({
       ...prevState,
       queuedChanges: {
         ...prevState.queuedChanges,
         type: newValue,
       },
     }));
   };
 
   onChangeAccountPassword = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.currentTarget;
     this.setState({ accountPassword: target.value });
   };
 
-  onSubmit = (event: SyntheticEvent<HTMLInputElement>) => {
+  onSubmit = (event: SyntheticEvent<HTMLElement>) => {
     event.preventDefault();
     this.props.dispatchActionPromise(
       changeThreadSettingsActionTypes,
       this.changeThreadSettingsAction(),
     );
   };
 
   async changeThreadSettingsAction() {
     try {
       const response = await this.props.changeThreadSettings({
         threadID: this.props.threadInfo.id,
         changes: this.state.queuedChanges,
       });
       this.props.onClose();
       return response;
     } catch (e) {
       this.setState(
         prevState => ({
           ...prevState,
           queuedChanges: Object.freeze({}),
           accountPassword: '',
           errorMessage: 'unknown error',
           currentTabType: 'general',
         }),
         () => {
           invariant(this.nameInput, 'nameInput ref unset');
           this.nameInput.focus();
         },
       );
       throw e;
     }
   }
 
-  onDelete = (event: SyntheticEvent<HTMLInputElement>) => {
+  onDelete = (event: SyntheticEvent<HTMLElement>) => {
     event.preventDefault();
     this.props.dispatchActionPromise(
       deleteThreadActionTypes,
       this.deleteThreadAction(),
     );
   };
 
   async deleteThreadAction() {
     try {
       const response = await this.props.deleteThread(
         this.props.threadInfo.id,
         this.state.accountPassword,
       );
       this.props.onClose();
       return response;
     } catch (e) {
       const errorMessage =
         e.message === 'invalid_credentials'
           ? 'wrong password'
           : 'unknown error';
       this.setState(
         {
           accountPassword: '',
           errorMessage: errorMessage,
         },
         () => {
           invariant(
             this.accountPasswordInput,
             'accountPasswordInput ref unset',
           );
           this.accountPasswordInput.focus();
         },
       );
       throw e;
     }
   }
 }
 
 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 callDeleteThread = useServerCall(deleteThread);
     const callChangeThreadSettings = useServerCall(changeThreadSettings);
     const dispatchActionPromise = useDispatchActionPromise();
     const threadInfo: ?ThreadInfo = useSelector(
       state => threadInfoSelector(state)[props.threadID],
     );
     const modalContext = useModalContext();
 
     if (!threadInfo) {
       return (
         <Modal onClose={modalContext.clearModal} name="Invalid thread">
           <div className={css['modal-body']}>
             <p>You no longer have permission to view this thread</p>
           </div>
         </Modal>
       );
     }
 
     return (
       <ThreadSettingsModal
         {...props}
         threadInfo={threadInfo}
         changeInProgress={changeInProgress}
         viewerID={viewerID}
         userInfos={userInfos}
         deleteThread={callDeleteThread}
         changeThreadSettings={callChangeThreadSettings}
         dispatchActionPromise={dispatchActionPromise}
         onClose={modalContext.clearModal}
       />
     );
   },
 );
 
 export default ConnectedThreadSettingsModal;
diff --git a/web/splash/splash.react.js b/web/splash/splash.react.js
index 548ba6c2d..98de90329 100644
--- a/web/splash/splash.react.js
+++ b/web/splash/splash.react.js
@@ -1,282 +1,283 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   requestAccessActionTypes,
   requestAccess,
 } from 'lib/actions/user-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { validEmailRegex } from 'lib/shared/account-utils';
 import type { AccessRequest } from 'lib/types/account-types';
 import { type DeviceType, assertDeviceType } from 'lib/types/device-types';
 import { type LoadingStatus } from 'lib/types/loading-types';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils';
 
+import Button from '../components/button.react';
 import LoadingIndicator from '../loading-indicator.react';
 import LogInModal from '../modals/account/log-in-modal.react';
 import { useModalContext } from '../modals/modal-provider.react';
 import { useSelector } from '../redux/redux-utils';
 import css from './splash.css';
 
 const defaultRequestAccessScrollHeight = 390;
 
 type Props = {
   +loadingStatus: LoadingStatus,
   +dispatchActionPromise: DispatchActionPromise,
   +requestAccess: (accessRequest: AccessRequest) => Promise<void>,
   +setModal: (modal: React.Node) => void,
   +modal: ?React.Node,
 };
 type State = {
   +platform: DeviceType,
   +email: string,
   +error: ?string,
   +success: ?string,
 };
 class Splash extends React.PureComponent<Props, State> {
   emailInput: ?HTMLInputElement;
   bottomContainer: ?HTMLDivElement;
   state: State = {
     platform: 'ios',
     email: '',
     error: null,
     success: null,
   };
 
   componentDidMount() {
     if ('scrollRestoration' in history) {
       history.scrollRestoration = 'manual';
     }
   }
 
   render() {
     let androidWarning = null;
     if (this.state.platform === 'android') {
       androidWarning = (
         <p className={css.androidWarning}>
           Make sure this is the email you use to log in to the Google Play
           Store!
         </p>
       );
     }
     let error = null;
     if (this.state.error) {
       error = <p className={css.requestAccessError}>{this.state.error}</p>;
     }
     let success = null;
     if (this.state.success) {
       success = (
         <p className={css.requestAccessSuccess}>{this.state.success}</p>
       );
     }
     let submitButtonContent = 'Submit';
     if (this.props.loadingStatus === 'loading') {
       submitButtonContent = (
         <LoadingIndicator status={this.props.loadingStatus} />
       );
     }
     return (
       <React.Fragment>
         <div className={css.headerContainer}>
           <div className={css.top}>
             <header className={css.header}>
               <div className={css.headerContents}>
                 <h1>Comm</h1>
                 <div className={css.actionLinks}>
                   <a href="#" onClick={this.onClickRequestAccess}>
                     <span className={css.requestAccess}>Request access</span>
                   </a>
                   <a href="#" onClick={this.onClickLogIn}>
                     <span>Log in</span>
                   </a>
                 </div>
               </div>
             </header>
           </div>
         </div>
         <div className={css.content}>
           <div className={css.topContainer}>
             <div className={css.top}>
               <div className={css.body}>
                 <div className={css.intro}>
                   <p className={css.introHeader}>
                     Comm is a chat app with an integrated calendar.
                   </p>
                   <p className={css.introDescription}>
                     We make it incredibly easy to plan events with your friends.
                   </p>
                 </div>
                 <div className={css.devices}>
                   <img
                     src="images/ios_screenshot.png"
                     srcSet="images/ios_screenshot@2x.png 526w"
                     width={263}
                     height={527}
                   />
                   <img
                     src="images/android_screenshot.png"
                     srcSet="images/android_screenshot@2x.png 570w"
                     width={285}
                     height={527}
                   />
                 </div>
               </div>
             </div>
           </div>
           <div className={css.bottomContainer} ref={this.bottomContainerRef}>
             <div className={css.bottom}>
               <div className={css.headerRest}>
                 <div className={css.prompt}>
                   <p className={css.promptHeader}>
                     We&apos;re currently alpha testing the first version of our
                     app.
                   </p>
                   <p className={css.promptDescription}>
                     If you&apos;d like to try it out, please let us know!
                   </p>
                   <div className={css.requestAccessContainer}>
                     <div>
                       <form className={css.requestAccessForm}>
                         <input
                           type="text"
                           value={this.state.email}
                           onChange={this.onChangeEmail}
                           placeholder="Email address"
                           className={css.requestAccessEmail}
                           ref={this.emailInputRef}
                         />
                         <div className={css.customSelect}>
                           <select onChange={this.onChangePlatform}>
                             <option value="ios">iOS</option>
                             <option value="android">Android</option>
                           </select>
                         </div>
-                        <button
+                        <Button
                           type="submit"
                           className={css.requestAccessSubmit}
                           onClick={this.onSubmitRequestAccess}
                         >
                           {submitButtonContent}
-                        </button>
+                        </Button>
                       </form>
                       {androidWarning}
                     </div>
                     {error}
                     {success}
                   </div>
                 </div>
               </div>
               <div className={css.headerOverscroll} />
             </div>
           </div>
         </div>
         {this.props.modal}
       </React.Fragment>
     );
   }
 
   bottomContainerRef = (bottomContainer: ?HTMLDivElement) => {
     this.bottomContainer = bottomContainer;
   };
 
   emailInputRef = (emailInput: ?HTMLInputElement) => {
     this.emailInput = emailInput;
   };
 
   onChangeEmail = (event: SyntheticEvent<HTMLInputElement>) => {
     this.setState({ email: event.currentTarget.value });
   };
 
   onChangePlatform = (event: SyntheticEvent<HTMLSelectElement>) => {
     this.setState({ platform: assertDeviceType(event.currentTarget.value) });
   };
 
   onClickLogIn = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     this.props.setModal(<LogInModal />);
   };
 
   onClickRequestAccess = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const { bottomContainer } = this;
     invariant(bottomContainer, 'bottomContainer should exist');
     const formHeight = 180;
     const contentHeight = 790;
     const guaranteesSpace = contentHeight - window.innerHeight + formHeight;
     if (bottomContainer.scrollTop < guaranteesSpace) {
       bottomContainer.scrollTop = Math.max(
         defaultRequestAccessScrollHeight,
         guaranteesSpace,
       );
     }
     if (this.emailInput) {
       this.emailInput.focus();
     }
   };
 
-  onSubmitRequestAccess = (event: SyntheticEvent<HTMLInputElement>) => {
+  onSubmitRequestAccess = (event: SyntheticEvent<HTMLElement>) => {
     event.preventDefault();
 
     if (this.state.email.search(validEmailRegex) === -1) {
       this.setState({ success: null, error: 'Please enter a valid email!' });
       invariant(this.emailInput, 'should be set');
       this.emailInput.focus();
       return;
     }
 
     this.props.dispatchActionPromise(
       requestAccessActionTypes,
       this.requestAccessAction(),
     );
   };
 
   async requestAccessAction() {
     try {
       await this.props.requestAccess({
         email: this.state.email,
         platform: this.state.platform,
       });
       this.setState({
         success:
           "Thanks for your interest! We'll let you know as soon as " +
           "we're able to extend an invite.",
         error: null,
       });
     } catch (e) {
       this.setState({ success: null, error: 'Unknown error...' });
       throw e;
     }
   }
 }
 
 const loadingStatusSelector = createLoadingStatusSelector(
   requestAccessActionTypes,
 );
 
 const ConnectedSplash: React.ComponentType<{}> = React.memo<{}>(
   function ConnectedSplash(): React.Node {
     const loadingStatus = useSelector(loadingStatusSelector);
     const callRequestAccess = useServerCall(requestAccess);
     const dispatchActionPromise = useDispatchActionPromise();
 
     const modalContext = useModalContext();
 
     return (
       <Splash
         loadingStatus={loadingStatus}
         requestAccess={callRequestAccess}
         dispatchActionPromise={dispatchActionPromise}
         setModal={modalContext.setModal}
         modal={modalContext.modal}
       />
     );
   },
 );
 
 export default ConnectedSplash;