diff --git a/apps/spruce/src/components/DayPicker/__snapshots__/DayPicker.stories.storyshot b/apps/spruce/src/components/DayPicker/__snapshots__/DayPicker.stories.storyshot
index 7f64d4afd..3f3ef6222 100644
--- a/apps/spruce/src/components/DayPicker/__snapshots__/DayPicker.stories.storyshot
+++ b/apps/spruce/src/components/DayPicker/__snapshots__/DayPicker.stories.storyshot
@@ -4,6 +4,7 @@ exports[`Snapshot Tests DayPicker.stories Default 1`] = `
 <div>
   <div
     class="css-8cvf0s-Container emi64ys2"
+    data-cy="daypicker"
   >
     <label
       class="css-1u74sbj-Circle emi64ys1"
diff --git a/apps/spruce/src/components/DayPicker/index.tsx b/apps/spruce/src/components/DayPicker/index.tsx
index 811c930e6..f6b756c3d 100644
--- a/apps/spruce/src/components/DayPicker/index.tsx
+++ b/apps/spruce/src/components/DayPicker/index.tsx
@@ -48,7 +48,7 @@ export const DayPicker: React.FC<{
   );
 
   return (
-    <Container>
+    <Container data-cy="daypicker">
       {days.map((day, i) => (
         <Day
           day={day}
diff --git a/apps/spruce/src/components/Spawn/editHostModal/FieldTemplates/UserTagRow.tsx b/apps/spruce/src/components/Spawn/editHostModal/FieldTemplates/UserTagRow.tsx
deleted file mode 100644
index 7b8484239..000000000
--- a/apps/spruce/src/components/Spawn/editHostModal/FieldTemplates/UserTagRow.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-import styled from "@emotion/styled";
-import { SpruceFormProps } from "components/SpruceForm/types";
-import { size } from "constants/tokens";
-
-export const UserTagRow: SpruceFormProps["ObjectFieldTemplate"] = ({
-  properties,
-}) => {
-  const [key, value] = properties;
-
-  return (
-    <UserTagContainer>
-      <div>{key.content}</div>
-      <div>{value.content}</div>
-    </UserTagContainer>
-  );
-};
-
-const UserTagContainer = styled.div`
-  display: flex;
-  margin-bottom: ${size.s};
-  gap: ${size.s};
-`;
diff --git a/apps/spruce/src/components/Spawn/editHostModal/getFormSchema.tsx b/apps/spruce/src/components/Spawn/editHostModal/getFormSchema.tsx
index 670f8074c..10c20765c 100644
--- a/apps/spruce/src/components/Spawn/editHostModal/getFormSchema.tsx
+++ b/apps/spruce/src/components/Spawn/editHostModal/getFormSchema.tsx
@@ -1,23 +1,29 @@
 import { css } from "@emotion/react";
-import { add } from "date-fns";
+import { Label } from "@leafygreen-ui/typography";
 import { GetFormSchema } from "components/SpruceForm/types";
-import widgets from "components/SpruceForm/Widgets";
-import { LeafyGreenTextArea } from "components/SpruceForm/Widgets/LeafyGreenWidgets";
-import { InputLabel, StyledLink } from "components/styles";
+import { StyledLink } from "components/styles";
 import { windowsPasswordRulesURL } from "constants/externalResources";
+import { size } from "constants/tokens";
 import { MyPublicKeysQuery, MyVolumesQuery } from "gql/generated/types";
-import { ExpirationRow } from "../ExpirationRow";
-import { getDefaultExpiration } from "../utils";
-import { UserTagRow } from "./FieldTemplates/UserTagRow";
+import {
+  getExpirationDetailsSchema,
+  getPublicKeySchema,
+} from "../getFormSchema";
 
 interface Props {
   canEditInstanceType: boolean;
   canEditRdpPassword: boolean;
   canEditSshKeys: boolean;
   disableExpirationCheckbox: boolean;
+  hostUptimeValidation?: {
+    enabledHoursCount: number;
+    errors: string[];
+    warnings: string[];
+  };
   instanceTypes: string[];
   myPublicKeys: MyPublicKeysQuery["myPublicKeys"];
   noExpirationCheckboxTooltip: string;
+  timeZone?: string;
   volumes: MyVolumesQuery["myVolumes"];
 }
 
@@ -26,283 +32,136 @@ export const getFormSchema = ({
   canEditRdpPassword,
   canEditSshKeys,
   disableExpirationCheckbox,
+  hostUptimeValidation,
   instanceTypes,
   myPublicKeys,
   noExpirationCheckboxTooltip,
+  timeZone,
   volumes,
-}: Props): ReturnType<GetFormSchema> => ({
-  fields: {},
-  schema: {
-    type: "object" as "object",
-    properties: {
-      hostName: {
-        title: "Edit Host Name",
-        type: "string",
-        default: "",
-      },
-      expirationDetails: {
-        title: "",
-        type: "object" as "object",
-        properties: {
-          expiration: {
-            type: "string" as "string",
-            title: "Edit Expiration",
-            default: getDefaultExpiration(),
-          },
-          noExpiration: {
-            type: "boolean" as "boolean",
-            title: "Never expire",
-            default: false,
-          },
-        },
-        dependencies: {
-          noExpiration: {
-            oneOf: [
-              {
-                properties: {
-                  noExpiration: {
-                    enum: [true],
-                  },
-                  expiration: {
-                    readOnly: true,
-                  },
-                },
-              },
-              {
-                properties: {
-                  noExpiration: {
-                    enum: [false],
-                  },
-                  expiration: {
-                    readOnly: false,
-                  },
-                },
-              },
-            ],
-          },
+}: Props): ReturnType<GetFormSchema> => {
+  const expirationDetails = getExpirationDetailsSchema({
+    disableExpirationCheckbox,
+    hostUptimeValidation,
+    noExpirationCheckboxTooltip,
+    timeZone,
+  });
+  const publicKeys = getPublicKeySchema({
+    canEditSshKeys,
+    myPublicKeys,
+    required: false,
+  });
+
+  return {
+    fields: {},
+    schema: {
+      type: "object" as "object",
+      properties: {
+        hostName: {
+          title: "Edit Host Name",
+          type: "string",
+          default: "",
         },
-      },
-      instanceType: {
-        title: "Change Instance Type",
-        type: "string" as "string",
-        default: "",
-        oneOf: instanceTypes.map((it) => ({
+        instanceType: {
+          title: "Change Instance Type",
           type: "string" as "string",
-          title: it,
-          enum: [it],
-        })),
-      },
-      volume: {
-        title: "Add Volume",
-        type: "string" as "string",
-        default: "",
-        oneOf: [
-          {
-            type: "string" as "string",
-            title: "Select volume…",
-            enum: [""],
-          },
-          ...volumes.map((v) => ({
+          default: "",
+          oneOf: instanceTypes.map((it) => ({
             type: "string" as "string",
-            title: `(${v.size}GB) ${v.displayName || v.id}`,
-            enum: [v.id],
+            title: it,
+            enum: [it],
           })),
-        ],
-      },
-      ...(canEditRdpPassword && {
-        rdpPassword: {
-          title: "Set New RDP Password",
-          type: "string",
-          default: "",
         },
-      }),
-      userTags: {
-        title: "",
-        type: "array" as "array",
-        items: {
-          type: "object" as "object",
-          properties: {
-            key: {
+        volume: {
+          title: "Add Volume",
+          type: "string" as "string",
+          default: "",
+          oneOf: [
+            {
               type: "string" as "string",
-              title: "Key",
-              default: "",
+              title: "Select volume…",
+              enum: [""],
             },
-            value: {
+            ...volumes.map((v) => ({
               type: "string" as "string",
-              title: "Value",
-              default: "",
-            },
-          },
+              title: `(${v.size}GB) ${v.displayName || v.id}`,
+              enum: [v.id],
+            })),
+          ],
         },
-      },
-      publicKeySection: {
-        title: "",
-        type: "object",
-        properties: {
-          useExisting: {
-            title: "Add SSH Key",
-            default: true,
-            type: "boolean" as "boolean",
-            oneOf: [
-              {
-                type: "boolean" as "boolean",
-                title: "Use existing key",
-                enum: [true],
-              },
-              {
-                type: "boolean" as "boolean",
-                title: "Add new key",
-                enum: [false],
-              },
-            ],
+        ...(canEditRdpPassword && {
+          rdpPassword: {
+            title: "Set New RDP Password",
+            type: "string",
+            default: "",
           },
-        },
-        dependencies: {
-          useExisting: {
-            oneOf: [
-              {
-                properties: {
-                  useExisting: {
-                    enum: [true],
-                  },
-                  publicKeyNameDropdown: {
-                    title: "Choose key",
-                    type: "string" as "string",
-                    default: "",
-                    oneOf: [
-                      {
-                        type: "string" as "string",
-                        title: "Select public key…",
-                        enum: [""],
-                      },
-                      ...myPublicKeys.map((d) => ({
-                        type: "string" as "string",
-                        title: d.name,
-                        enum: [d.name],
-                      })),
-                    ],
-                  },
-                },
+        }),
+        userTags: {
+          title: "",
+          type: "array" as "array",
+          items: {
+            type: "object" as "object",
+            properties: {
+              key: {
+                type: "string" as "string",
+                title: "Key",
+                default: "",
               },
-              {
-                properties: {
-                  useExisting: {
-                    enum: [false],
-                  },
-                  newPublicKey: {
-                    title: "Public key",
-                    type: "string" as "string",
-                    default: "",
-                  },
-                  savePublicKey: {
-                    title: "Save Public Key",
-                    type: "boolean" as "boolean",
-                    default: false,
-                  },
-                },
-                dependencies: {
-                  savePublicKey: {
-                    oneOf: [
-                      {
-                        properties: {
-                          savePublicKey: {
-                            enum: [true],
-                          },
-                          newPublicKeyName: {
-                            title: "Key name",
-                            type: "string" as "string",
-                            default: "",
-                          },
-                        },
-                      },
-                    ],
-                  },
-                },
+              value: {
+                type: "string" as "string",
+                title: "Value",
+                default: "",
               },
-            ],
+            },
           },
         },
+        expirationDetails: expirationDetails.schema,
+        publicKeySection: publicKeys.schema,
       },
     },
-  },
-  uiSchema: {
-    expirationDetails: {
-      "ui:ObjectFieldTemplate": ExpirationRow,
-      expiration: {
-        "ui:disableBefore": add(today, { days: 1 }),
-        "ui:disableAfter": add(today, { days: 30 }),
-        "ui:widget": "date-time",
-        "ui:elementWrapperCSS": datePickerCSS,
-      },
-      noExpiration: {
-        "ui:disabled": disableExpirationCheckbox,
-        "ui:tooltipDescription": noExpirationCheckboxTooltip ?? "",
-        "ui:elementWrapperCSS": checkboxCSS,
-      },
-    },
-    instanceType: {
-      "ui:description": !canEditInstanceType
-        ? "Instance type can only be changed when the host is stopped."
-        : "",
-      "ui:disabled": !canEditInstanceType,
-      "ui:allowDeselect": false,
-    },
-    volume: {
-      "ui:allowDeselect": false,
-      "ui:disabled": volumes.length === 0,
-      "ui:description": volumes.length === 0 ? "No volumes available." : "",
-    },
-    rdpPassword: {
-      // Console error should be resolved by https://jira.mongodb.org/browse/LG-2342.
-      "ui:description": (
-        <>
-          Password should match the criteria defined{" "}
-          <StyledLink href={windowsPasswordRulesURL} target="__blank">
-            here.
-          </StyledLink>
-        </>
-      ),
-    },
-    userTags: {
-      "ui:descriptionNode": <InputLabel>Add User Tags</InputLabel>,
-      "ui:addButtonText": "Add Tag",
-      "ui:orderable": false,
-      items: {
-        "ui:ObjectFieldTemplate": UserTagRow,
-        "ui:label": false,
-      },
-    },
-    publicKeySection: {
-      useExisting: {
-        "ui:widget": widgets.RadioBoxWidget,
-        "ui:description": !canEditSshKeys
-          ? "SSH keys can only be added when the host is running."
+    uiSchema: {
+      instanceType: {
+        "ui:description": !canEditInstanceType
+          ? "Instance type can only be changed when the host is stopped."
           : "",
-        "ui:disabled": !canEditSshKeys,
+        "ui:disabled": !canEditInstanceType,
+        "ui:allowDeselect": false,
       },
-      publicKeyNameDropdown: {
+      volume: {
         "ui:allowDeselect": false,
-        "ui:disabled": !canEditSshKeys || myPublicKeys.length === 0,
-        "ui:description":
-          canEditSshKeys && myPublicKeys.length === 0
-            ? "No keys available."
-            : "",
+        "ui:disabled": volumes.length === 0,
+        "ui:description": volumes.length === 0 ? "No volumes available." : "",
       },
-      newPublicKey: {
-        "ui:widget": LeafyGreenTextArea,
-        "ui:disabled": !canEditSshKeys,
+      rdpPassword: {
+        // Console error should be resolved by https://jira.mongodb.org/browse/LG-2342.
+        "ui:description": (
+          <>
+            Password should match the criteria defined{" "}
+            <StyledLink href={windowsPasswordRulesURL} target="__blank">
+              here.
+            </StyledLink>
+          </>
+        ),
       },
+      userTags: {
+        "ui:addButtonText": "Add Tag",
+        "ui:descriptionNode": (
+          <Label htmlFor="root_userTags">Add User Tags</Label>
+        ),
+        "ui:orderable": false,
+        items: {
+          "ui:elementWrapperCSS": css`
+            display: flex;
+            gap: ${size.s};
+          `,
+        },
+      },
+      expirationDetails: {
+        ...expirationDetails.uiSchema,
+        "ui:elementWrapperCSS": css`
+          margin-bottom: ${size.s};
+        `,
+      },
+      publicKeySection: publicKeys.uiSchema,
     },
-  },
-});
-
-const datePickerCSS = css`
-  position: relative;
-  z-index: 1;
-`;
-
-const checkboxCSS = css`
-  margin-bottom: 0;
-`;
-
-const today = new Date();
+  };
+};
diff --git a/apps/spruce/src/components/Spawn/editHostModal/transformer.test.ts b/apps/spruce/src/components/Spawn/editHostModal/transformer.test.ts
index 832d5a132..0ca3836f3 100644
--- a/apps/spruce/src/components/Spawn/editHostModal/transformer.test.ts
+++ b/apps/spruce/src/components/Spawn/editHostModal/transformer.test.ts
@@ -8,6 +8,7 @@ describe("edit spawn host modal", () => {
         hostId: "host_id",
         myPublicKeys,
         oldUserTags,
+        timeZone: "America/New_York",
       }),
     ).toStrictEqual({
       hostId: "host_id",
@@ -25,6 +26,14 @@ describe("edit spawn host modal", () => {
       expiration: null,
       noExpiration: true,
       servicePassword: "password-123",
+      sleepSchedule: {
+        dailyStartTime: "09:00",
+        dailyStopTime: "17:00",
+        permanentlyExempt: false,
+        shouldKeepOff: false,
+        timeZone: "America/New_York",
+        wholeWeekdaysOff: [0, 5, 6],
+      },
       publicKey: {
         name: "a_key",
         key: "key value",
@@ -46,6 +55,17 @@ const formState = {
   expirationDetails: {
     noExpiration: true,
     expiration: "Wed Oct 19 2022 08:56:42 GMT-0400 (Eastern Daylight Time)",
+    hostUptime: {
+      useDefaultUptimeSchedule: false,
+      sleepSchedule: {
+        enabledWeekdays: [false, true, true, true, true, false, false],
+        timeSelection: {
+          startTime: "Fri May 03 2024 09:00:00",
+          stopTime: "Fri May 03 2024 17:00:00",
+          runContinuously: false,
+        },
+      },
+    },
   },
   instanceType: "m4.xlarge",
   volume: "my-volume-id",
diff --git a/apps/spruce/src/components/Spawn/editHostModal/transformer.ts b/apps/spruce/src/components/Spawn/editHostModal/transformer.ts
index 188d63755..baa6ae859 100644
--- a/apps/spruce/src/components/Spawn/editHostModal/transformer.ts
+++ b/apps/spruce/src/components/Spawn/editHostModal/transformer.ts
@@ -3,6 +3,7 @@ import {
   EditSpawnHostMutationVariables,
 } from "gql/generated/types";
 import { string } from "utils";
+import { getSleepSchedule } from "../utils";
 import { FormState } from "./types";
 
 const { stripNewLines } = string;
@@ -12,12 +13,14 @@ interface Props {
   myPublicKeys: MyPublicKeysQuery["myPublicKeys"];
   formData: FormState;
   oldUserTags: { key: string; value: string }[];
+  timeZone: string;
 }
 export const formToGql = ({
   formData,
   hostId,
   myPublicKeys,
   oldUserTags,
+  timeZone,
 }: Props): EditSpawnHostMutationVariables => {
   const {
     expirationDetails,
@@ -29,7 +32,7 @@ export const formToGql = ({
     volume,
   } = formData || {};
 
-  const { expiration, noExpiration } = expirationDetails;
+  const { expiration, hostUptime, noExpiration } = expirationDetails;
   const {
     newPublicKey = "",
     newPublicKeyName = "",
@@ -66,5 +69,9 @@ export const formToGql = ({
         : stripNewLines(newPublicKey),
     },
     savePublicKey: !useExisting && savePublicKey,
+    sleepSchedule:
+      noExpiration && hostUptime
+        ? getSleepSchedule(hostUptime, timeZone)
+        : null,
   };
 };
diff --git a/apps/spruce/src/components/Spawn/editHostModal/types.ts b/apps/spruce/src/components/Spawn/editHostModal/types.ts
index 0cd3e5150..0bd370d4b 100644
--- a/apps/spruce/src/components/Spawn/editHostModal/types.ts
+++ b/apps/spruce/src/components/Spawn/editHostModal/types.ts
@@ -1,8 +1,11 @@
+import { HostUptime } from "../utils";
+
 export type FormState = {
   hostName?: string;
   expirationDetails?: {
-    expiration?: string;
     noExpiration: boolean;
+    expiration?: string;
+    hostUptime?: HostUptime;
   };
   instanceType?: string;
   volume?: string;
diff --git a/apps/spruce/src/components/Spawn/editHostModal/utils.ts b/apps/spruce/src/components/Spawn/editHostModal/utils.ts
index 92b1e27af..216262813 100644
--- a/apps/spruce/src/components/Spawn/editHostModal/utils.ts
+++ b/apps/spruce/src/components/Spawn/editHostModal/utils.ts
@@ -25,5 +25,10 @@ export const computeDiff = (
     );
   }
 
+  // Always overwrite the whole sleep schedule, no need to update on a per-field basis.
+  if (mutationParams.sleepSchedule) {
+    mutationParams.sleepSchedule = currEditState.sleepSchedule;
+  }
+
   return [hasChanges, mutationParams];
 };
diff --git a/apps/spruce/src/components/Spawn/getFormSchema.tsx b/apps/spruce/src/components/Spawn/getFormSchema.tsx
index 3b7e99c5e..a0723f14e 100644
--- a/apps/spruce/src/components/Spawn/getFormSchema.tsx
+++ b/apps/spruce/src/components/Spawn/getFormSchema.tsx
@@ -1,14 +1,19 @@
 import { css } from "@emotion/react";
 import Badge from "@leafygreen-ui/badge";
 import { Body } from "@leafygreen-ui/typography";
+import { add } from "date-fns";
 import widgets from "components/SpruceForm/Widgets";
 import { prettifyTimeZone } from "constants/fieldMaps";
 import { size } from "constants/tokens";
+import { MyPublicKeysQuery } from "gql/generated/types";
+import { isProduction } from "utils/environmentVariables";
+import {
+  defaultStartDate,
+  defaultStopDate,
+  getDefaultExpiration,
+} from "./utils";
 
-const defaultStartTime = new Date();
-defaultStartTime.setHours(8, 0, 0, 0);
-const defaultEndTime = new Date();
-defaultEndTime.setHours(20, 0, 0, 0);
+const today = new Date();
 
 type HostUptimeProps = {
   hostUptimeValidation?: {
@@ -17,10 +22,9 @@ type HostUptimeProps = {
     warnings: string[];
   };
   timeZone?: string;
-  totalUptimeHours?: number;
 };
 
-export const getHostUptimeSchema = ({
+const getHostUptimeSchema = ({
   hostUptimeValidation,
   timeZone,
 }: HostUptimeProps) => ({
@@ -52,12 +56,12 @@ export const getHostUptimeSchema = ({
               startTime: {
                 type: "string" as "string",
                 title: "Start Time",
-                default: defaultStartTime.toString(),
+                default: defaultStartDate.toString(),
               },
-              endTime: {
+              stopTime: {
                 type: "string" as "string",
-                title: "End Time",
-                default: defaultEndTime.toString(),
+                title: "Stop Time",
+                default: defaultStopDate.toString(),
               },
               or: {
                 type: "null" as "null",
@@ -79,7 +83,7 @@ export const getHostUptimeSchema = ({
                     properties: {
                       runContinuously: { enum: [true] },
                       startTime: { readOnly: true },
-                      endTime: { readOnly: true },
+                      stopTime: { readOnly: true },
                     },
                   },
                 ],
@@ -121,7 +125,7 @@ export const getHostUptimeSchema = ({
         "ui:widget": widgets.DayPickerWidget,
       },
       timeSelection: {
-        "ui:fieldSetCSS": css`
+        "ui:elementWrapperCSS": css`
           align-items: center;
           display: flex;
           gap: ${size.xs};
@@ -134,7 +138,7 @@ export const getHostUptimeSchema = ({
           "ui:useUtc": false,
           "ui:widget": widgets.TimeWidget,
         },
-        endTime: {
+        stopTime: {
           "ui:format": "HH:mm",
           "ui:useUtc": false,
           "ui:widget": widgets.TimeWidget,
@@ -170,9 +174,253 @@ const Details: React.FC<{ timeZone: string; totalUptimeHours: number }> = ({
   timeZone,
   totalUptimeHours,
 }) => (
-  <>
+  <div data-cy="host-uptime-details">
     All times are displayed in{" "}
     <Badge>{prettifyTimeZone.get(timeZone) ?? timeZone}</Badge> •{" "}
     {totalUptimeHours} host uptime hours per week
-  </>
+  </div>
 );
+
+type ExpirationProps = {
+  disableExpirationCheckbox: boolean;
+  hostUptimeValidation?: {
+    enabledHoursCount: number;
+    errors: string[];
+    warnings: string[];
+  };
+  noExpirationCheckboxTooltip?: string;
+  timeZone?: string;
+};
+
+export const getExpirationDetailsSchema = ({
+  disableExpirationCheckbox,
+  hostUptimeValidation,
+  noExpirationCheckboxTooltip,
+  timeZone,
+}: ExpirationProps) => {
+  const defaultExpiration = getDefaultExpiration();
+  const hostUptime = getHostUptimeSchema({ hostUptimeValidation, timeZone });
+  return {
+    schema: {
+      title: "Expiration Details",
+      type: "object" as "object",
+      properties: {
+        noExpiration: {
+          default: false,
+          type: "boolean" as "boolean",
+          title: "",
+          oneOf: [
+            {
+              type: "boolean" as "boolean",
+              title: "Expirable Host",
+              enum: [false],
+            },
+            {
+              type: "boolean" as "boolean",
+              title: "Unexpirable Host",
+              enum: [true],
+            },
+          ],
+        },
+      },
+      dependencies: {
+        noExpiration: {
+          oneOf: [
+            {
+              properties: {
+                noExpiration: {
+                  enum: [false],
+                },
+                expiration: {
+                  type: "string" as "string",
+                  title: "Expiration",
+                  default: defaultExpiration,
+                  minLength: 6,
+                },
+              },
+            },
+            {
+              properties: {
+                noExpiration: {
+                  enum: [true],
+                },
+                ...(!isProduction() && { hostUptime: hostUptime.schema }),
+              },
+            },
+          ],
+        },
+      },
+    },
+    uiSchema: {
+      "ui:tooltipTitle": noExpirationCheckboxTooltip ?? "",
+      noExpiration: {
+        "ui:enumDisabled": disableExpirationCheckbox ? [true] : null,
+        "ui:data-cy": "expirable-radio-box",
+        "ui:widget": widgets.RadioBoxWidget,
+      },
+      hostUptime: hostUptime.uiSchema,
+      expiration: {
+        "ui:disableBefore": add(today, { days: 1 }),
+        "ui:disableAfter": add(today, { days: 30 }),
+        "ui:widget": "date-time",
+        "ui:elementWrapperCSS": datePickerCSS,
+      },
+    },
+  };
+};
+
+const datePickerCSS = css`
+  position: relative;
+  z-index: 1;
+`;
+
+type PublicKeyProps = {
+  canEditSshKeys?: boolean;
+  myPublicKeys: MyPublicKeysQuery["myPublicKeys"];
+  required?: boolean;
+};
+
+export const getPublicKeySchema = ({
+  canEditSshKeys = true,
+  myPublicKeys,
+  required = true,
+}: PublicKeyProps) => ({
+  schema: {
+    type: "object" as "object",
+    title: "SSH Key",
+    properties: {
+      useExisting: {
+        default: true,
+        type: "boolean" as "boolean",
+        title: "",
+        oneOf: [
+          {
+            type: "boolean" as "boolean",
+            title: "Use existing key",
+            enum: [true],
+          },
+          {
+            type: "boolean" as "boolean",
+            title: "Add new key",
+            enum: [false],
+          },
+        ],
+      },
+    },
+    dependencies: {
+      useExisting: {
+        oneOf: [
+          {
+            properties: {
+              useExisting: {
+                enum: [true],
+              },
+              publicKeyNameDropdown: {
+                title: "Choose key",
+                type: "string" as "string",
+                default: myPublicKeys?.length ? myPublicKeys[0]?.name : "",
+                minLength: required ? 1 : 0,
+                oneOf:
+                  myPublicKeys?.length > 0
+                    ? [
+                        {
+                          type: "string" as "string",
+                          title: "Select public key…",
+                          enum: [""],
+                        },
+                        ...myPublicKeys.map((d) => ({
+                          type: "string" as "string",
+                          title: d.name,
+                          enum: [d.name],
+                        })),
+                      ]
+                    : [
+                        {
+                          type: "string" as "string",
+                          title: "No keys available.",
+                          enum: [""],
+                        },
+                      ],
+              },
+            },
+          },
+          {
+            properties: {
+              useExisting: {
+                enum: [false],
+              },
+              newPublicKey: {
+                title: "Public key",
+                type: "string" as "string",
+                default: "",
+                minLength: 1,
+              },
+              savePublicKey: {
+                title: "Save Public Key",
+                type: "boolean" as "boolean",
+                default: false,
+              },
+            },
+            dependencies: {
+              savePublicKey: {
+                oneOf: [
+                  {
+                    properties: {
+                      savePublicKey: {
+                        enum: [false],
+                      },
+                    },
+                  },
+                  {
+                    properties: {
+                      savePublicKey: {
+                        enum: [true],
+                      },
+                      newPublicKeyName: {
+                        title: "Key name",
+                        type: "string" as "string",
+                        default: "",
+                        minLength: 1,
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        ],
+      },
+    },
+  },
+  uiSchema: {
+    "ui:disabled": !canEditSshKeys,
+    useExisting: {
+      "ui:widget": widgets.RadioBoxWidget,
+      "ui:description": !canEditSshKeys
+        ? "SSH keys can only be added when the host is running."
+        : "",
+    },
+    publicKeyNameDropdown: {
+      "ui:elementWrapperCSS": dropdownWrapperClassName,
+      "ui:data-cy": "key-select",
+      "ui:allowDeselect": false,
+      "ui:disabled": myPublicKeys?.length === 0,
+      "ui:description":
+        canEditSshKeys && myPublicKeys?.length === 0
+          ? "No keys available."
+          : "",
+    },
+    newPublicKey: {
+      "ui:widget": "textarea",
+      "ui:elementWrapperCSS": textAreaWrapperClassName,
+      "ui:data-cy": "key-value-text-area",
+    },
+  },
+});
+
+const dropdownWrapperClassName = css`
+  max-width: 225px;
+`;
+const textAreaWrapperClassName = css`
+  max-width: 675px;
+`;
diff --git a/apps/spruce/src/components/Spawn/index.tsx b/apps/spruce/src/components/Spawn/index.tsx
index 86cea9ae2..a0f4c22d7 100644
--- a/apps/spruce/src/components/Spawn/index.tsx
+++ b/apps/spruce/src/components/Spawn/index.tsx
@@ -1,4 +1,9 @@
 export * from "./Layout";
 export { DetailsCard } from "./DetailsCard";
 export { MountVolumeSelect } from "./MountVolumeSelect";
-export { maxUptimeHours, validateUptimeSchedule } from "./utils";
+export {
+  defaultSleepSchedule,
+  getHostUptimeFromGql,
+  validateUptimeSchedule,
+  validator,
+} from "./utils";
diff --git a/apps/spruce/src/components/Spawn/spawnHostModal/getFormSchema.tsx b/apps/spruce/src/components/Spawn/spawnHostModal/getFormSchema.tsx
index c1a1366b9..740cefa89 100644
--- a/apps/spruce/src/components/Spawn/spawnHostModal/getFormSchema.tsx
+++ b/apps/spruce/src/components/Spawn/spawnHostModal/getFormSchema.tsx
@@ -1,5 +1,4 @@
 import { css } from "@emotion/react";
-import { add } from "date-fns";
 import { GetFormSchema } from "components/SpruceForm/types";
 import widgets from "components/SpruceForm/Widgets";
 import { LeafyGreenTextArea } from "components/SpruceForm/Widgets/LeafyGreenWidgets";
@@ -8,10 +7,11 @@ import {
   SpawnTaskQuery,
   MyVolumesQuery,
 } from "gql/generated/types";
-import { isProduction } from "utils/environmentVariables";
 import { shortenGithash } from "utils/string";
-import { getHostUptimeSchema } from "../getFormSchema";
-import { getDefaultExpiration } from "../utils";
+import {
+  getExpirationDetailsSchema,
+  getPublicKeySchema,
+} from "../getFormSchema";
 import { DEFAULT_VOLUME_SIZE } from "./constants";
 import { validateTask } from "./utils";
 import { DistroDropdown } from "./Widgets/DistroDropdown";
@@ -71,7 +71,14 @@ export const getFormSchema = ({
   const availableVolumes = volumes
     ? volumes.filter((v) => v.homeVolume && !v.hostID)
     : [];
-  const hostUptime = getHostUptimeSchema({ hostUptimeValidation, timeZone });
+
+  const expirationDetails = getExpirationDetailsSchema({
+    disableExpirationCheckbox,
+    hostUptimeValidation,
+    noExpirationCheckboxTooltip,
+    timeZone,
+  });
+  const publicKeys = getPublicKeySchema({ myPublicKeys });
 
   return {
     fields: {},
@@ -104,158 +111,8 @@ export const getFormSchema = ({
             },
           },
         },
-        publicKeySection: {
-          type: "object",
-          title: "Key selection",
-          properties: {
-            useExisting: {
-              default: true,
-              type: "boolean" as "boolean",
-              title: "",
-              oneOf: [
-                {
-                  type: "boolean" as "boolean",
-                  title: "Use existing key",
-                  enum: [true],
-                },
-                {
-                  type: "boolean" as "boolean",
-                  title: "Add new key",
-                  enum: [false],
-                },
-              ],
-            },
-          },
-          dependencies: {
-            useExisting: {
-              oneOf: [
-                {
-                  properties: {
-                    useExisting: {
-                      enum: [true],
-                    },
-                    publicKeyNameDropdown: {
-                      title: "Choose key",
-                      type: "string" as "string",
-                      default: myPublicKeys?.length
-                        ? myPublicKeys[0]?.name
-                        : "",
-                      minLength: 1,
-                      oneOf:
-                        myPublicKeys?.length > 0
-                          ? myPublicKeys.map((d) => ({
-                              type: "string" as "string",
-                              title: d.name,
-                              enum: [d.name],
-                            }))
-                          : [
-                              {
-                                type: "string" as "string",
-                                title: "No keys available.",
-                                enum: [""],
-                              },
-                            ],
-                    },
-                  },
-                },
-                {
-                  properties: {
-                    useExisting: {
-                      enum: [false],
-                    },
-                    newPublicKey: {
-                      title: "Public key",
-                      type: "string" as "string",
-                      default: "",
-                      minLength: 1,
-                    },
-                    savePublicKey: {
-                      title: "Save Public Key",
-                      type: "boolean" as "boolean",
-                      default: false,
-                    },
-                  },
-                  dependencies: {
-                    savePublicKey: {
-                      oneOf: [
-                        {
-                          properties: {
-                            savePublicKey: {
-                              enum: [false],
-                            },
-                          },
-                        },
-                        {
-                          properties: {
-                            savePublicKey: {
-                              enum: [true],
-                            },
-                            newPublicKeyName: {
-                              title: "Key name",
-                              type: "string" as "string",
-                              default: "",
-                              minLength: 1,
-                            },
-                          },
-                        },
-                      ],
-                    },
-                  },
-                },
-              ],
-            },
-          },
-        },
-        expirationDetails: {
-          title: "Expiration Details",
-          type: "object" as "object",
-          properties: {
-            noExpiration: {
-              default: false,
-              type: "boolean" as "boolean",
-              title: "",
-              oneOf: [
-                {
-                  type: "boolean" as "boolean",
-                  title: "Expirable Host",
-                  enum: [false],
-                },
-                {
-                  type: "boolean" as "boolean",
-                  title: "Unexpirable Host",
-                  enum: [true],
-                },
-              ],
-            },
-          },
-          dependencies: {
-            noExpiration: {
-              oneOf: [
-                {
-                  properties: {
-                    noExpiration: {
-                      enum: [false],
-                    },
-                    expiration: {
-                      type: "string" as "string",
-                      title: "Expiration",
-                      default: getDefaultExpiration(),
-                      minLength: 6,
-                    },
-                  },
-                },
-                {
-                  properties: {
-                    noExpiration: {
-                      enum: [true],
-                    },
-                    ...(!isProduction() && { hostUptime: hostUptime.schema }),
-                  },
-                },
-              ],
-            },
-          },
-        },
+        publicKeySection: publicKeys.schema,
+        expirationDetails: expirationDetails.schema,
         optionalInformationTitle: {
           title: "Optional Host Details",
           type: "null",
@@ -471,7 +328,7 @@ export const getFormSchema = ({
     },
     uiSchema: {
       requiredSection: {
-        "ui:fieldSetCSS": css`
+        "ui:elementWrapperCSS": css`
           display: flex;
         `,
         distro: {
@@ -488,22 +345,7 @@ export const getFormSchema = ({
           "ui:allowDeselect": false,
         },
       },
-      publicKeySection: {
-        useExisting: {
-          "ui:widget": widgets.RadioBoxWidget,
-        },
-        publicKeyNameDropdown: {
-          "ui:elementWrapperCSS": dropdownWrapperClassName,
-          "ui:data-cy": "key-select",
-          "ui:allowDeselect": false,
-          "ui:disabled": myPublicKeys?.length === 0,
-        },
-        newPublicKey: {
-          "ui:widget": LeafyGreenTextArea,
-          "ui:elementWrapperCSS": textAreaWrapperClassName,
-          "ui:data-cy": "key-value-text-area",
-        },
-      },
+      publicKeySection: publicKeys.uiSchema,
       userdataScriptSection: {
         userdataScript: {
           "ui:widget": LeafyGreenTextArea,
@@ -522,24 +364,10 @@ export const getFormSchema = ({
           "ui:data-cy": "setup-script-text-area",
         },
       },
-      expirationDetails: {
-        "ui:tooltipTitle": noExpirationCheckboxTooltip ?? "",
-        noExpiration: {
-          "ui:enumDisabled": disableExpirationCheckbox ? [true] : null,
-          "ui:data-cy": "expirable-radio-box",
-          "ui:widget": widgets.RadioBoxWidget,
-        },
-        hostUptime: hostUptime.uiSchema,
-        expiration: {
-          "ui:disableBefore": add(today, { days: 1 }),
-          "ui:disableAfter": add(today, { days: 30 }),
-          "ui:widget": "date-time",
-          "ui:elementWrapperCSS": datePickerCSS,
-        },
-      },
+      expirationDetails: expirationDetails.uiSchema,
       ...(hasValidTask && {
         loadData: {
-          "ui:fieldSetCSS": loadDataFieldSetCSS,
+          "ui:elementWrapperCSS": loadDataFieldSetCSS,
           loadDataOntoHostAtStartup: {
             "ui:widget": hasValidTask ? widgets.CheckboxWidget : "hidden",
             "ui:customLabel": (
@@ -614,9 +442,3 @@ const childCheckboxCSS = css`
 const loadDataFieldSetCSS = css`
   margin-bottom: 20px;
 `;
-const datePickerCSS = css`
-  position: relative;
-  z-index: 1;
-`;
-
-const today = new Date();
diff --git a/apps/spruce/src/components/Spawn/spawnHostModal/transformer.ts b/apps/spruce/src/components/Spawn/spawnHostModal/transformer.ts
index c5d2dde99..ec96cf382 100644
--- a/apps/spruce/src/components/Spawn/spawnHostModal/transformer.ts
+++ b/apps/spruce/src/components/Spawn/spawnHostModal/transformer.ts
@@ -1,10 +1,10 @@
 import {
   MyPublicKeysQuery,
-  SleepScheduleInput,
   SpawnTaskQuery,
   SpawnHostMutationVariables,
 } from "gql/generated/types";
 import { stripNewLines } from "utils/string";
+import { getSleepSchedule } from "../utils";
 import { DEFAULT_VOLUME_SIZE } from "./constants";
 import { FormState } from "./types";
 import { validateTask } from "./utils";
@@ -91,55 +91,3 @@ export const formToGql = ({
     taskSync: !!(loadData?.loadDataOntoHostAtStartup && loadData?.taskSync),
   };
 };
-
-const getSleepSchedule = (
-  {
-    sleepSchedule,
-    useDefaultUptimeSchedule,
-  }: FormState["expirationDetails"]["hostUptime"],
-  timeZone: string,
-): SleepScheduleInput => {
-  if (useDefaultUptimeSchedule) {
-    return getDefaultSleepSchedule({ timeZone });
-  }
-
-  const {
-    enabledWeekdays,
-    timeSelection: { endTime, runContinuously, startTime },
-  } = sleepSchedule;
-
-  const schedule = {
-    permanentlyExempt: false,
-    shouldKeepOff: false,
-    timeZone,
-    wholeWeekdaysOff: enabledWeekdays.reduce((accum, isEnabled, i) => {
-      if (!isEnabled) {
-        accum.push(i);
-      }
-      return accum;
-    }, []),
-  } as SleepScheduleInput;
-
-  if (!runContinuously) {
-    const startDate = new Date(startTime);
-    const stopDate = new Date(endTime);
-    schedule.dailyStartTime = `${startDate.getHours()}:${startDate.getMinutes()}`;
-    schedule.dailyStopTime = `${stopDate.getHours()}:${stopDate.getMinutes()}`;
-  }
-
-  return schedule;
-};
-
-const getDefaultSleepSchedule = ({ timeZone }): SleepScheduleInput => {
-  const sleepSchedule: SleepScheduleInput = {
-    dailyStartTime: "08:00",
-    dailyStopTime: "20:00",
-    permanentlyExempt: false,
-    // TODO: Add pause
-    shouldKeepOff: false,
-    timeZone,
-    wholeWeekdaysOff: [0, 6],
-  };
-
-  return sleepSchedule;
-};
diff --git a/apps/spruce/src/components/Spawn/spawnHostModal/types.ts b/apps/spruce/src/components/Spawn/spawnHostModal/types.ts
index 22e8feb55..67bd050f8 100644
--- a/apps/spruce/src/components/Spawn/spawnHostModal/types.ts
+++ b/apps/spruce/src/components/Spawn/spawnHostModal/types.ts
@@ -1,3 +1,5 @@
+import { HostUptime } from "../utils";
+
 export type FormState = {
   requiredSection?: {
     distro?: string;
@@ -13,17 +15,7 @@ export type FormState = {
   expirationDetails?: {
     noExpiration: boolean;
     expiration?: string;
-    hostUptime?: {
-      useDefaultUptimeSchedule: boolean;
-      sleepSchedule?: {
-        enabledWeekdays: boolean[];
-        timeSelection: {
-          startTime: string;
-          endTime: string;
-          runContinuously: boolean;
-        };
-      };
-    };
+    hostUptime?: HostUptime;
   };
   userdataScriptSection?: {
     runUserdataScript: boolean;
diff --git a/apps/spruce/src/components/Spawn/utils.ts b/apps/spruce/src/components/Spawn/utils.ts
deleted file mode 100644
index 8620f0f21..000000000
--- a/apps/spruce/src/components/Spawn/utils.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { differenceInHours } from "date-fns";
-
-const daysInWeek = 7;
-const hoursInDay = 24;
-export const maxUptimeHours = (daysInWeek - 1) * hoursInDay;
-const suggestedUptimeHours = (daysInWeek - 2) * hoursInDay;
-
-interface GetNoExpirationCheckboxTooltipCopyProps {
-  disableExpirationCheckbox: boolean;
-  isVolume: boolean;
-  limit: number;
-}
-
-export const getNoExpirationCheckboxTooltipCopy = ({
-  disableExpirationCheckbox,
-  isVolume,
-  limit,
-}: GetNoExpirationCheckboxTooltipCopyProps) =>
-  disableExpirationCheckbox
-    ? `You have reached the max number of unexpirable ${
-        isVolume ? "volumes" : "hosts"
-      }  (${limit}). Toggle an existing ${
-        isVolume ? "volume" : "host"
-      } to expirable to enable this checkbox.`
-    : undefined;
-
-export const getDefaultExpiration = () => {
-  const nextWeek = new Date();
-  nextWeek.setDate(nextWeek.getDate() + 7);
-  return nextWeek.toString();
-};
-
-type ValidateInput = {
-  enabledWeekdays: boolean[];
-  endTime: string;
-  runContinuously: boolean;
-  startTime: string;
-  useDefaultUptimeSchedule: boolean;
-};
-
-export const validateUptimeSchedule = ({
-  enabledWeekdays,
-  endTime,
-  runContinuously,
-  startTime,
-  useDefaultUptimeSchedule,
-}: ValidateInput): {
-  enabledHoursCount: number;
-  errors: string[];
-  warnings: string[];
-} => {
-  const { enabledHoursCount, enabledWeekdaysCount } = getEnabledHoursCount({
-    enabledWeekdays,
-    endTime,
-    runContinuously,
-    startTime,
-  });
-
-  if (useDefaultUptimeSchedule) {
-    return {
-      enabledHoursCount,
-      errors: [],
-      warnings: [],
-    };
-  }
-
-  if (enabledHoursCount > maxUptimeHours) {
-    // Return error based on whether runContinously enabled
-    if (runContinuously) {
-      return {
-        enabledHoursCount,
-        errors: ["Please pause your host for at least 1 day per week."],
-        warnings: [],
-      };
-    }
-    const hourlyRequirement = Math.floor(maxUptimeHours / enabledWeekdaysCount);
-    return {
-      enabledHoursCount,
-      errors: [
-        `Please reduce your host uptime to a max of ${hourlyRequirement} hours per day.`,
-      ],
-      warnings: [],
-    };
-  }
-
-  if (enabledHoursCount > suggestedUptimeHours) {
-    // Return warning based on whether runContinuously enabled
-    if (runContinuously) {
-      return {
-        enabledHoursCount,
-        errors: [],
-        warnings: ["Consider pausing your host for 2 days per week."],
-      };
-    }
-    const hourlySuggestion = Math.floor(
-      suggestedUptimeHours / enabledWeekdaysCount,
-    );
-    return {
-      enabledHoursCount,
-      errors: [],
-      warnings: [
-        `Consider running your host for ${hourlySuggestion} hours per day or fewer.`,
-      ],
-    };
-  }
-  // No error
-  return {
-    enabledHoursCount,
-    errors: [],
-    warnings: [],
-  };
-};
-
-const getEnabledHoursCount = ({
-  enabledWeekdays,
-  endTime,
-  runContinuously,
-  startTime,
-}: Omit<ValidateInput, "useDefaultUptimeSchedule">) => {
-  const enabledWeekdaysCount =
-    enabledWeekdays?.filter((day) => day).length ?? 0;
-  const enabledHoursCount = runContinuously
-    ? enabledWeekdaysCount * hoursInDay
-    : enabledWeekdaysCount * getDailyUptime({ startTime, endTime });
-  return { enabledHoursCount, enabledWeekdaysCount };
-};
-
-const getDailyUptime = ({ endTime, startTime }) =>
-  differenceInHours(new Date(endTime), new Date(startTime));
diff --git a/apps/spruce/src/components/Spawn/utils/expiration.ts b/apps/spruce/src/components/Spawn/utils/expiration.ts
new file mode 100644
index 000000000..f6529a8f3
--- /dev/null
+++ b/apps/spruce/src/components/Spawn/utils/expiration.ts
@@ -0,0 +1,24 @@
+interface GetNoExpirationCheckboxTooltipCopyProps {
+  disableExpirationCheckbox: boolean;
+  isVolume: boolean;
+  limit: number;
+}
+
+export const getNoExpirationCheckboxTooltipCopy = ({
+  disableExpirationCheckbox,
+  isVolume,
+  limit,
+}: GetNoExpirationCheckboxTooltipCopyProps) =>
+  disableExpirationCheckbox
+    ? `You have reached the max number of unexpirable ${
+        isVolume ? "volumes" : "hosts"
+      }  (${limit}). Toggle an existing ${
+        isVolume ? "volume" : "host"
+      } to expirable to enable this checkbox.`
+    : undefined;
+
+export const getDefaultExpiration = () => {
+  const nextWeek = new Date();
+  nextWeek.setDate(nextWeek.getDate() + 7);
+  return nextWeek.toString();
+};
diff --git a/apps/spruce/src/components/Spawn/utils/hostUptime.test.ts b/apps/spruce/src/components/Spawn/utils/hostUptime.test.ts
new file mode 100644
index 000000000..9620bdb4b
--- /dev/null
+++ b/apps/spruce/src/components/Spawn/utils/hostUptime.test.ts
@@ -0,0 +1,339 @@
+import {
+  getHostUptimeFromGql,
+  getSleepSchedule,
+  matchesDefaultUptimeSchedule,
+  validateUptimeSchedule,
+  validator,
+} from "./hostUptime";
+
+describe("matchesDefaultUptimeSchedule", () => {
+  it("correctly identifies a match", () => {
+    const sched = {
+      dailyStartTime: "08:00",
+      dailyStopTime: "20:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    };
+    expect(matchesDefaultUptimeSchedule(sched)).toBe(true);
+  });
+
+  it("fails when start time is incorrect", () => {
+    const sched = {
+      dailyStartTime: "08:30",
+      dailyStopTime: "20:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    };
+    expect(matchesDefaultUptimeSchedule(sched)).toBe(false);
+  });
+
+  it("fails when stop time is incorrect", () => {
+    const sched = {
+      dailyStartTime: "08:00",
+      dailyStopTime: "21:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    };
+    expect(matchesDefaultUptimeSchedule(sched)).toBe(false);
+  });
+
+  it("fails when days off is incorrect", () => {
+    const sched = {
+      dailyStartTime: "08:00",
+      dailyStopTime: "20:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0],
+    };
+    expect(matchesDefaultUptimeSchedule(sched)).toBe(false);
+  });
+});
+
+describe("validator", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("returns no errors when host is expirable", () => {
+    const f = jest.fn();
+    validator(
+      {
+        expirationDetails: {
+          hostUptime: {
+            useDefaultUptimeSchedule: false,
+            sleepSchedule: {
+              enabledWeekdays: [],
+              timeSelection: {
+                startTime: "",
+                stopTime: "",
+                runContinuously: true,
+              },
+            },
+          },
+          noExpiration: false,
+        },
+      },
+      // @ts-expect-error
+      { expirationDetails: { hostUptime: { addError: f } } },
+    );
+    expect(f).toHaveBeenCalledTimes(0);
+  });
+
+  it("returns error when the host has too many uptime hours", () => {
+    const f = jest.fn();
+    validator(
+      {
+        expirationDetails: {
+          hostUptime: {
+            useDefaultUptimeSchedule: false,
+            sleepSchedule: {
+              enabledWeekdays: [true, true, true, true, true, true, true],
+              timeSelection: {
+                startTime: "",
+                stopTime: "",
+                runContinuously: true,
+              },
+            },
+          },
+          noExpiration: true,
+        },
+      },
+      // @ts-expect-error
+      { expirationDetails: { hostUptime: { addError: f } } },
+    );
+    expect(f).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not return an error when the host does not have too many uptime hours", () => {
+    const f = jest.fn();
+    validator(
+      {
+        expirationDetails: {
+          hostUptime: {
+            useDefaultUptimeSchedule: false,
+            sleepSchedule: {
+              enabledWeekdays: [false, true, true, true, true, true, false],
+              timeSelection: {
+                startTime: "",
+                stopTime: "",
+                runContinuously: true,
+              },
+            },
+          },
+          noExpiration: true,
+        },
+      },
+      // @ts-expect-error
+      { expirationDetails: { hostUptime: { addError: f } } },
+    );
+    expect(f).toHaveBeenCalledTimes(0);
+  });
+});
+
+describe("getHostUptimeFromGql", () => {
+  it("matches default schedule", () => {
+    const sched = {
+      dailyStartTime: "08:00",
+      dailyStopTime: "20:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    };
+    expect(getHostUptimeFromGql(sched)).toStrictEqual({
+      sleepSchedule: {
+        enabledWeekdays: [false, true, true, true, true, true, false],
+        timeSelection: {
+          runContinuously: false,
+          startTime:
+            "Mon Jan 01 1900 08:00:00 GMT+0000 (Coordinated Universal Time)",
+          stopTime:
+            "Mon Jan 01 1900 20:00:00 GMT+0000 (Coordinated Universal Time)",
+        },
+      },
+      useDefaultUptimeSchedule: true,
+    });
+  });
+
+  it("matches alternate schedule", () => {
+    const sched = {
+      dailyStartTime: "09:00",
+      dailyStopTime: "21:00",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [],
+    };
+    expect(getHostUptimeFromGql(sched)).toStrictEqual({
+      useDefaultUptimeSchedule: false,
+      sleepSchedule: {
+        enabledWeekdays: [true, true, true, true, true, true, true],
+        timeSelection: {
+          runContinuously: false,
+          startTime:
+            "Mon Jan 01 1900 09:00:00 GMT+0000 (Coordinated Universal Time)",
+          stopTime:
+            "Mon Jan 01 1900 21:00:00 GMT+0000 (Coordinated Universal Time)",
+        },
+      },
+    });
+  });
+
+  it("assigns continuous days", () => {
+    const sched = {
+      dailyStartTime: "",
+      dailyStopTime: "",
+      permanentlyExempt: true,
+      shouldKeepOff: true,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    };
+    expect(getHostUptimeFromGql(sched)).toStrictEqual({
+      useDefaultUptimeSchedule: false,
+      sleepSchedule: {
+        enabledWeekdays: [false, true, true, true, true, true, false],
+        timeSelection: {
+          runContinuously: true,
+          startTime:
+            "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+          stopTime:
+            "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+        },
+      },
+    });
+  });
+});
+
+describe("getSleepSchedule", () => {
+  it("sets the default schedule", () => {
+    expect(
+      getSleepSchedule({ useDefaultUptimeSchedule: true }, "America/New_York"),
+    ).toStrictEqual({
+      dailyStartTime: "08:00",
+      dailyStopTime: "20:00",
+      permanentlyExempt: false,
+      shouldKeepOff: false,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 6],
+    });
+  });
+
+  it("sets continuously running days", () => {
+    expect(
+      getSleepSchedule(
+        {
+          useDefaultUptimeSchedule: false,
+          sleepSchedule: {
+            enabledWeekdays: [false, false, true, true, true, true, false],
+            timeSelection: {
+              runContinuously: true,
+              startTime:
+                "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+              stopTime:
+                "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+            },
+          },
+        },
+        "America/New_York",
+      ),
+    ).toStrictEqual({
+      dailyStartTime: "",
+      dailyStopTime: "",
+      permanentlyExempt: false,
+      shouldKeepOff: false,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 1, 6],
+    });
+  });
+
+  it("sets start and stop times", () => {
+    expect(
+      getSleepSchedule(
+        {
+          useDefaultUptimeSchedule: false,
+          sleepSchedule: {
+            enabledWeekdays: [false, false, true, true, true, true, false],
+            timeSelection: {
+              runContinuously: false,
+              startTime:
+                "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+              stopTime:
+                "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+            },
+          },
+        },
+        "America/New_York",
+      ),
+    ).toStrictEqual({
+      dailyStartTime: "08:00",
+      dailyStopTime: "20:00",
+      permanentlyExempt: false,
+      shouldKeepOff: false,
+      timeZone: "America/New_York",
+      wholeWeekdaysOff: [0, 1, 6],
+    });
+  });
+});
+
+describe("validateUptimeSchedule", () => {
+  it("returns no errors when under recommended time", () => {
+    expect(
+      validateUptimeSchedule({
+        enabledWeekdays: [false, false, true, true, true, true, false],
+        runContinuously: false,
+        startTime:
+          "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+        stopTime:
+          "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+        useDefaultUptimeSchedule: true,
+      }),
+    ).toStrictEqual({
+      enabledHoursCount: 60,
+      errors: [],
+      warnings: [],
+    });
+  });
+
+  it("returns a warning when over recommended time", () => {
+    expect(
+      validateUptimeSchedule({
+        enabledWeekdays: [false, true, true, true, true, true, true],
+        runContinuously: true,
+        startTime:
+          "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+        stopTime:
+          "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+        useDefaultUptimeSchedule: false,
+      }),
+    ).toStrictEqual({
+      enabledHoursCount: 144,
+      errors: [],
+      warnings: ["Consider pausing your host for 2 days per week."],
+    });
+  });
+
+  it("returns an error when over allowed time", () => {
+    expect(
+      validateUptimeSchedule({
+        enabledWeekdays: [true, true, true, true, true, true, true],
+        runContinuously: true,
+        startTime:
+          "Sun Dec 31 1899 08:00:00 GMT+0000 (Coordinated Universal Time)",
+        stopTime:
+          "Sun Dec 31 1899 20:00:00 GMT+0000 (Coordinated Universal Time)",
+        useDefaultUptimeSchedule: false,
+      }),
+    ).toStrictEqual({
+      enabledHoursCount: 168,
+      errors: ["Please pause your host for at least 1 day per week."],
+      warnings: [],
+    });
+  });
+});
diff --git a/apps/spruce/src/components/Spawn/utils/hostUptime.ts b/apps/spruce/src/components/Spawn/utils/hostUptime.ts
new file mode 100644
index 000000000..1cba78953
--- /dev/null
+++ b/apps/spruce/src/components/Spawn/utils/hostUptime.ts
@@ -0,0 +1,252 @@
+import { differenceInHours, parse } from "date-fns";
+import { ValidateProps } from "components/SpruceForm";
+import { SleepScheduleInput } from "gql/generated/types";
+import { MyHost } from "types/spawn";
+import { arraySymmetricDifference } from "utils/array";
+
+const daysInWeek = 7;
+const hoursInDay = 24;
+const defaultStartHour = 8;
+const defaultStopHour = 20;
+const defaultScheduleWeeklyHourCount = 60;
+
+const suggestedUptimeHours = (daysInWeek - 2) * hoursInDay;
+export const maxUptimeHours = (daysInWeek - 1) * hoursInDay;
+
+export const defaultStartDate = new Date(null, null, null, defaultStartHour);
+export const defaultStopDate = new Date(null, null, null, defaultStopHour);
+
+export type HostUptime = {
+  useDefaultUptimeSchedule: boolean;
+  sleepSchedule?: {
+    enabledWeekdays: boolean[];
+    timeSelection: {
+      startTime: string;
+      stopTime: string;
+      runContinuously: boolean;
+    };
+  };
+};
+
+type ValidateInput = {
+  enabledWeekdays: boolean[];
+  stopTime: string;
+  runContinuously: boolean;
+  startTime: string;
+  useDefaultUptimeSchedule: boolean;
+};
+
+export const validateUptimeSchedule = ({
+  enabledWeekdays,
+  runContinuously,
+  startTime,
+  stopTime,
+  useDefaultUptimeSchedule,
+}: ValidateInput): {
+  enabledHoursCount: number;
+  errors: string[];
+  warnings: string[];
+} => {
+  if (useDefaultUptimeSchedule) {
+    return {
+      enabledHoursCount: defaultScheduleWeeklyHourCount,
+      errors: [],
+      warnings: [],
+    };
+  }
+
+  const { enabledHoursCount, enabledWeekdaysCount } = getEnabledHoursCount({
+    enabledWeekdays,
+    stopTime,
+    runContinuously,
+    startTime,
+  });
+
+  if (enabledHoursCount > maxUptimeHours) {
+    // Return error based on whether runContinously enabled
+    if (runContinuously) {
+      return {
+        enabledHoursCount,
+        errors: ["Please pause your host for at least 1 day per week."],
+        warnings: [],
+      };
+    }
+    const hourlyRequirement = Math.floor(maxUptimeHours / enabledWeekdaysCount);
+    return {
+      enabledHoursCount,
+      errors: [
+        `Please reduce your host uptime to a max of ${hourlyRequirement} hours per day.`,
+      ],
+      warnings: [],
+    };
+  }
+
+  if (enabledHoursCount > suggestedUptimeHours) {
+    // Return warning based on whether runContinuously enabled
+    if (runContinuously) {
+      return {
+        enabledHoursCount,
+        errors: [],
+        warnings: ["Consider pausing your host for 2 days per week."],
+      };
+    }
+    const hourlySuggestion = Math.floor(
+      suggestedUptimeHours / enabledWeekdaysCount,
+    );
+    return {
+      enabledHoursCount,
+      errors: [],
+      warnings: [
+        `Consider running your host for ${hourlySuggestion} hours per day or fewer.`,
+      ],
+    };
+  }
+  // No error
+  return {
+    enabledHoursCount,
+    errors: [],
+    warnings: [],
+  };
+};
+
+export const getEnabledHoursCount = ({
+  enabledWeekdays,
+  runContinuously,
+  startTime,
+  stopTime,
+}: Omit<ValidateInput, "useDefaultUptimeSchedule">) => {
+  const enabledWeekdaysCount =
+    enabledWeekdays?.filter((day) => day).length ?? 0;
+  const enabledHoursCount = runContinuously
+    ? enabledWeekdaysCount * hoursInDay
+    : enabledWeekdaysCount * getDailyUptime({ startTime, stopTime });
+  return { enabledHoursCount, enabledWeekdaysCount };
+};
+
+export const getSleepSchedule = (
+  { sleepSchedule, useDefaultUptimeSchedule }: HostUptime,
+  timeZone: string,
+): SleepScheduleInput => {
+  if (useDefaultUptimeSchedule) {
+    return {
+      ...defaultSleepSchedule,
+      timeZone,
+    };
+  }
+
+  const {
+    enabledWeekdays,
+    timeSelection: { runContinuously, startTime, stopTime },
+  } = sleepSchedule;
+
+  return {
+    dailyStartTime: runContinuously ? "" : toTimeString(new Date(startTime)),
+    dailyStopTime: runContinuously ? "" : toTimeString(new Date(stopTime)),
+    permanentlyExempt: false,
+    timeZone,
+    shouldKeepOff: false,
+    wholeWeekdaysOff: enabledWeekdays.reduce((accum, isEnabled, i) => {
+      if (!isEnabled) {
+        accum.push(i);
+      }
+      return accum;
+    }, []),
+  };
+};
+
+const getDailyUptime = ({ startTime, stopTime }) =>
+  differenceInHours(new Date(stopTime), new Date(startTime));
+
+const toTimeString = (date: Date): string =>
+  date.toLocaleTimeString([], {
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+  });
+
+export const defaultSleepSchedule: Omit<SleepScheduleInput, "timeZone"> = {
+  dailyStartTime: toTimeString(defaultStartDate),
+  dailyStopTime: toTimeString(defaultStopDate),
+  permanentlyExempt: false,
+  // TODO: Add pause
+  shouldKeepOff: false,
+  wholeWeekdaysOff: [0, 6],
+};
+
+export const getHostUptimeFromGql = (
+  sleepSchedule: MyHost["sleepSchedule"],
+): HostUptime => {
+  const { dailyStartTime, dailyStopTime, wholeWeekdaysOff } = sleepSchedule;
+
+  return {
+    useDefaultUptimeSchedule: matchesDefaultUptimeSchedule(sleepSchedule),
+    sleepSchedule: {
+      enabledWeekdays: new Array(7)
+        .fill(false)
+        .map((_, i) => !wholeWeekdaysOff.includes(i)),
+      timeSelection:
+        dailyStartTime && dailyStopTime
+          ? {
+              startTime: parse(
+                dailyStartTime,
+                "HH:mm",
+                new Date(null, null),
+              ).toString(),
+              stopTime: parse(
+                dailyStopTime,
+                "HH:mm",
+                new Date(null, null),
+              ).toString(),
+              runContinuously: false,
+            }
+          : {
+              startTime: defaultStartDate.toString(),
+              stopTime: defaultStopDate.toString(),
+              runContinuously: true,
+            },
+    },
+  };
+};
+
+export const matchesDefaultUptimeSchedule = (
+  sleepSchedule: MyHost["sleepSchedule"],
+): boolean => {
+  const { dailyStartTime, dailyStopTime, wholeWeekdaysOff } = sleepSchedule;
+
+  if (
+    arraySymmetricDifference(
+      wholeWeekdaysOff,
+      defaultSleepSchedule.wholeWeekdaysOff,
+    ).length > 0
+  ) {
+    return false;
+  }
+  if (dailyStartTime !== defaultSleepSchedule.dailyStartTime) return false;
+  if (dailyStopTime !== defaultSleepSchedule.dailyStopTime) return false;
+  return true;
+};
+
+export const validator = (({ expirationDetails }, errors) => {
+  const { hostUptime, noExpiration } = expirationDetails ?? {};
+  if (!hostUptime || noExpiration === false) return errors;
+
+  const { sleepSchedule, useDefaultUptimeSchedule } = hostUptime;
+  const { enabledWeekdays, timeSelection } = sleepSchedule;
+
+  if (useDefaultUptimeSchedule) {
+    return errors;
+  }
+
+  const { enabledHoursCount } = getEnabledHoursCount({
+    enabledWeekdays,
+    ...timeSelection,
+  });
+
+  if (enabledHoursCount > maxUptimeHours) {
+    errors.expirationDetails?.hostUptime?.addError("Insufficient hours");
+  }
+
+  return errors;
+}) satisfies ValidateProps<{
+  expirationDetails?: { hostUptime?: HostUptime; noExpiration: boolean };
+}>;
diff --git a/apps/spruce/src/components/Spawn/utils/index.ts b/apps/spruce/src/components/Spawn/utils/index.ts
new file mode 100644
index 000000000..97ce3b90b
--- /dev/null
+++ b/apps/spruce/src/components/Spawn/utils/index.ts
@@ -0,0 +1,14 @@
+export {
+  getDefaultExpiration,
+  getNoExpirationCheckboxTooltipCopy,
+} from "./expiration";
+export {
+  defaultSleepSchedule,
+  defaultStartDate,
+  defaultStopDate,
+  getHostUptimeFromGql,
+  getSleepSchedule,
+  validateUptimeSchedule,
+  validator,
+} from "./hostUptime";
+export type { HostUptime } from "./hostUptime";
diff --git a/apps/spruce/src/components/SpruceForm/FieldTemplates/ArrayFieldTemplates/index.tsx b/apps/spruce/src/components/SpruceForm/FieldTemplates/ArrayFieldTemplates/index.tsx
index c1fcdb31d..6ada8a1eb 100644
--- a/apps/spruce/src/components/SpruceForm/FieldTemplates/ArrayFieldTemplates/index.tsx
+++ b/apps/spruce/src/components/SpruceForm/FieldTemplates/ArrayFieldTemplates/index.tsx
@@ -195,6 +195,7 @@ export const ArrayFieldTemplate: React.FC<ArrayFieldTemplateProps> = ({
         </AddButtonContainer>
       )}
       <ArrayContainer
+        id={id}
         fullWidth={fullWidth || useExpandableCard}
         hasChildren={!!items?.length}
         data-cy={arrayDataCy}
diff --git a/apps/spruce/src/components/SpruceForm/FieldTemplates/ObjectFieldTemplates/index.tsx b/apps/spruce/src/components/SpruceForm/FieldTemplates/ObjectFieldTemplates/index.tsx
index 628362b5c..64df0baa9 100644
--- a/apps/spruce/src/components/SpruceForm/FieldTemplates/ObjectFieldTemplates/index.tsx
+++ b/apps/spruce/src/components/SpruceForm/FieldTemplates/ObjectFieldTemplates/index.tsx
@@ -23,7 +23,7 @@ export const ObjectFieldTemplate = ({
   const warnings = uiSchema["ui:warnings"] ?? [];
   const tooltipTitle = uiSchema["ui:tooltipTitle"] ?? null;
   return (
-    <fieldset css={uiSchema["ui:fieldSetCSS"]} id={idSchema.$id}>
+    <fieldset css={uiSchema["ui:elementWrapperCSS"]} id={idSchema.$id}>
       {(uiSchema["ui:title"] || title) && (
         <TitleContainer>
           <TitleField
diff --git a/apps/spruce/src/components/SpruceForm/Widgets/DateTimePicker.tsx b/apps/spruce/src/components/SpruceForm/Widgets/DateTimePicker.tsx
index e7482d5c7..75dfd7109 100644
--- a/apps/spruce/src/components/SpruceForm/Widgets/DateTimePicker.tsx
+++ b/apps/spruce/src/components/SpruceForm/Widgets/DateTimePicker.tsx
@@ -116,6 +116,7 @@ export const TimePicker: React.FC<
       <AntdTimePicker
         // @ts-expect-error
         getPopupContainer={getPopupContainer}
+        id={id}
         data-cy="time-picker"
         format={format}
         onChange={handleChange}
diff --git a/apps/spruce/src/components/SpruceForm/__snapshots__/SpruceForm.stories.storyshot b/apps/spruce/src/components/SpruceForm/__snapshots__/SpruceForm.stories.storyshot
index b4f1ad065..6369622b1 100644
--- a/apps/spruce/src/components/SpruceForm/__snapshots__/SpruceForm.stories.storyshot
+++ b/apps/spruce/src/components/SpruceForm/__snapshots__/SpruceForm.stories.storyshot
@@ -156,6 +156,7 @@ exports[`Snapshot Tests SpruceForm.stories Example1 1`] = `
               </div>
               <div
                 class="css-1mmfwj9-ArrayContainer e1jxkcec5"
+                id="root_expansions"
               >
                 <div
                   class="css-nbhfvd-ArrayItemRow e1jxkcec7"
diff --git a/apps/spruce/src/constants/fieldMaps.ts b/apps/spruce/src/constants/fieldMaps.ts
index 767a53895..3020dece9 100644
--- a/apps/spruce/src/constants/fieldMaps.ts
+++ b/apps/spruce/src/constants/fieldMaps.ts
@@ -1,3 +1,5 @@
+export const defaultTimeZone = "America/New_York";
+
 export const timeZones = [
   {
     str: "Coordinated Universal Time",
@@ -33,7 +35,7 @@ export const timeZones = [
   },
   {
     str: "Eastern Time",
-    value: "America/New_York",
+    value: defaultTimeZone,
   },
   {
     str: "Venezuela",
diff --git a/apps/spruce/src/gql/generated/types.ts b/apps/spruce/src/gql/generated/types.ts
index 7c21a4197..ebdcdbdf6 100644
--- a/apps/spruce/src/gql/generated/types.ts
+++ b/apps/spruce/src/gql/generated/types.ts
@@ -4782,6 +4782,7 @@ export type EditSpawnHostMutationVariables = Exact<{
   servicePassword?: InputMaybe<Scalars["String"]["input"]>;
   publicKey?: InputMaybe<PublicKeyInput>;
   savePublicKey?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sleepSchedule?: InputMaybe<SleepScheduleInput>;
 }>;
 
 export type EditSpawnHostMutation = {
@@ -6418,6 +6419,16 @@ export type MyHostsQuery = {
     tag: string;
     uptime?: Date | null;
     user?: string | null;
+    sleepSchedule?: {
+      __typename?: "SleepSchedule";
+      dailyStartTime: string;
+      dailyStopTime: string;
+      permanentlyExempt: boolean;
+      shouldKeepOff: boolean;
+      temporarilyExemptUntil?: Date | null;
+      timeZone: string;
+      wholeWeekdaysOff: Array<number>;
+    } | null;
     distro?: {
       __typename?: "DistroInfo";
       id?: string | null;
diff --git a/apps/spruce/src/gql/mocks/getSpruceConfig.ts b/apps/spruce/src/gql/mocks/getSpruceConfig.ts
index ccc03235e..2f88dacf5 100644
--- a/apps/spruce/src/gql/mocks/getSpruceConfig.ts
+++ b/apps/spruce/src/gql/mocks/getSpruceConfig.ts
@@ -4,7 +4,7 @@ import {
   UserSettingsQuery,
   UserSettingsQueryVariables,
 } from "gql/generated/types";
-import { SPRUCE_CONFIG } from "gql/queries";
+import { SPRUCE_CONFIG, USER_SETTINGS } from "gql/queries";
 import { ApolloMock } from "types/gql";
 
 export const getSpruceConfigMock: ApolloMock<
@@ -67,8 +67,8 @@ export const getUserSettingsMock: ApolloMock<
   UserSettingsQueryVariables
 > = {
   request: {
-    query: SPRUCE_CONFIG,
-    variables: null,
+    query: USER_SETTINGS,
+    variables: {},
   },
   result: {
     data: {
@@ -82,6 +82,7 @@ export const getUserSettingsMock: ApolloMock<
         notifications: {
           __typename: "Notifications",
           buildBreak: "",
+          commitQueue: "",
           patchFinish: "",
           patchFirstFailure: "",
           spawnHostExpiration: "",
@@ -90,6 +91,7 @@ export const getUserSettingsMock: ApolloMock<
         region: "us-east-1",
         slackMemberId: "1234",
         slackUsername: "user",
+        timeFormat: "H:mm:ss",
         timezone: "America/New_York",
         useSpruceOptions: {
           __typename: "UseSpruceOptions",
diff --git a/apps/spruce/src/gql/mocks/myVolumesQuery.ts b/apps/spruce/src/gql/mocks/myVolumesQuery.ts
new file mode 100644
index 000000000..688f50421
--- /dev/null
+++ b/apps/spruce/src/gql/mocks/myVolumesQuery.ts
@@ -0,0 +1,60 @@
+import { MyVolumesQuery, MyVolumesQueryVariables } from "gql/generated/types";
+import { MY_VOLUMES } from "gql/queries";
+import { ApolloMock } from "types/gql";
+
+export const myVolumesQueryMock: ApolloMock<
+  MyVolumesQuery,
+  MyVolumesQueryVariables
+> = {
+  request: { query: MY_VOLUMES, variables: {} },
+  result: {
+    data: {
+      myVolumes: [
+        {
+          id: "vol-0228202a15111023c",
+          displayName: "",
+          createdBy: "arjrsatun.psratatel",
+          type: "gp2",
+          availabilityZone: "us-east-1d",
+          size: 200,
+          expiration: new Date("2020-11-12T18:19:39Z"),
+          deviceName: null,
+          hostID: "i-0d5d29bf2e7ee342d",
+          host: {
+            displayName: "hai",
+            id: "i-0d5d29bf2e7ee342d",
+            noExpiration: false,
+            __typename: "Host",
+          },
+          noExpiration: false,
+          homeVolume: false,
+          creationTime: new Date("2020-11-05T18:19:39Z"),
+          migrating: false,
+          __typename: "Volume",
+        },
+        {
+          id: "vol-0d7b1973c71a7cccb",
+          displayName: "ramen",
+          createdBy: "arrastrjun.prastatel",
+          type: "gp2",
+          availabilityZone: "us-east-1d",
+          size: 100,
+          expiration: new Date("2020-11-12T18:24:09Z"),
+          deviceName: null,
+          hostID: "i-0d5d29bf2e7ee342d",
+          host: {
+            displayName: "hai",
+            id: "i-0d5d29bf2e7ee342d",
+            noExpiration: false,
+            __typename: "Host",
+          },
+          noExpiration: false,
+          homeVolume: false,
+          migrating: false,
+          creationTime: new Date("2020-11-05T18:18:36Z"),
+          __typename: "Volume",
+        },
+      ],
+    },
+  },
+};
diff --git a/apps/spruce/src/gql/mutations/edit-spawn-host.graphql b/apps/spruce/src/gql/mutations/edit-spawn-host.graphql
index 0912421a7..14800d3cf 100644
--- a/apps/spruce/src/gql/mutations/edit-spawn-host.graphql
+++ b/apps/spruce/src/gql/mutations/edit-spawn-host.graphql
@@ -12,6 +12,7 @@ mutation EditSpawnHost(
   $servicePassword: String
   $publicKey: PublicKeyInput
   $savePublicKey: Boolean
+  $sleepSchedule: SleepScheduleInput
 ) {
   editSpawnHost(
     spawnHost: {
@@ -26,6 +27,7 @@ mutation EditSpawnHost(
       servicePassword: $servicePassword
       publicKey: $publicKey
       savePublicKey: $savePublicKey
+      sleepSchedule: $sleepSchedule
     }
   ) {
     ...BaseSpawnHost
diff --git a/apps/spruce/src/gql/queries/my-hosts.graphql b/apps/spruce/src/gql/queries/my-hosts.graphql
index f3efa18eb..ccf676480 100644
--- a/apps/spruce/src/gql/queries/my-hosts.graphql
+++ b/apps/spruce/src/gql/queries/my-hosts.graphql
@@ -3,5 +3,14 @@
 query MyHosts {
   myHosts {
     ...BaseSpawnHost
+    sleepSchedule {
+      dailyStartTime
+      dailyStopTime
+      permanentlyExempt
+      shouldKeepOff
+      temporarilyExemptUntil
+      timeZone
+      wholeWeekdaysOff
+    }
   }
 }
diff --git a/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.test.tsx b/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.test.tsx
new file mode 100644
index 000000000..b1565e93a
--- /dev/null
+++ b/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.test.tsx
@@ -0,0 +1,333 @@
+import { MockedProvider, MockedResponse } from "@apollo/client/testing";
+import { defaultSleepSchedule } from "components/Spawn/utils";
+import { RenderFakeToastContext } from "context/toast/__mocks__";
+import {
+  InstanceTypesQuery,
+  InstanceTypesQueryVariables,
+  MyHostsQuery,
+  MyHostsQueryVariables,
+  MyPublicKeysQuery,
+  MyPublicKeysQueryVariables,
+} from "gql/generated/types";
+import {
+  getSpruceConfigMock,
+  getUserSettingsMock,
+} from "gql/mocks/getSpruceConfig";
+import { getUserMock } from "gql/mocks/getUser";
+import { myVolumesQueryMock } from "gql/mocks/myVolumesQuery";
+import { INSTANCE_TYPES, MY_HOSTS, MY_PUBLIC_KEYS } from "gql/queries";
+import {
+  renderWithRouterMatch as render,
+  screen,
+  userEvent,
+  within,
+} from "test_utils";
+import { ApolloMock } from "types/gql";
+import { MyHost } from "types/spawn";
+import { EditSpawnHostModal } from "./EditSpawnHostModal";
+
+describe("editSpawnHostModal", () => {
+  it("renders modal", () => {
+    const { Component } = RenderFakeToastContext(
+      <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+    );
+    render(
+      <MockedProvider mocks={baseMocks}>
+        <Component />
+      </MockedProvider>,
+    );
+    expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+  });
+
+  it("disables save button when no changes have been made", () => {
+    const { Component } = RenderFakeToastContext(
+      <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+    );
+    render(
+      <MockedProvider mocks={baseMocks}>
+        <Component />
+      </MockedProvider>,
+    );
+    expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+    expect(screen.getByRole("button", { name: "Save" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+  });
+
+  describe("when default sleep schedule is enabled", () => {
+    it("has default sleep schedule checkbox checked", () => {
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      expect(
+        screen.queryByLabelText("Use default host uptime schedule", {
+          exact: false,
+        }),
+      ).toBeChecked();
+    });
+
+    it("has all daypicker elements disabled", () => {
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      within(screen.queryByDataCy("daypicker"))
+        .getAllByRole("checkbox")
+        .forEach((day) => {
+          expect(day).toBeDisabled();
+        });
+    });
+
+    it("has default days selected", () => {
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      expect(screen.queryByLabelText("M")).toHaveAttribute(
+        "aria-checked",
+        "true",
+      );
+      expect(screen.queryByLabelText("W")).toHaveAttribute(
+        "aria-checked",
+        "true",
+      );
+      expect(screen.queryByLabelText("F")).toHaveAttribute(
+        "aria-checked",
+        "true",
+      );
+      screen.queryAllByLabelText("T").forEach((day) => {
+        expect(day).toHaveAttribute("aria-checked", "true");
+      });
+      screen.queryAllByLabelText("S").forEach((day) => {
+        expect(day).toHaveAttribute("aria-checked", "false");
+      });
+    });
+
+    it("has timepicker elements disabled", () => {
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      expect(screen.queryByLabelText("Start Time")).toBeDisabled();
+      expect(screen.queryByLabelText("Stop Time")).toBeDisabled();
+      expect(
+        screen.queryByLabelText("Run continuously for enabled days"),
+      ).not.toBeChecked();
+      expect(
+        screen.queryByLabelText("Run continuously for enabled days"),
+      ).toHaveAttribute("aria-disabled", "true");
+    });
+  });
+
+  describe("when disabling the default sleep schedule", () => {
+    it("shows the updated hour count when changing the schedule", async () => {
+      const user = userEvent.setup();
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      await user.click(
+        screen.queryByText("Use default host uptime schedule", {
+          exact: false,
+        }),
+      );
+      within(screen.queryByDataCy("daypicker"))
+        .getAllByRole("checkbox")
+        .forEach((day) => {
+          expect(day).not.toBeDisabled();
+        });
+      await user.click(screen.queryByLabelText("Start Time"));
+      await user.click(screen.queryAllByText("07")[0]);
+      await user.click(screen.getByRole("button", { name: "OK" }));
+      expect(screen.queryByLabelText("Start Time")).toHaveValue("07:00");
+      expect(screen.queryByDataCy("host-uptime-details")).toHaveTextContent(
+        "65",
+      );
+    });
+
+    it("shows a warning when user has configured a schedule over the recommended limit", async () => {
+      const user = userEvent.setup();
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      await user.click(
+        screen.queryByText("Use default host uptime schedule", {
+          exact: false,
+        }),
+      );
+      await user.click(screen.queryByTitle("Sunday"));
+      await user.click(screen.queryByText("Run continuously for enabled days"));
+      expect(screen.queryByDataCy("host-uptime-details")).toHaveTextContent(
+        "144",
+      );
+      expect(
+        screen.queryByText("Consider pausing your host for 2 days per week."),
+      ).toBeVisible();
+    });
+
+    it("shows an error and disables save when user has configured a schedule over the hard limit", async () => {
+      const user = userEvent.setup();
+      const { Component } = RenderFakeToastContext(
+        <EditSpawnHostModal host={baseSpawnHost} visible onCancel={() => {}} />,
+      );
+      render(
+        <MockedProvider mocks={baseMocks}>
+          <Component />
+        </MockedProvider>,
+      );
+      expect(screen.queryByDataCy("edit-spawn-host-modal")).toBeVisible();
+      await user.click(
+        screen.queryByText("Use default host uptime schedule", {
+          exact: false,
+        }),
+      );
+      await user.click(screen.queryByTitle("Sunday"));
+      await user.click(screen.queryByTitle("Saturday"));
+      await user.click(screen.queryByText("Run continuously for enabled days"));
+      expect(screen.queryByDataCy("host-uptime-details")).toHaveTextContent(
+        "168",
+      );
+      expect(
+        screen.queryByText(
+          "Please pause your host for at least 1 day per week.",
+        ),
+      ).toBeVisible();
+      expect(screen.queryByRole("button", { name: "Save" })).toHaveAttribute(
+        "aria-disabled",
+        "true",
+      );
+    });
+  });
+});
+
+const baseSpawnHost: MyHost = {
+  id: "i-0e2424677dfab890e",
+  distro: {
+    isVirtualWorkStation: true,
+    id: "ubuntu1804-workstation",
+    user: "ubuntu",
+    workDir: "/home/ubuntu",
+    isWindows: false,
+    __typename: "DistroInfo",
+  },
+  expiration: new Date("2024-05-06T20:27:43.024Z"),
+  hostUrl: "ec2-34-201-138-106.compute-1.amazonaws.com",
+  homeVolumeID: "vol-07fa9f6b5c2067e34",
+  homeVolume: {
+    id: "home-volume-id",
+    displayName: "",
+  },
+  instanceType: "m5.xlarge",
+  instanceTags: [],
+  volumes: [
+    {
+      displayName: "",
+      id: "vol-0cf616375140c067e",
+      migrating: false,
+      __typename: "Volume",
+    },
+  ],
+  noExpiration: true,
+  persistentDnsName: "",
+  provider: "ec2-ondemand",
+  startedBy: "stssss.arst",
+  status: "running",
+  tag: "evg-ubuntu1804-workstation-20201014223740-6478743249380995507",
+  user: "ubuntu",
+  uptime: new Date("2020-10-14T22:37:40Z"),
+  displayName: "",
+  availabilityZone: "us-east-1c",
+  sleepSchedule: {
+    ...defaultSleepSchedule,
+    timeZone: "America/New_York",
+  },
+  __typename: "Host",
+};
+
+const myHostsMock: ApolloMock<MyHostsQuery, MyHostsQueryVariables> = {
+  request: { query: MY_HOSTS, variables: {} },
+  result: {
+    data: {
+      myHosts: [baseSpawnHost],
+    },
+  },
+};
+
+const myPublicKeysMock: ApolloMock<
+  MyPublicKeysQuery,
+  MyPublicKeysQueryVariables
+> = {
+  request: { query: MY_PUBLIC_KEYS, variables: {} },
+  result: {
+    data: {
+      myPublicKeys: [{ key: "abc", name: "MBP", __typename: "PublicKey" }],
+    },
+  },
+};
+
+const instanceTypesMock: ApolloMock<
+  InstanceTypesQuery,
+  InstanceTypesQueryVariables
+> = {
+  request: { query: INSTANCE_TYPES, variables: {} },
+  result: {
+    data: {
+      instanceTypes: [
+        "c5.xlarge",
+        "c5.2xlarge",
+        "c5.4xlarge",
+        "m5.4xlarge",
+        "m6i.xlarge",
+        "m6i.2xlarge",
+        "m6i.4xlarge",
+        "m6g.2xlarge",
+        "m6g.4xlarge",
+        "m7g.2xlarge",
+        "m7g.4xlarge",
+      ],
+    },
+  },
+};
+
+const baseMocks: MockedResponse[] = [
+  getUserMock,
+  getUserSettingsMock,
+  getSpruceConfigMock,
+  instanceTypesMock,
+  myHostsMock,
+  myVolumesQueryMock,
+  myPublicKeysMock,
+];
diff --git a/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.tsx b/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.tsx
index b671f933c..9cca551e3 100644
--- a/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.tsx
+++ b/apps/spruce/src/pages/spawn/spawnHost/EditSpawnHostModal.tsx
@@ -1,7 +1,13 @@
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { useMutation } from "@apollo/client";
 import { useSpawnAnalytics } from "analytics";
 import { ConfirmationModal } from "components/ConfirmationModal";
+import {
+  defaultSleepSchedule,
+  getHostUptimeFromGql,
+  validateUptimeSchedule,
+  validator,
+} from "components/Spawn";
 import {
   FormState,
   computeDiff,
@@ -10,12 +16,14 @@ import {
   useLoadFormData,
 } from "components/Spawn/editHostModal";
 import { SpruceForm } from "components/SpruceForm";
+import { defaultTimeZone } from "constants/fieldMaps";
 import { useToastContext } from "context/toast";
 import {
   EditSpawnHostMutation,
   EditSpawnHostMutationVariables,
 } from "gql/generated/types";
 import { EDIT_SPAWN_HOST } from "gql/mutations";
+import { useUserTimeZone } from "hooks";
 import { HostStatus } from "types/host";
 import { MyHost } from "types/spawn";
 import { omit } from "utils/object";
@@ -32,6 +40,7 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
 }) => {
   const dispatchToast = useToastContext();
   const { sendEvent } = useSpawnAnalytics();
+  const timeZone = useUserTimeZone() || defaultTimeZone;
 
   const {
     disableExpirationCheckbox,
@@ -41,7 +50,12 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
     volumesData,
   } = useLoadFormData(host);
 
-  const instanceTypes = instanceTypesData?.instanceTypes ?? [];
+  let instanceTypes = instanceTypesData?.instanceTypes ?? [];
+  // The list of instance types provided by Evergreen can be out-of-date, so make sure the instance type in use is considered valid by RJSF
+  if (!instanceTypes.includes(host.instanceType)) {
+    instanceTypes = [...instanceTypes, host.instanceType];
+  }
+
   const volumes =
     volumesData?.myVolumes?.filter(
       (v) => v.availabilityZone === host.availabilityZone && v.hostID === "",
@@ -54,18 +68,36 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
 
   const initialFormState = {
     hostName: host.displayName ?? "",
-    expirationDetails: {
-      expiration: host.expiration ? host.expiration.toString() : null,
-      noExpiration: host.noExpiration,
-    },
     instanceType: host.instanceType ?? "",
     volume: "",
     rdpPassword: "",
     userTags,
+    expirationDetails: {
+      expiration: host.expiration ? host.expiration.toString() : null,
+      noExpiration: host.noExpiration,
+      hostUptime: host.noExpiration
+        ? getHostUptimeFromGql(host.sleepSchedule)
+        : getHostUptimeFromGql({ ...defaultSleepSchedule, timeZone }),
+    },
     publicKeySection: { useExisting: true, publicKeyNameDropdown: "" },
   };
 
   const [formState, setFormState] = useState<FormState>(initialFormState);
+  const [hasError, setHasError] = useState(false);
+
+  const hostUptimeValidation = useMemo(
+    () =>
+      validateUptimeSchedule({
+        enabledWeekdays:
+          formState?.expirationDetails?.hostUptime?.sleepSchedule
+            ?.enabledWeekdays,
+        ...formState?.expirationDetails?.hostUptime?.sleepSchedule
+          ?.timeSelection,
+        useDefaultUptimeSchedule:
+          formState?.expirationDetails?.hostUptime?.useDefaultUptimeSchedule,
+      }),
+    [formState?.expirationDetails?.hostUptime],
+  );
 
   const { schema, uiSchema } = getFormSchema({
     canEditInstanceType: host.status === HostStatus.Stopped,
@@ -73,9 +105,11 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
       host.distro.isWindows && host.status === HostStatus.Running,
     canEditSshKeys: host.status === HostStatus.Running,
     disableExpirationCheckbox,
+    hostUptimeValidation,
     instanceTypes: instanceTypes ?? [],
     myPublicKeys: publicKeys ?? [],
     noExpirationCheckboxTooltip,
+    timeZone,
     volumes,
   });
 
@@ -103,6 +137,7 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
     hostId: host.id,
     myPublicKeys: publicKeys,
     oldUserTags: userTags,
+    timeZone,
   });
 
   const currEditState = formToGql({
@@ -110,6 +145,7 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
     hostId: host.id,
     myPublicKeys: publicKeys,
     oldUserTags: userTags,
+    timeZone,
   });
 
   const [hasChanges, mutationParams] = computeDiff(
@@ -138,7 +174,7 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
       title="Edit Host Details"
       open={visible}
       data-cy="edit-spawn-host-modal"
-      submitDisabled={!hasChanges || loadingSpawnHost}
+      submitDisabled={!hasChanges || hasError || loadingSpawnHost}
       onCancel={() => {
         onCancel();
         setFormState(initialFormState);
@@ -150,9 +186,12 @@ export const EditSpawnHostModal: React.FC<EditSpawnHostModalProps> = ({
         schema={schema}
         uiSchema={uiSchema}
         formData={formState}
-        onChange={({ formData }) => {
+        onChange={({ errors, formData }) => {
           setFormState(formData);
+          setHasError(errors.length > 0);
         }}
+        // @ts-expect-error rjsf v4 has insufficient typing for its validator
+        validate={validator}
       />
     </ConfirmationModal>
   );
diff --git a/apps/spruce/src/pages/spawn/spawnHost/spawnHostButton/SpawnHostModal.tsx b/apps/spruce/src/pages/spawn/spawnHost/spawnHostButton/SpawnHostModal.tsx
index 6b87bcdef..4e925dd14 100644
--- a/apps/spruce/src/pages/spawn/spawnHost/spawnHostButton/SpawnHostModal.tsx
+++ b/apps/spruce/src/pages/spawn/spawnHost/spawnHostButton/SpawnHostModal.tsx
@@ -3,7 +3,7 @@ import { useQuery, useMutation } from "@apollo/client";
 import { useLocation } from "react-router-dom";
 import { useSpawnAnalytics } from "analytics";
 import { ConfirmationModal } from "components/ConfirmationModal";
-import { maxUptimeHours, validateUptimeSchedule } from "components/Spawn";
+import { validateUptimeSchedule, validator } from "components/Spawn";
 import {
   formToGql,
   getFormSchema,
@@ -11,7 +11,8 @@ import {
   useVirtualWorkstationDefaultExpiration,
   FormState,
 } from "components/Spawn/spawnHostModal";
-import { SpruceForm, ValidateProps } from "components/SpruceForm";
+import { SpruceForm } from "components/SpruceForm";
+import { defaultTimeZone } from "constants/fieldMaps";
 import { useToastContext } from "context/toast";
 import {
   SpawnHostMutation,
@@ -36,7 +37,7 @@ export const SpawnHostModal: React.FC<SpawnHostModalProps> = ({
 }) => {
   const dispatchToast = useToastContext();
   const spawnAnalytics = useSpawnAnalytics();
-  const timeZone = useUserTimeZone();
+  const timeZone = useUserTimeZone() || defaultTimeZone;
 
   // Handle distroId, taskId query param
   const { search } = useLocation();
@@ -161,26 +162,8 @@ export const SpawnHostModal: React.FC<SpawnHostModalProps> = ({
           setHasError(errors.length > 0);
         }}
         // @ts-expect-error rjsf v4 has insufficient typing for its validator
-        validate={validate(hostUptimeValidation?.enabledHoursCount ?? 0)}
+        validate={validator}
       />
     </ConfirmationModal>
   );
 };
-
-const validate = (enabledHoursCount: number) =>
-  (({ expirationDetails }, errors) => {
-    const { hostUptime } = expirationDetails ?? {};
-    if (!hostUptime) return errors;
-
-    const { useDefaultUptimeSchedule } = hostUptime;
-
-    if (!useDefaultUptimeSchedule) {
-      if (enabledHoursCount > maxUptimeHours) {
-        errors.expirationDetails?.hostUptime?.sleepSchedule?.addError(
-          "Insufficient hours",
-        );
-      }
-    }
-
-    return errors;
-  }) satisfies ValidateProps<FormState>;
diff --git a/apps/spruce/src/pages/spawn/spawnVolume/SpawnVolumeModal.test.tsx b/apps/spruce/src/pages/spawn/spawnVolume/SpawnVolumeModal.test.tsx
index 77f0c0f29..6b63e3729 100644
--- a/apps/spruce/src/pages/spawn/spawnVolume/SpawnVolumeModal.test.tsx
+++ b/apps/spruce/src/pages/spawn/spawnVolume/SpawnVolumeModal.test.tsx
@@ -3,8 +3,6 @@ import { RenderFakeToastContext } from "context/toast/__mocks__";
 import {
   MyHostsQuery,
   MyHostsQueryVariables,
-  MyVolumesQuery,
-  MyVolumesQueryVariables,
   SpawnVolumeMutation,
   SpawnVolumeMutationVariables,
   SubnetAvailabilityZonesQuery,
@@ -12,8 +10,9 @@ import {
 } from "gql/generated/types";
 import { getSpruceConfigMock } from "gql/mocks/getSpruceConfig";
 import { getUserMock } from "gql/mocks/getUser";
+import { myVolumesQueryMock } from "gql/mocks/myVolumesQuery";
 import { SPAWN_VOLUME } from "gql/mutations";
-import { MY_HOSTS, SUBNET_AVAILABILITY_ZONES, MY_VOLUMES } from "gql/queries";
+import { MY_HOSTS, SUBNET_AVAILABILITY_ZONES } from "gql/queries";
 import {
   userEvent,
   renderWithRouterMatch as render,
@@ -351,61 +350,6 @@ const myHostsMock: ApolloMock<MyHostsQuery, MyHostsQueryVariables> = {
   },
 };
 
-const myVolumesQueryMock: ApolloMock<MyVolumesQuery, MyVolumesQueryVariables> =
-  {
-    request: { query: MY_VOLUMES, variables: {} },
-    result: {
-      data: {
-        myVolumes: [
-          {
-            id: "vol-0228202a15111023c",
-            displayName: "",
-            createdBy: "arjrsatun.psratatel",
-            type: "gp2",
-            availabilityZone: "us-east-1d",
-            size: 200,
-            expiration: new Date("2020-11-12T18:19:39Z"),
-            deviceName: null,
-            hostID: "i-0d5d29bf2e7ee342d",
-            host: {
-              displayName: "hai",
-              id: "i-0d5d29bf2e7ee342d",
-              noExpiration: false,
-              __typename: "Host",
-            },
-            noExpiration: false,
-            homeVolume: false,
-            creationTime: new Date("2020-11-05T18:19:39Z"),
-            migrating: false,
-            __typename: "Volume",
-          },
-          {
-            id: "vol-0d7b1973c71a7cccb",
-            displayName: "ramen",
-            createdBy: "arrastrjun.prastatel",
-            type: "gp2",
-            availabilityZone: "us-east-1d",
-            size: 100,
-            expiration: new Date("2020-11-12T18:24:09Z"),
-            deviceName: null,
-            hostID: "i-0d5d29bf2e7ee342d",
-            host: {
-              displayName: "hai",
-              id: "i-0d5d29bf2e7ee342d",
-              noExpiration: false,
-              __typename: "Host",
-            },
-            noExpiration: false,
-            homeVolume: false,
-            migrating: false,
-            creationTime: new Date("2020-11-05T18:18:36Z"),
-            __typename: "Volume",
-          },
-        ],
-      },
-    },
-  };
-
 const subnetZonesMock: ApolloMock<
   SubnetAvailabilityZonesQuery,
   SubnetAvailabilityZonesQueryVariables