diff --git a/src/components/App/DefaultState.ts b/src/components/App/DefaultState.ts
index 1290da98da..1294ddf45d 100644
--- a/src/components/App/DefaultState.ts
+++ b/src/components/App/DefaultState.ts
@@ -2,7 +2,6 @@ import { defaultState as goalTimelineState } from "components/GoalTimeline/Defau
 import { defaultState as loginState } from "components/Login/Redux/LoginReducer";
 import { defaultState as currentProjectState } from "components/Project/ProjectReduxTypes";
 import { defaultState as exportProjectState } from "components/ProjectExport/Redux/ExportProjectReduxTypes";
-import { defaultState as createProjectState } from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
 import { defaultState as pronunciationsState } from "components/Pronunciations/Redux/PronunciationsReduxTypes";
 import { defaultState as treeViewState } from "components/TreeView/Redux/TreeViewReduxTypes";
 import { defaultState as characterInventoryState } from "goals/CharacterInventory/Redux/CharacterInventoryReducer";
@@ -15,10 +14,6 @@ export const defaultState = {
   loginState: { ...loginState },
 
   //project
-  createProjectState: {
-    ...createProjectState,
-    success: true,
-  },
   currentProjectState: { ...currentProjectState },
   exportProjectState: { ...exportProjectState },
 
diff --git a/src/components/DataEntry/DataEntryTable/index.tsx b/src/components/DataEntry/DataEntryTable/index.tsx
index 5ebc1bc007..e3d37e5e0e 100644
--- a/src/components/DataEntry/DataEntryTable/index.tsx
+++ b/src/components/DataEntry/DataEntryTable/index.tsx
@@ -865,9 +865,12 @@ export default function DataEntryTable(
         </Grid>
 
         {state.recentWords.map((wordAccess, index) => (
-          <Grid item xs={12} key={index}>
+          <Grid
+            item
+            key={`${wordAccess.word.id}_${wordAccess.senseGuid}`}
+            xs={12}
+          >
             <RecentEntry
-              key={wordAccess.word.id + "_" + wordAccess.senseGuid}
               rowIndex={index}
               entry={wordAccess.word}
               senseGuid={wordAccess.senseGuid}
diff --git a/src/components/GoalTimeline/GoalList.tsx b/src/components/GoalTimeline/GoalList.tsx
index f5baac7ffe..d576bab38b 100644
--- a/src/components/GoalTimeline/GoalList.tsx
+++ b/src/components/GoalTimeline/GoalList.tsx
@@ -55,6 +55,9 @@ export default function GoalList(props: GoalListProps): ReactElement {
   const [scrollVisible, setScrollVisible] = useState<boolean | undefined>();
   const tileSize = props.size / 3 - 1.25;
 
+  const id = (g: Goal): string =>
+    props.completed ? `completed-goal-${g.guid}` : `new-goal-${g.name}`;
+
   return (
     <ImageList
       style={gridStyle(props.orientation, props.size, scrollVisible)}
@@ -62,17 +65,19 @@ export default function GoalList(props: GoalListProps): ReactElement {
       onMouseOver={() => setScrollVisible(props.scrollable)}
       onMouseLeave={() => setScrollVisible(false)}
     >
-      {props.data.length > 0
-        ? props.data.map((g, i) => {
-            const buttonProps = {
-              id: props.completed
-                ? `completed-goal-${i}`
-                : `new-goal-${g.name}`,
-              onClick: () => props.handleChange(g),
-            };
-            return makeGoalTile(tileSize, props.orientation, g, buttonProps);
-          })
-        : makeGoalTile(tileSize, props.orientation)}
+      {props.data.length > 0 ? (
+        props.data.map((g) => (
+          <GoalTile
+            buttonProps={{ id: id(g), onClick: () => props.handleChange(g) }}
+            goal={g}
+            key={g.guid || g.name}
+            orientation={props.orientation}
+            size={tileSize}
+          />
+        ))
+      ) : (
+        <GoalTile size={tileSize} orientation={props.orientation} />
+      )}
       <div
         ref={(element: HTMLDivElement) => {
           if (props.scrollToEnd && element) {
@@ -93,19 +98,22 @@ function buttonStyle(orientation: Orientation, size: number): CSSProperties {
   }
 }
 
-export function makeGoalTile(
-  size: number,
-  orientation: Orientation,
-  goal?: Goal,
-  buttonProps?: ButtonProps
-): ReactElement {
+interface GoalTileProps {
+  buttonProps?: ButtonProps;
+  goal?: Goal;
+  orientation: Orientation;
+  size: number;
+}
+
+function GoalTile(props: GoalTileProps): ReactElement {
+  const goal = props.goal;
   return (
-    <ImageListItem key={goal?.guid + orientation} cols={1}>
+    <ImageListItem cols={1}>
       <Button
-        {...buttonProps}
+        {...props.buttonProps}
         color="primary"
         variant={goal ? "outlined" : "contained"}
-        style={buttonStyle(orientation, size)}
+        style={buttonStyle(props.orientation, props.size)}
         disabled={
           /* Hide completed, except goalTypes for which the completed view is implemented. */
           !goal ||
@@ -125,6 +133,7 @@ export function makeGoalTile(
 interface GoalInfoProps {
   goal?: Goal;
 }
+
 function GoalInfo(props: GoalInfoProps): ReactElement {
   const { t } = useTranslation();
 
diff --git a/src/components/GoalTimeline/tests/GoalRedux.test.tsx b/src/components/GoalTimeline/tests/GoalRedux.test.tsx
index b6d1d03ff1..7803d39800 100644
--- a/src/components/GoalTimeline/tests/GoalRedux.test.tsx
+++ b/src/components/GoalTimeline/tests/GoalRedux.test.tsx
@@ -2,7 +2,7 @@ import "@testing-library/jest-dom";
 import { act, cleanup } from "@testing-library/react";
 
 import "tests/reactI18nextMock";
-import { MergeUndoIds, Permission, User, UserEdit } from "api/models";
+import { Edit, MergeUndoIds, Permission, User, UserEdit } from "api/models";
 import * as LocalStorage from "backend/localStorage";
 import GoalTimeline from "components/GoalTimeline";
 import {
@@ -64,20 +64,21 @@ const mockUpdateUser = jest.fn();
 function setMockFunctions(): void {
   mockAddGoalToUserEdit.mockResolvedValue(0);
   mockAddStepToGoal.mockResolvedValue(0);
-  mockCreateUserEdit.mockResolvedValue(mockUser);
+  mockCreateUserEdit.mockResolvedValue(mockUser());
   mockGetCurrentPermissions.mockResolvedValue([
     Permission.CharacterInventory,
     Permission.MergeAndReviewEntries,
   ]);
   mockGetDuplicates.mockResolvedValue(goalDataMock.plannedWords);
   mockGetGraylistEntries.mockResolvedValue([]);
-  mockGetUser.mockResolvedValue(mockUser);
-  mockGetUserEditById.mockResolvedValue(mockUserEdit);
-  mockUpdateUser.mockResolvedValue(mockUser);
+  mockGetUser.mockResolvedValue(mockUser());
+  mockGetUserEditById.mockResolvedValue(mockUserEdit(true));
+  mockUpdateUser.mockResolvedValue(mockUser());
 }
 
 const mockProjectId = "123";
 const mockUserEditId = "456";
+const mockUserId = "789";
 const mockCompletedMerge: MergeUndoIds = {
   parentIds: ["1", "2"],
   childIds: ["3", "4"],
@@ -86,34 +87,31 @@ const mockCharInvChanges: CharacterChange[] = [
   ["'", CharacterStatus.Undecided, CharacterStatus.Accepted],
 ];
 
-const mockUserEdit: UserEdit = {
-  id: mockUserEditId,
-  edits: [
-    {
-      guid: "edit-guid",
-      goalType: 4,
-      stepData: [],
-      changes: JSON.stringify(mockCompletedMerge),
-    },
-  ],
-  projectId: "",
-};
-const mockNoUserEdits: UserEdit = {
+const mockEdit = (): Edit => ({
+  changes: JSON.stringify(mockCompletedMerge),
+  goalType: 4,
+  guid: "edit-guid",
+  stepData: [],
+});
+const mockUserEdit = (hasEdit: boolean): UserEdit => ({
+  edits: hasEdit ? [mockEdit()] : [],
   id: mockUserEditId,
-  edits: [],
-  projectId: "",
-};
-const mockUserId = "789";
-const mockUser = newUser("First Last", "username");
-mockUser.id = mockUserId;
-mockUser.workedProjects[mockProjectId] = mockUserEditId;
+  projectId: mockProjectId,
+});
+const mockUser = (): User => ({
+  ...newUser("First Last", "username"),
+  id: mockUserId,
+  workedProjects: { [mockProjectId]: mockUserEditId },
+});
 
 function setupLocalStorage(): void {
-  LocalStorage.setCurrentUser(mockUser);
+  LocalStorage.setCurrentUser(mockUser());
   LocalStorage.setProjectId(mockProjectId);
 }
 
 beforeEach(() => {
+  // Restore any spied functions before clearing all
+  jest.restoreAllMocks();
   jest.clearAllMocks();
   setMockFunctions();
   setupLocalStorage();
@@ -140,10 +138,12 @@ describe("asyncGetUserEdits", () => {
     await act(async () => {
       renderWithProviders(<GoalTimeline />, { store: store });
     });
-    const convertGoalToEditSpy = jest.spyOn(goalUtilities, "convertEditToGoal");
-    await store.dispatch(asyncGetUserEdits());
+    const convertEditToGoalSpy = jest.spyOn(goalUtilities, "convertEditToGoal");
+    await act(async () => {
+      await store.dispatch(asyncGetUserEdits());
+    });
     expect(store.getState().goalsState.history).toHaveLength(1);
-    expect(convertGoalToEditSpy).toBeCalledTimes(1);
+    expect(convertEditToGoalSpy).toBeCalledTimes(1);
   });
 
   it("backend returns no user edits", async () => {
@@ -155,23 +155,26 @@ describe("asyncGetUserEdits", () => {
 
     // setup mocks for testing the action/reducers
     jest.clearAllMocks();
-    const convertGoalToEditSpy = jest.spyOn(goalUtilities, "convertEditToGoal");
-    mockGetUserEditById.mockResolvedValueOnce(mockNoUserEdits);
+    const convertEditToGoalSpy = jest.spyOn(goalUtilities, "convertEditToGoal");
+    mockGetUserEditById.mockResolvedValueOnce(mockUserEdit(false));
 
     // dispatch the action
-    await store.dispatch(asyncGetUserEdits());
+    await act(async () => {
+      await store.dispatch(asyncGetUserEdits());
+    });
     expect(store.getState().goalsState.history).toHaveLength(0);
-    expect(convertGoalToEditSpy).toBeCalledTimes(0);
+    expect(convertEditToGoalSpy).toBeCalledTimes(0);
   });
 
   it("creates new user edits", async () => {
     const store = setupStore();
-
     await act(async () => {
       renderWithProviders(<GoalTimeline />, { store: store });
     });
-    LocalStorage.setCurrentUser(newUser("", ""));
-    await store.dispatch(asyncGetUserEdits());
+    LocalStorage.setCurrentUser(newUser());
+    await act(async () => {
+      await store.dispatch(asyncGetUserEdits());
+    });
     expect(store.getState().goalsState.history).toHaveLength(0);
     expect(mockCreateUserEdit).toBeCalledTimes(1);
   });
@@ -186,7 +189,7 @@ describe("asyncAddGoal", () => {
 
     const goal = new MergeDups();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     // verify the new goal was loaded
     const currentGoal = store.getState().goalsState.currentGoal as MergeDups;
@@ -207,7 +210,7 @@ describe("asyncAddGoal", () => {
 
     const goal = new CreateCharInv();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     // verify the new goal was loaded
     const currentGoal = store.getState().goalsState
@@ -233,7 +236,7 @@ describe("asyncAdvanceStep", () => {
     // create mergeDups goal
     const goal = new MergeDups();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     let currentGoal = store.getState().goalsState.currentGoal as MergeDups;
     expect(currentGoal.currentStep).toBe(0);
@@ -243,7 +246,7 @@ describe("asyncAdvanceStep", () => {
     for (let i = 0; i < numSteps - 1; i++) {
       // dispatch asyncAdvanceStep
       await act(async () => {
-        store.dispatch(asyncAdvanceStep());
+        await store.dispatch(asyncAdvanceStep());
       });
       // verify current step is incremented each time
       currentGoal = store.getState().goalsState.currentGoal as MergeDups;
@@ -253,7 +256,7 @@ describe("asyncAdvanceStep", () => {
     }
     // iterate past the last step
     await act(async () => {
-      store.dispatch(asyncAdvanceStep());
+      await store.dispatch(asyncAdvanceStep());
     });
     expect(store.getState().goalsState.currentGoal.currentStep).toBe(7);
     expect(mockNavigate).toHaveBeenCalledWith(Path.GoalNext);
@@ -268,12 +271,12 @@ describe("asyncAdvanceStep", () => {
     // create character inventory goal
     const goal = new CreateCharInv();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     expect(store.getState().goalsState.currentGoal.numSteps).toBe(1);
     // iterate past the last step
     await act(async () => {
-      store.dispatch(asyncAdvanceStep());
+      await store.dispatch(asyncAdvanceStep());
     });
     expect(store.getState().goalsState.currentGoal.currentStep).toBe(0);
     expect(mockNavigate).toHaveBeenCalledWith(Path.Goals);
@@ -290,9 +293,9 @@ describe("asyncUpdateGoal", () => {
     // create CreateCharInv goal
     const goal = new CreateCharInv();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
+      store.dispatch(addCharInvChangesToGoal(mockCharInvChanges));
     });
-    store.dispatch(addCharInvChangesToGoal(mockCharInvChanges));
     const changes = store.getState().goalsState.currentGoal
       .changes as CharInvChanges;
     expect(changes!.charChanges).toBe(mockCharInvChanges);
@@ -314,7 +317,7 @@ describe("asyncUpdateGoal", () => {
     // create MergeDups goal
     const goal = new MergeDups();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     // dispatch asyncUpdateGoal()
     await act(async () => {
@@ -339,7 +342,7 @@ describe("asyncUpdateGoal", () => {
     // create ReviewDeferredDups goal
     const goal = new ReviewDeferredDups();
     await act(async () => {
-      store.dispatch(asyncAddGoal(goal));
+      await store.dispatch(asyncAddGoal(goal));
     });
     // dispatch asyncUpdateGoal()
     await act(async () => {
diff --git a/src/components/ProjectExport/Redux/ExportProjectActions.ts b/src/components/ProjectExport/Redux/ExportProjectActions.ts
index cfea4ba26a..8bd8488ff1 100644
--- a/src/components/ProjectExport/Redux/ExportProjectActions.ts
+++ b/src/components/ProjectExport/Redux/ExportProjectActions.ts
@@ -1,10 +1,39 @@
+import { Action, PayloadAction } from "@reduxjs/toolkit";
+
 import { deleteLift, downloadLift, exportLift } from "backend";
 import {
-  ExportProjectAction,
-  ExportStatus,
-} from "components/ProjectExport/Redux/ExportProjectReduxTypes";
+  downloadingAction,
+  exportingAction,
+  failureAction,
+  resetAction,
+  successAction,
+} from "components/ProjectExport/Redux//ExportProjectReducer";
 import { StoreStateDispatch } from "types/Redux/actions";
 
+// Action Creation Functions
+
+export function exporting(projectId: string): PayloadAction {
+  return exportingAction(projectId);
+}
+
+export function downloading(projectId: string): PayloadAction {
+  return downloadingAction(projectId);
+}
+
+export function failure(projectId: string): PayloadAction {
+  return failureAction(projectId);
+}
+
+export function reset(): Action {
+  return resetAction();
+}
+
+export function success(projectId: string): PayloadAction {
+  return successAction(projectId);
+}
+
+// Dispatch Functions
+
 export function asyncExportProject(projectId: string) {
   return async (dispatch: StoreStateDispatch) => {
     dispatch(exporting(projectId));
@@ -27,31 +56,3 @@ export function asyncResetExport() {
     await deleteLift();
   };
 }
-
-function exporting(projectId: string): ExportProjectAction {
-  return {
-    type: ExportStatus.Exporting,
-    projectId,
-  };
-}
-function downloading(projectId: string): ExportProjectAction {
-  return {
-    type: ExportStatus.Downloading,
-    projectId,
-  };
-}
-export function success(projectId: string): ExportProjectAction {
-  return {
-    type: ExportStatus.Success,
-    projectId,
-  };
-}
-export function failure(projectId: string): ExportProjectAction {
-  return {
-    type: ExportStatus.Failure,
-    projectId,
-  };
-}
-function reset(): ExportProjectAction {
-  return { type: ExportStatus.Default };
-}
diff --git a/src/components/ProjectExport/Redux/ExportProjectReducer.ts b/src/components/ProjectExport/Redux/ExportProjectReducer.ts
index 6306fe529a..d830a50508 100644
--- a/src/components/ProjectExport/Redux/ExportProjectReducer.ts
+++ b/src/components/ProjectExport/Redux/ExportProjectReducer.ts
@@ -1,29 +1,43 @@
+import { createSlice } from "@reduxjs/toolkit";
+
 import {
   defaultState,
-  ExportProjectAction,
-  ExportProjectState,
   ExportStatus,
 } from "components/ProjectExport/Redux/ExportProjectReduxTypes";
-import { StoreAction, StoreActionTypes } from "rootActions";
+import { StoreActionTypes } from "rootActions";
+
+const exportProjectSlice = createSlice({
+  name: "exportProjectState",
+  initialState: defaultState,
+  reducers: {
+    downloadingAction: (state, action) => {
+      state.projectId = action.payload;
+      state.status = ExportStatus.Downloading;
+    },
+    exportingAction: (state, action) => {
+      state.projectId = action.payload;
+      state.status = ExportStatus.Exporting;
+    },
+    failureAction: (state, action) => {
+      state.projectId = action.payload;
+      state.status = ExportStatus.Failure;
+    },
+    resetAction: () => defaultState,
+    successAction: (state, action) => {
+      state.projectId = action.payload;
+      state.status = ExportStatus.Success;
+    },
+  },
+  extraReducers: (builder) =>
+    builder.addCase(StoreActionTypes.RESET, () => defaultState),
+});
+
+export const {
+  downloadingAction,
+  exportingAction,
+  failureAction,
+  resetAction,
+  successAction,
+} = exportProjectSlice.actions;
 
-export const exportProjectReducer = (
-  state: ExportProjectState = defaultState,
-  action: StoreAction | ExportProjectAction
-): ExportProjectState => {
-  switch (action.type) {
-    case ExportStatus.Exporting:
-    case ExportStatus.Downloading:
-    case ExportStatus.Success:
-    case ExportStatus.Failure:
-      return {
-        ...defaultState,
-        projectId: action.projectId ?? "",
-        status: action.type,
-      };
-    case ExportStatus.Default:
-    case StoreActionTypes.RESET:
-      return defaultState;
-    default:
-      return state;
-  }
-};
+export default exportProjectSlice.reducer;
diff --git a/src/components/ProjectExport/Redux/ExportProjectReduxTypes.ts b/src/components/ProjectExport/Redux/ExportProjectReduxTypes.ts
index 6b910ca38a..3725b60e9d 100644
--- a/src/components/ProjectExport/Redux/ExportProjectReduxTypes.ts
+++ b/src/components/ProjectExport/Redux/ExportProjectReduxTypes.ts
@@ -6,11 +6,6 @@ export enum ExportStatus {
   Failure = "FAILURE",
 }
 
-export interface ExportProjectAction {
-  type: ExportStatus;
-  projectId?: string;
-}
-
 export interface ExportProjectState {
   projectId: string;
   status: ExportStatus;
diff --git a/src/components/ProjectExport/Redux/tests/ExportProjectActions.test.tsx b/src/components/ProjectExport/Redux/tests/ExportProjectActions.test.tsx
new file mode 100644
index 0000000000..5ff440a77a
--- /dev/null
+++ b/src/components/ProjectExport/Redux/tests/ExportProjectActions.test.tsx
@@ -0,0 +1,85 @@
+import { PreloadedState } from "redux";
+
+import { defaultState } from "components/App/DefaultState";
+import {
+  asyncDownloadExport,
+  asyncExportProject,
+  asyncResetExport,
+} from "components/ProjectExport/Redux/ExportProjectActions";
+import { ExportStatus } from "components/ProjectExport/Redux/ExportProjectReduxTypes";
+import { RootState, setupStore } from "store";
+
+jest.mock("backend", () => ({
+  deleteLift: jest.fn,
+  downloadLift: (...args: any[]) => mockDownloadList(...args),
+  exportLift: (...args: any[]) => mockExportLift(...args),
+}));
+
+const mockDownloadList = jest.fn();
+const mockExportLift = jest.fn();
+const mockProjId = "project-id";
+
+// Preloaded values for store when testing
+const persistedDefaultState: PreloadedState<RootState> = {
+  ...defaultState,
+  _persist: { version: 1, rehydrated: false },
+};
+
+describe("ExportProjectActions", () => {
+  describe("asyncDownloadExport", () => {
+    it("correctly affects state on success", async () => {
+      const store = setupStore();
+      mockDownloadList.mockResolvedValueOnce({});
+      await store.dispatch(asyncDownloadExport(mockProjId));
+      const { projectId, status } = store.getState().exportProjectState;
+      expect(projectId).toEqual(mockProjId);
+      expect(status).toEqual(ExportStatus.Downloading);
+    });
+
+    it("correctly affects state on failure", async () => {
+      const store = setupStore();
+      mockDownloadList.mockRejectedValueOnce({});
+      await store.dispatch(asyncDownloadExport(mockProjId));
+      const { projectId, status } = store.getState().exportProjectState;
+      expect(projectId).toEqual(mockProjId);
+      expect(status).toEqual(ExportStatus.Failure);
+    });
+  });
+
+  describe("asyncExportProject", () => {
+    it("correctly affects state on success", async () => {
+      const store = setupStore();
+      mockExportLift.mockResolvedValueOnce({});
+      await store.dispatch(asyncExportProject(mockProjId));
+      const { projectId, status } = store.getState().exportProjectState;
+      expect(projectId).toEqual(mockProjId);
+      expect(status).toEqual(ExportStatus.Exporting);
+    });
+
+    it("correctly affects state on failure", async () => {
+      const store = setupStore();
+      mockExportLift.mockRejectedValueOnce({});
+      await store.dispatch(asyncExportProject(mockProjId));
+      const { projectId, status } = store.getState().exportProjectState;
+      expect(projectId).toEqual(mockProjId);
+      expect(status).toEqual(ExportStatus.Failure);
+    });
+  });
+
+  describe("asyncResetExport", () => {
+    it("correctly affects state", async () => {
+      const nonDefaultState = {
+        projectId: "nonempty-string",
+        status: ExportStatus.Success,
+      };
+      const store = setupStore({
+        ...persistedDefaultState,
+        exportProjectState: nonDefaultState,
+      });
+      await store.dispatch(asyncResetExport());
+      const { projectId, status } = store.getState().exportProjectState;
+      expect(projectId).toEqual("");
+      expect(status).toEqual(ExportStatus.Default);
+    });
+  });
+});
diff --git a/src/components/ProjectScreen/CreateProject/index.tsx b/src/components/ProjectScreen/CreateProject.tsx
similarity index 94%
rename from src/components/ProjectScreen/CreateProject/index.tsx
rename to src/components/ProjectScreen/CreateProject.tsx
index 6e4ab1a57c..8174810bae 100644
--- a/src/components/ProjectScreen/CreateProject/index.tsx
+++ b/src/components/ProjectScreen/CreateProject.tsx
@@ -11,7 +11,7 @@ import {
   Typography,
 } from "@mui/material";
 import { LanguagePicker, languagePickerStrings_en } from "mui-language-picker";
-import React, { Fragment, ReactElement, useEffect, useState } from "react";
+import React, { Fragment, ReactElement, useState } from "react";
 import { Trans, useTranslation } from "react-i18next";
 
 import { WritingSystem } from "api/models";
@@ -20,10 +20,8 @@ import { FileInputButton, LoadingDoneButton } from "components/Buttons";
 import {
   asyncCreateProject,
   asyncFinishProject,
-  reset,
-} from "components/ProjectScreen/CreateProject/Redux/CreateProjectActions";
-import { StoreState } from "types";
-import { useAppDispatch, useAppSelector } from "types/hooks";
+} from "components/ProjectScreen/CreateProjectActions";
+import { useAppDispatch } from "types/hooks";
 import theme from "types/theme";
 import { newWritingSystem } from "types/writingSystem";
 
@@ -41,18 +39,12 @@ const undBcp47 = "und";
 export default function CreateProject(): ReactElement {
   const dispatch = useAppDispatch();
 
-  const { inProgress, success } = useAppSelector(
-    (state: StoreState) => state.createProjectState
-  );
-
-  useEffect(() => {
-    dispatch(reset());
-  }, [dispatch]);
-
   const [analysisLang, setAnalysisLang] = useState(newWritingSystem(undBcp47));
   const [error, setError] = useState({ empty: false, nameTaken: false });
   const [languageData, setLanguageData] = useState<File | undefined>();
+  const [loading, setLoading] = useState(false);
   const [name, setName] = useState("");
+  const [success, setSuccess] = useState(false);
   const [vernLang, setVernLang] = useState(newWritingSystem(undBcp47));
   const [vernLangIsOther, setVernLangIsOther] = useState(false);
   const [vernLangOptions, setVernLangOptions] = useState<WritingSystem[]>([]);
@@ -178,10 +170,16 @@ export default function CreateProject(): ReactElement {
       return;
     }
 
+    setLoading(true);
+
     if (languageData) {
-      dispatch(asyncFinishProject(name, vernLang));
+      await dispatch(asyncFinishProject(name, vernLang)).then(() =>
+        setSuccess(true)
+      );
     } else {
-      dispatch(asyncCreateProject(name, vernLang, [analysisLang]));
+      await dispatch(asyncCreateProject(name, vernLang, [analysisLang])).then(
+        () => setSuccess(true)
+      );
     }
   };
 
@@ -297,7 +295,7 @@ export default function CreateProject(): ReactElement {
               disabled={!vernLang.bcp47 || vernLang.bcp47 === undBcp47}
               done={success}
               doneText={t("createProject.success")}
-              loading={inProgress}
+              loading={loading}
             >
               {t("createProject.create")}
             </LoadingDoneButton>
diff --git a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectActions.ts b/src/components/ProjectScreen/CreateProject/Redux/CreateProjectActions.ts
deleted file mode 100644
index d0a593086d..0000000000
--- a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectActions.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { WritingSystem } from "api/models";
-import { createProject, finishUploadLift, getProject } from "backend";
-import router from "browserRouter";
-import { asyncCreateUserEdits } from "components/GoalTimeline/Redux/GoalActions";
-import { setNewCurrentProject } from "components/Project/ProjectActions";
-import {
-  CreateProjectAction,
-  CreateProjectActionTypes,
-} from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
-import { StoreStateDispatch } from "types/Redux/actions";
-import { Path } from "types/path";
-import { newProject } from "types/project";
-
-/** thunk action creator for creating a project without an import. */
-export function asyncCreateProject(
-  name: string,
-  vernacularWritingSystem: WritingSystem,
-  analysisWritingSystems: WritingSystem[]
-) {
-  return async (dispatch: StoreStateDispatch) => {
-    dispatch(inProgress());
-
-    const project = newProject(name);
-    project.vernacularWritingSystem = vernacularWritingSystem;
-    project.analysisWritingSystems = analysisWritingSystems;
-
-    await createProject(project)
-      .then(async (createdProject) => {
-        dispatch(setNewCurrentProject(createdProject));
-        dispatch(success());
-
-        // Manually pause so they have a chance to see the success message.
-        setTimeout(() => {
-          dispatch(asyncCreateUserEdits());
-          router.navigate(Path.ProjSettings);
-        }, 1000);
-      })
-      .catch((e) => {
-        dispatch(failure(e.response?.statusText));
-      });
-  };
-}
-
-/** thunk action creator for creating a project with a pre-uploaded import. */
-export function asyncFinishProject(
-  name: string,
-  vernacularWritingSystem: WritingSystem
-) {
-  return async (dispatch: StoreStateDispatch) => {
-    dispatch(inProgress());
-
-    const project = newProject(name);
-    project.vernacularWritingSystem = vernacularWritingSystem;
-
-    await createProject(project)
-      .then(async (createdProject) => {
-        await finishUploadLift(createdProject.id);
-        createdProject = await getProject(createdProject.id);
-        dispatch(setNewCurrentProject(createdProject));
-        dispatch(success());
-
-        // Manually pause so they have a chance to see the success message.
-        setTimeout(() => {
-          dispatch(asyncCreateUserEdits());
-          router.navigate(Path.ProjSettings);
-        }, 1000);
-      })
-      .catch((e) => {
-        dispatch(failure(e.response?.statusText));
-      });
-  };
-}
-
-export function inProgress(): CreateProjectAction {
-  return {
-    type: CreateProjectActionTypes.CREATE_PROJECT_IN_PROGRESS,
-    payload: {},
-  };
-}
-
-export function success(): CreateProjectAction {
-  return {
-    type: CreateProjectActionTypes.CREATE_PROJECT_SUCCESS,
-    payload: {},
-  };
-}
-
-export function failure(errorMsg = ""): CreateProjectAction {
-  return {
-    type: CreateProjectActionTypes.CREATE_PROJECT_FAILURE,
-    payload: { errorMsg },
-  };
-}
-
-export function reset(): CreateProjectAction {
-  return {
-    type: CreateProjectActionTypes.CREATE_PROJECT_RESET,
-    payload: {},
-  };
-}
diff --git a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReducer.ts b/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReducer.ts
deleted file mode 100644
index 31685a01d3..0000000000
--- a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReducer.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import {
-  CreateProjectAction,
-  CreateProjectActionTypes,
-  CreateProjectState,
-  defaultState,
-} from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
-import { StoreAction, StoreActionTypes } from "rootActions";
-
-export const createProjectReducer = (
-  state: CreateProjectState = defaultState,
-  action: CreateProjectAction | StoreAction
-): CreateProjectState => {
-  switch (action.type) {
-    case CreateProjectActionTypes.CREATE_PROJECT_IN_PROGRESS:
-      return { ...defaultState, inProgress: true };
-    case CreateProjectActionTypes.CREATE_PROJECT_SUCCESS:
-      return { ...defaultState, success: true };
-    case CreateProjectActionTypes.CREATE_PROJECT_FAILURE:
-      return { ...defaultState, errorMsg: action.payload.errorMsg ?? "" };
-    case CreateProjectActionTypes.CREATE_PROJECT_RESET:
-      return defaultState;
-    case StoreActionTypes.RESET:
-      return defaultState;
-    default:
-      return state;
-  }
-};
diff --git a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes.ts b/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes.ts
deleted file mode 100644
index 39d2b6987a..0000000000
--- a/src/components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-export enum CreateProjectActionTypes {
-  CREATE_PROJECT_FAILURE = "CREATE_PROJECT_FAILURE",
-  CREATE_PROJECT_IN_PROGRESS = "CREATE_PROJECT_IN_PROGRESS",
-  CREATE_PROJECT_RESET = "CREATE_PROJECT_RESET",
-  CREATE_PROJECT_SUCCESS = "CREATE_PROJECT_SUCCESS",
-}
-
-type CreateProjectType =
-  | typeof CreateProjectActionTypes.CREATE_PROJECT_FAILURE
-  | typeof CreateProjectActionTypes.CREATE_PROJECT_IN_PROGRESS
-  | typeof CreateProjectActionTypes.CREATE_PROJECT_RESET
-  | typeof CreateProjectActionTypes.CREATE_PROJECT_SUCCESS;
-
-export interface CreateProjectAction {
-  type: CreateProjectType;
-  payload: { errorMsg?: string };
-}
-
-export interface CreateProjectState {
-  inProgress: boolean;
-  success: boolean;
-  errorMsg: string;
-}
-
-export const defaultState: CreateProjectState = {
-  success: false,
-  inProgress: false,
-  errorMsg: "",
-};
diff --git a/src/components/ProjectScreen/CreateProject/tests/CreateProjectActions.test.tsx b/src/components/ProjectScreen/CreateProject/tests/CreateProjectActions.test.tsx
deleted file mode 100644
index 0c5af9eb1b..0000000000
--- a/src/components/ProjectScreen/CreateProject/tests/CreateProjectActions.test.tsx
+++ /dev/null
@@ -1,48 +0,0 @@
-import configureMockStore from "redux-mock-store";
-import thunk from "redux-thunk";
-
-import * as action from "components/ProjectScreen/CreateProject/Redux/CreateProjectActions";
-import { defaultState } from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
-import { newWritingSystem } from "types/writingSystem";
-
-jest.mock("backend", () => ({
-  createProject: () => Promise.reject({ response: "intentional failure" }),
-}));
-
-const mockStore = configureMockStore([thunk])(defaultState);
-
-const project = {
-  name: "testProjectName",
-  vernacularLanguage: newWritingSystem("testVernCode", "testVernName"),
-  analysisLanguages: [newWritingSystem("testAnalysisCode", "testAnalysisName")],
-};
-
-beforeEach(() => {
-  mockStore.clearActions();
-});
-
-describe("CreateProjectActions", () => {
-  test("asyncCreateProject correctly affects state", async () => {
-    await mockStore.dispatch<any>(
-      action.asyncCreateProject(
-        project.name,
-        project.vernacularLanguage,
-        project.analysisLanguages
-      )
-    );
-    expect(mockStore.getActions()).toEqual([
-      action.inProgress(),
-      action.failure(), // backend.createProject mocked to fail
-    ]);
-  });
-
-  test("asyncFinishProject correctly affects state", async () => {
-    await mockStore.dispatch<any>(
-      action.asyncFinishProject(project.name, project.vernacularLanguage)
-    );
-    expect(mockStore.getActions()).toEqual([
-      action.inProgress(),
-      action.failure(), // backend.createProject mocked to fail
-    ]);
-  });
-});
diff --git a/src/components/ProjectScreen/CreateProject/tests/CreateProjectReducer.test.tsx b/src/components/ProjectScreen/CreateProject/tests/CreateProjectReducer.test.tsx
deleted file mode 100644
index 89b80daff9..0000000000
--- a/src/components/ProjectScreen/CreateProject/tests/CreateProjectReducer.test.tsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import {
-  failure,
-  inProgress,
-  reset,
-  success,
-} from "components/ProjectScreen/CreateProject/Redux/CreateProjectActions";
-import * as reducer from "components/ProjectScreen/CreateProject/Redux/CreateProjectReducer";
-import {
-  CreateProjectState,
-  defaultState,
-} from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
-import { StoreAction, StoreActionTypes } from "rootActions";
-
-describe("CreateProjectReducer", () => {
-  test("undefined state and reset action, expecting default state", () => {
-    expect(reducer.createProjectReducer(undefined, reset())).toEqual(
-      defaultState
-    );
-  });
-
-  test("undefined state and failure action, expecting error message", () => {
-    const errorMsg = "";
-    expect(reducer.createProjectReducer(undefined, failure(errorMsg))).toEqual({
-      ...defaultState,
-      errorMsg,
-    });
-  });
-
-  test("empty state and in-progress action, expecting inProgress", () => {
-    expect(
-      reducer.createProjectReducer({} as CreateProjectState, inProgress())
-    ).toEqual({ ...defaultState, inProgress: true });
-  });
-
-  test("empty state and success action, expecting success", () => {
-    expect(
-      reducer.createProjectReducer({} as CreateProjectState, success())
-    ).toEqual({ ...defaultState, success: true });
-  });
-
-  test("empty state and store reset action, expecting default state", () => {
-    const storeResetAction: StoreAction = { type: StoreActionTypes.RESET };
-    expect(
-      reducer.createProjectReducer({} as CreateProjectState, storeResetAction)
-    ).toEqual(defaultState);
-  });
-});
diff --git a/src/components/ProjectScreen/CreateProjectActions.ts b/src/components/ProjectScreen/CreateProjectActions.ts
new file mode 100644
index 0000000000..1c6a3c2e85
--- /dev/null
+++ b/src/components/ProjectScreen/CreateProjectActions.ts
@@ -0,0 +1,54 @@
+import { WritingSystem } from "api/models";
+import { createProject, finishUploadLift, getProject } from "backend";
+import router from "browserRouter";
+import { asyncCreateUserEdits } from "components/GoalTimeline/Redux/GoalActions";
+import { setNewCurrentProject } from "components/Project/ProjectActions";
+import { StoreStateDispatch } from "types/Redux/actions";
+import { Path } from "types/path";
+import { newProject } from "types/project";
+
+// Dispatch Functions
+
+/*** Create a project without an import. */
+export function asyncCreateProject(
+  name: string,
+  vernacularWritingSystem: WritingSystem,
+  analysisWritingSystems: WritingSystem[]
+) {
+  return async (dispatch: StoreStateDispatch) => {
+    const project = newProject(name);
+    project.vernacularWritingSystem = vernacularWritingSystem;
+    project.analysisWritingSystems = analysisWritingSystems;
+
+    const createdProject = await createProject(project);
+    dispatch(setNewCurrentProject(createdProject));
+
+    // Manually pause so they have a chance to see the success message.
+    setTimeout(() => {
+      dispatch(asyncCreateUserEdits());
+      router.navigate(Path.ProjSettings);
+    }, 1000);
+  };
+}
+
+/*** Create a project with a pre-uploaded import. */
+export function asyncFinishProject(
+  name: string,
+  vernacularWritingSystem: WritingSystem
+) {
+  return async (dispatch: StoreStateDispatch) => {
+    const project = newProject(name);
+    project.vernacularWritingSystem = vernacularWritingSystem;
+
+    const projId = (await createProject(project)).id;
+    await finishUploadLift(projId);
+    const createdProject = await getProject(projId);
+    dispatch(setNewCurrentProject(createdProject));
+
+    // Manually pause so they have a chance to see the success message.
+    setTimeout(() => {
+      dispatch(asyncCreateUserEdits());
+      router.navigate(Path.ProjSettings);
+    }, 1000);
+  };
+}
diff --git a/src/components/ProjectScreen/CreateProject/tests/CreateProjectComponent.test.tsx b/src/components/ProjectScreen/tests/CreateProject.test.tsx
similarity index 95%
rename from src/components/ProjectScreen/CreateProject/tests/CreateProjectComponent.test.tsx
rename to src/components/ProjectScreen/tests/CreateProject.test.tsx
index b39d3c42d2..f87d550a1b 100644
--- a/src/components/ProjectScreen/CreateProject/tests/CreateProjectComponent.test.tsx
+++ b/src/components/ProjectScreen/tests/CreateProject.test.tsx
@@ -17,7 +17,6 @@ import CreateProject, {
   formId,
   selectIdVern,
 } from "components/ProjectScreen/CreateProject";
-import { defaultState } from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
 import { newWritingSystem } from "types/writingSystem";
 
 jest.mock("backend", () => ({
@@ -29,10 +28,7 @@ const mockProjectDuplicateCheck = jest.fn();
 const mockUploadLiftAndGetWritingSystems = jest.fn();
 
 const createMockStore = configureMockStore();
-const mockState = {
-  currentProjectState: { project: {} },
-  createProjectState: defaultState,
-};
+const mockState = { currentProjectState: { project: {} } };
 const mockStore = createMockStore(mockState);
 
 const mockChangeEvent = (
diff --git a/src/components/ProjectSettings/ProjectSchedule/CalendarView.tsx b/src/components/ProjectSettings/ProjectSchedule/CalendarView.tsx
index 8494ce6bb0..67ac753ace 100644
--- a/src/components/ProjectSettings/ProjectSchedule/CalendarView.tsx
+++ b/src/components/ProjectSettings/ProjectSchedule/CalendarView.tsx
@@ -39,7 +39,7 @@ export default function CalendarView(props: CalendarViewProps): ReactElement {
 
     return monthToRender.map((tempDayjs) => (
       <CalendarPicker
-        key={"calendarPick" + tempDayjs.toString()}
+        key={tempDayjs.toISOString()}
         components={{ LeftArrowIcon: Icon, RightArrowIcon: Icon }}
         readOnly
         disabled
diff --git a/src/components/ProjectSettings/ProjectSelect.tsx b/src/components/ProjectSettings/ProjectSelect.tsx
index b3b99ff8c5..8e789d28af 100644
--- a/src/components/ProjectSettings/ProjectSelect.tsx
+++ b/src/components/ProjectSettings/ProjectSelect.tsx
@@ -41,8 +41,8 @@ export default function ProjectSelect(
       sx={{ maxWidth: "100%" }}
       value={props.project.name}
     >
-      {projectList.map((p, i) => (
-        <MenuItem key={i} value={p.name}>
+      {projectList.map((p) => (
+        <MenuItem key={p.id} value={p.name}>
           {p.name}
         </MenuItem>
       ))}
diff --git a/src/components/Statistics/DomainStatistics.tsx b/src/components/Statistics/DomainStatistics.tsx
index 3d0132b245..d8a7fea5d9 100644
--- a/src/components/Statistics/DomainStatistics.tsx
+++ b/src/components/Statistics/DomainStatistics.tsx
@@ -68,9 +68,9 @@ function TableRow(props: {
   return (
     <ListItem style={{ minWidth: "600px" }}>
       <Grid container wrap="nowrap" justifyContent="space-around">
-        <TableCell key={"id_" + props.dom.id} text={props.dom.id} />
-        <TableCell key={"domain_" + props.dom.id} text={props.dom.name} />
-        <TableCell key={"count_" + props.dom.id} text={props.count} />
+        <TableCell text={props.dom.id} />
+        <TableCell text={props.dom.name} />
+        <TableCell text={props.count} />
       </Grid>
     </ListItem>
   );
diff --git a/src/components/Statistics/UserStatistics.tsx b/src/components/Statistics/UserStatistics.tsx
index b48660ca2e..63b434cfb6 100644
--- a/src/components/Statistics/UserStatistics.tsx
+++ b/src/components/Statistics/UserStatistics.tsx
@@ -61,18 +61,9 @@ function TableRow(props: { counts: SemanticDomainUserCount }): ReactElement {
   return (
     <ListItem style={{ minWidth: "600px" }}>
       <Grid container wrap="nowrap" justifyContent="space-around">
-        <TableCell
-          key={"username_" + props.counts.id}
-          text={props.counts.username}
-        />
-        <TableCell
-          key={"domCount_" + props.counts.id}
-          text={props.counts.domainCount}
-        />
-        <TableCell
-          key={"wordCount_" + props.counts.id}
-          text={props.counts.wordCount}
-        />
+        <TableCell text={props.counts.username} />
+        <TableCell text={props.counts.domainCount} />
+        <TableCell text={props.counts.wordCount} />
       </Grid>
     </ListItem>
   );
diff --git a/src/goals/CharacterInventory/CharInvCompleted.tsx b/src/goals/CharacterInventory/CharInvCompleted.tsx
index 306ad4100f..c9b89df05d 100644
--- a/src/goals/CharacterInventory/CharInvCompleted.tsx
+++ b/src/goals/CharacterInventory/CharInvCompleted.tsx
@@ -1,6 +1,6 @@
 import { ArrowRightAlt } from "@mui/icons-material";
 import { Typography } from "@mui/material";
-import React, { ReactElement } from "react";
+import { ReactElement } from "react";
 import { useTranslation } from "react-i18next";
 import { useSelector } from "react-redux";
 
@@ -19,26 +19,19 @@ export default function CharInvCompleted(): ReactElement {
   const { t } = useTranslation();
 
   return (
-    <React.Fragment>
+    <>
       <Typography component="h1" variant="h4">
         {t("charInventory.title")}
       </Typography>
-      {CharInvChangesMade(changes)}
-    </React.Fragment>
+      {changes.charChanges?.length ? (
+        changes.charChanges.map((c) => <CharInvChange change={c} key={c[0]} />)
+      ) : (
+        <Typography>{t("charInventory.changes.noChanges")}</Typography>
+      )}
+    </>
   );
 }
 
-function CharInvChangesMade(
-  changes: CharInvChanges
-): ReactElement | ReactElement[] {
-  const { t } = useTranslation();
-
-  if (!changes.charChanges?.length) {
-    return <Typography>{t("charInventory.changes.noChanges")}</Typography>;
-  }
-  return changes.charChanges.map(CharInvChange);
-}
-
 export function CharInvChangesGoalList(changes: CharInvChanges): ReactElement {
   const { t } = useTranslation();
   const changeLimit = 3;
@@ -48,32 +41,36 @@ export function CharInvChangesGoalList(changes: CharInvChanges): ReactElement {
   }
   if (changes.charChanges.length > changeLimit) {
     return (
-      <React.Fragment>
+      <>
         <Typography />
-        {changes.charChanges.slice(0, changeLimit - 1).map(CharInvChange)}
+        {changes.charChanges.slice(0, changeLimit - 1).map((c) => (
+          <CharInvChange change={c} key={c[0]} />
+        ))}
         <Typography>
           {`+${changes.charChanges.length - 3} `}
           {t("charInventory.changes.more")}
         </Typography>
-      </React.Fragment>
+      </>
     );
   }
   return (
-    <React.Fragment>
+    <>
       <Typography />
-      {changes.charChanges.map(CharInvChange)}
-    </React.Fragment>
+      {changes.charChanges.map((c) => (
+        <CharInvChange change={c} key={c[0]} />
+      ))}
+    </>
   );
 }
 
-function CharInvChange(change: CharacterChange): ReactElement {
+function CharInvChange(props: { change: CharacterChange }): ReactElement {
   return (
-    <React.Fragment key={change[0]}>
-      <Typography display="inline">{`${change[0]}: `}</Typography>
-      <CharacterStatusText status={change[1]} inline />
+    <>
+      <Typography display="inline">{`${props.change[0]}: `}</Typography>
+      <CharacterStatusText status={props.change[1]} inline />
       <ArrowRightAlt fontSize="inherit" />
-      <CharacterStatusText status={change[2]} inline />
+      <CharacterStatusText status={props.change[2]} inline />
       <Typography />
-    </React.Fragment>
+    </>
   );
 }
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellColumns.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellColumns.tsx
index c61d582a7d..cc4d6268a7 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellColumns.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellColumns.tsx
@@ -458,7 +458,6 @@ const columns: Column<any>[] = [
     render: (rowData: ReviewEntriesWord) => (
       <Input
         fullWidth
-        key={`note${rowData.id}`}
         value={rowData.noteText}
         readOnly
         disableUnderline
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/AlignedList.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/AlignedList.tsx
index 9ca600cd74..3997cd83a3 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/AlignedList.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/AlignedList.tsx
@@ -16,7 +16,7 @@ export default function AlignedList(props: AlignedListProps): ReactElement {
         <Grid
           item
           xs
-          key={`alignedList:${props.listId}:${index}`}
+          key={index}
           style={
             props.bottomCell || index + 1 !== props.contents.length
               ? { borderBottom: "1px solid lightgrey" }
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DefinitionCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DefinitionCell.tsx
index bade811c7c..7a6c840474 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DefinitionCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DefinitionCell.tsx
@@ -33,7 +33,7 @@ export default function DefinitionCell(
     <AlignedList
       listId={`senses${props.rowData.id}`}
       contents={props.rowData.senses.map((sense, index) => (
-        <Overlay key={index} on={sense.deleted}>
+        <Overlay key={sense.guid} on={sense.deleted}>
           <DefinitionList
             defaultLang={analysisLang}
             definitions={sense.definitions}
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DomainCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DomainCell.tsx
index b20de93704..a54e61c371 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DomainCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/DomainCell.tsx
@@ -102,14 +102,11 @@ export default function DomainCell(props: DomainCellProps): ReactElement {
         key={`domainCell:${props.rowData.id}`}
         listId={`domains${props.rowData.id}`}
         contents={props.rowData.senses.map((sense, senseIndex) => (
-          <Overlay key={senseIndex} on={sense.deleted}>
+          <Overlay key={sense.guid} on={sense.deleted}>
             <Grid container direction="row" spacing={2}>
               {sense.domains.length > 0 ? (
                 sense.domains.map((domain, domainIndex) => (
-                  <Grid
-                    item
-                    key={`${domain.name}::${props.rowData.id}:${sense.guid}`}
-                  >
+                  <Grid item key={`${domain.id}_${domain.name}`}>
                     <Chip
                       color={sense.deleted ? "secondary" : "default"}
                       style={getChipStyle(senseIndex, domainIndex)}
@@ -124,7 +121,7 @@ export default function DomainCell(props: DomainCellProps): ReactElement {
                   </Grid>
                 ))
               ) : (
-                <Grid item xs key={`noDomain${sense.guid}`}>
+                <Grid item xs>
                   <Chip
                     label={t("reviewEntries.noDomain")}
                     color={props.sortingByThis ? "default" : "secondary"}
@@ -134,7 +131,6 @@ export default function DomainCell(props: DomainCellProps): ReactElement {
               )}
               {props.editDomains && !sense.deleted && (
                 <IconButton
-                  key={`buttonFor${sense.guid}`}
                   onClick={() => prepAddDomain(sense)}
                   id={`sense-${sense.guid}-domain-add`}
                   size="large"
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/GlossCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/GlossCell.tsx
index 72e66f37e6..604cc8d2ac 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/GlossCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/GlossCell.tsx
@@ -31,7 +31,7 @@ export default function GlossCell(props: GlossCellProps): ReactElement {
     <AlignedList
       listId={`senses${props.rowData.id}`}
       contents={props.rowData.senses.map((sense, index) => (
-        <Overlay key={index} on={sense.deleted}>
+        <Overlay key={sense.guid} on={sense.deleted}>
           <GlossList
             defaultLang={analysisLang}
             editable={props.editable && !sense.deleted}
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/NoteCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/NoteCell.tsx
index 8a91465be8..7a3ad5c809 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/NoteCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/NoteCell.tsx
@@ -10,7 +10,6 @@ export default function NoteCell(props: FieldParameterStandard): ReactElement {
   return (
     <TextField
       variant="standard"
-      key={`row-${props.rowData.id}-note`}
       id={`row-${props.rowData.id}-note-text`}
       multiline
       value={props.value}
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/PartOfSpeechCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/PartOfSpeechCell.tsx
index 50cd6d76dd..c3f3a982cf 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/PartOfSpeechCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/PartOfSpeechCell.tsx
@@ -14,10 +14,9 @@ export default function PartOfSpeechCell(
 ): ReactElement {
   return (
     <AlignedList
-      key={`partOfSpeechCell:${props.rowData.id}`}
       listId={`partsOfSpeech${props.rowData.id}`}
-      contents={props.rowData.senses.map((sense, senseIndex) => (
-        <Grid container direction="row" spacing={2} key={senseIndex}>
+      contents={props.rowData.senses.map((sense) => (
+        <Grid container direction="row" key={sense.guid} spacing={2}>
           <PartOfSpeechButton
             buttonId={`sense-${sense.guid}-part-of-speech`}
             gramInfo={sense.partOfSpeech}
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/SenseCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/SenseCell.tsx
index 6415703314..135dd68ebd 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/SenseCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/SenseCell.tsx
@@ -30,7 +30,6 @@ export default function SenseCell(props: SenseCellProps): ReactElement {
 
   return (
     <AlignedList
-      key={`delete:${props.rowData.id}`}
       listId={`delete${props.rowData.id}`}
       contents={props.rowData.senses.map((sense) => (
         <Tooltip
diff --git a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/VernacularCell.tsx b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/VernacularCell.tsx
index 0ca5fff7d5..ca8cf63348 100644
--- a/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/VernacularCell.tsx
+++ b/src/goals/ReviewEntries/ReviewEntriesComponent/CellComponents/VernacularCell.tsx
@@ -16,7 +16,6 @@ export default function VernacularCell(
   return (
     <TextFieldWithFont
       variant="standard"
-      key={`row-${props.rowData.id}-vernacular`}
       id={`row-${props.rowData.id}-vernacular-text`}
       multiline
       value={props.value}
diff --git a/src/rootReducer.ts b/src/rootReducer.ts
index dabea8c886..b0863ed7f0 100644
--- a/src/rootReducer.ts
+++ b/src/rootReducer.ts
@@ -3,8 +3,7 @@ import { combineReducers, Reducer } from "redux";
 import goalsReducer from "components/GoalTimeline/Redux/GoalReducer";
 import { loginReducer } from "components/Login/Redux/LoginReducer";
 import { projectReducer } from "components/Project/ProjectReducer";
-import { exportProjectReducer } from "components/ProjectExport/Redux/ExportProjectReducer";
-import { createProjectReducer } from "components/ProjectScreen/CreateProject/Redux/CreateProjectReducer";
+import exportProjectReducer from "components/ProjectExport/Redux/ExportProjectReducer";
 import { pronunciationsReducer } from "components/Pronunciations/Redux/PronunciationsReducer";
 import { treeViewReducer } from "components/TreeView/Redux/TreeViewReducer";
 import { characterInventoryReducer } from "goals/CharacterInventory/Redux/CharacterInventoryReducer";
@@ -18,7 +17,6 @@ export const rootReducer: Reducer<StoreState> = combineReducers<StoreState>({
   loginState: loginReducer,
 
   //project
-  createProjectState: createProjectReducer,
   currentProjectState: projectReducer,
   exportProjectState: exportProjectReducer,
 
diff --git a/src/types/index.ts b/src/types/index.ts
index a82aa20a00..114069a2de 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -1,7 +1,6 @@
 import { LoginState } from "components/Login/Redux/LoginReduxTypes";
 import { CurrentProjectState } from "components/Project/ProjectReduxTypes";
 import { ExportProjectState } from "components/ProjectExport/Redux/ExportProjectReduxTypes";
-import { CreateProjectState } from "components/ProjectScreen/CreateProject/Redux/CreateProjectReduxTypes";
 import { PronunciationsState } from "components/Pronunciations/Redux/PronunciationsReduxTypes";
 import { TreeViewState } from "components/TreeView/Redux/TreeViewReduxTypes";
 import { CharacterInventoryState } from "goals/CharacterInventory/Redux/CharacterInventoryReduxTypes";
@@ -16,7 +15,6 @@ export interface StoreState {
   loginState: LoginState;
 
   //project
-  createProjectState: CreateProjectState;
   currentProjectState: CurrentProjectState;
   exportProjectState: ExportProjectState;