diff --git a/src/components/plan/PlanForm.svelte b/src/components/plan/PlanForm.svelte
index af576be102..b5e39fa4e3 100644
--- a/src/components/plan/PlanForm.svelte
+++ b/src/components/plan/PlanForm.svelte
@@ -14,8 +14,10 @@
   import { viewTogglePanel } from '../../stores/views';
   import type { ActivityDirective, ActivityDirectiveId } from '../../types/activity';
   import type { User, UserId } from '../../types/app';
+  import type { ArgumentsMap } from '../../types/parameter';
   import type { Plan, PlanCollaborator, PlanSlimmer, PlanTransfer } from '../../types/plan';
   import type { PlanSnapshot as PlanSnapshotType } from '../../types/plan-snapshot';
+  import type { Simulation } from '../../types/simulation';
   import type { PlanTagsInsertInput, Tag, TagsChangeEvent } from '../../types/tags';
   import effects from '../../utilities/effects';
   import { removeQueryParam, setQueryParam } from '../../utilities/generic';
@@ -166,35 +168,54 @@
       let totalProgress = 0;
       const numOfDirectives = Object.values(activityDirectivesMap).length;
 
-      qualifiedActivityDirectives = await Promise.all(
-        Object.values(activityDirectivesMap).map(async activityDirective => {
-          if (plan) {
-            const effectiveArguments = await effects.getEffectiveActivityArguments(
-              plan?.model_id,
-              activityDirective.type,
-              activityDirective.arguments,
-              user,
-              planExportAbortController?.signal,
-            );
+      const simulation: Simulation | null = await effects.getPlanLatestSimulation(plan.id, user);
 
-            totalProgress++;
-            planExportProgress = (totalProgress / numOfDirectives) * 100;
-
-            return {
-              ...activityDirective,
-              arguments: effectiveArguments?.arguments ?? activityDirective.arguments,
-            };
+      const simulationArguments: ArgumentsMap = simulation
+        ? {
+            ...simulation.template?.arguments,
+            ...simulation.arguments,
           }
+        : {};
+
+      qualifiedActivityDirectives = (
+        await Promise.all(
+          Object.values(activityDirectivesMap).map(async activityDirective => {
+            if (plan) {
+              const effectiveArguments = await effects.getEffectiveActivityArguments(
+                plan?.model_id,
+                activityDirective.type,
+                activityDirective.arguments,
+                user,
+                planExportAbortController?.signal,
+              );
+
+              totalProgress++;
+              planExportProgress = (totalProgress / numOfDirectives) * 100;
+
+              return {
+                ...activityDirective,
+                arguments: effectiveArguments?.arguments ?? activityDirective.arguments,
+              };
+            }
 
-          totalProgress++;
-          planExportProgress = (totalProgress / numOfDirectives) * 100;
+            totalProgress++;
+            planExportProgress = (totalProgress / numOfDirectives) * 100;
 
-          return activityDirective;
-        }),
-      );
+            return activityDirective;
+          }),
+        )
+      ).sort((directiveA, directiveB) => {
+        if (directiveA.id < directiveB.id) {
+          return -1;
+        }
+        if (directiveA.id > directiveB.id) {
+          return 1;
+        }
+        return 0;
+      });
 
       if (planExportAbortController && !planExportAbortController.signal.aborted) {
-        const planExport: PlanTransfer = getPlanForTransfer(plan, qualifiedActivityDirectives);
+        const planExport: PlanTransfer = getPlanForTransfer(plan, qualifiedActivityDirectives, simulationArguments);
 
         const a = document.createElement('a');
         a.href = URL.createObjectURL(new Blob([JSON.stringify(planExport, null, 2)], { type: 'application/json' }));
@@ -226,7 +247,6 @@
         <svelte:fragment slot="right">
           <button
             class="st-button icon export"
-            style={'visibility:hidden;'}
             on:click|stopPropagation={onPlanExport}
             use:tooltip={{ content: planExportProgress === null ? 'Export Plan JSON' : 'Cancel Plan Export' }}
           >
diff --git a/src/routes/plans/+page.svelte b/src/routes/plans/+page.svelte
index bd81278ad1..e8229ddf69 100644
--- a/src/routes/plans/+page.svelte
+++ b/src/routes/plans/+page.svelte
@@ -6,6 +6,7 @@
   import { page } from '$app/stores';
   import PlanIcon from '@nasa-jpl/stellar/icons/plan.svg?component';
   import type { ICellRendererParams, ValueGetterParams } from 'ag-grid-community';
+  import { flatten } from 'lodash-es';
   import { onDestroy, onMount } from 'svelte';
   import Nav from '../../components/app/Nav.svelte';
   import PageTitle from '../../components/app/PageTitle.svelte';
@@ -34,17 +35,20 @@
   import type { User } from '../../types/app';
   import type { DataGridColumnDef, RowId } from '../../types/data-grid';
   import type { ModelSlim } from '../../types/model';
-  import type { Plan, PlanSlim } from '../../types/plan';
+  import type { DeprecatedPlanTransfer, Plan, PlanSlim, PlanTransfer } from '../../types/plan';
   import type { PlanTagsInsertInput, Tag, TagsChangeEvent } from '../../types/tags';
+  import { generateRandomPastelColor } from '../../utilities/color';
   import effects from '../../utilities/effects';
   import { removeQueryParam } from '../../utilities/generic';
   import { permissionHandler } from '../../utilities/permissionHandler';
   import { featurePermissions } from '../../utilities/permissions';
+  import { isDeprecatedPlanTransfer } from '../../utilities/plan';
   import {
     convertDoyToYmd,
     convertUsToDurationString,
     formatDate,
     getDoyTime,
+    getDoyTimeFromInterval,
     getShortISOForDate,
   } from '../../utilities/time';
   import { min, required, unique } from '../../utilities/validators';
@@ -220,6 +224,8 @@
       'Plan name already exists',
     ),
   ]);
+  let planUploadFiles: FileList | undefined;
+  let fileInput: HTMLInputElement;
   let simTemplateField = field<number | null>(null);
 
   $: startTimeField = field<string>('', [required, $plugins.time.primary.validate]);
@@ -325,26 +331,46 @@
     }
     let startTime = getDoyTime(startTimeDate);
     let endTime = getDoyTime(endTimeDate);
-    const newPlan = await effects.createPlan(
-      endTime,
-      $modelIdField.value,
-      $nameField.value,
-      startTime,
-      $simTemplateField.value,
-      user,
-    );
-
-    if (newPlan) {
-      // Associate new tags with plan
-      const newPlanTags: PlanTagsInsertInput[] = (planTags || []).map(({ id: tag_id }) => ({
-        plan_id: newPlan.id,
-        tag_id,
-      }));
-      newPlan.tags = planTags.map(tag => ({ tag }));
-      if (!$plans.find(({ id }) => newPlan.id === id)) {
-        plans.updateValue(storePlans => [...storePlans, newPlan]);
+    if (planUploadFiles && planUploadFiles.length) {
+      await effects.importPlan(
+        $nameField.value,
+        $modelIdField.value,
+        startTime,
+        endTime,
+        $simTemplateField.value,
+        planTags.map(({ id }) => id),
+        planUploadFiles,
+        user,
+      );
+      fileInput.value = '';
+      planUploadFiles = undefined;
+      $startTimeField.value = '';
+      $endTimeField.value = '';
+      $nameField.value = '';
+    } else {
+      const newPlan: PlanSlim | null = await effects.createPlan(
+        endTime,
+        $modelIdField.value,
+        $nameField.value,
+        startTime,
+        $simTemplateField.value,
+        user,
+      );
+      if (newPlan) {
+        // Associate new tags with plan
+        const newPlanTags: PlanTagsInsertInput[] = (planTags || []).map(({ id: tag_id }) => ({
+          plan_id: newPlan.id,
+          tag_id,
+        }));
+        newPlan.tags = planTags.map(tag => ({ tag }));
+        if (!$plans.find(({ id }) => newPlan.id === id)) {
+          plans.updateValue(storePlans => [...storePlans, newPlan]);
+        }
+        await effects.createPlanTags(newPlanTags, newPlan, user);
+        $startTimeField.value = '';
+        $endTimeField.value = '';
+        $nameField.value = '';
       }
-      await effects.createPlanTags(newPlanTags, newPlan, user);
     }
   }
 
@@ -418,6 +444,82 @@
       durationString = 'None';
     }
   }
+  async function onReaderLoad(event: ProgressEvent<FileReader>) {
+    if (event.target !== null && event.target.result !== null) {
+      const planJSON: PlanTransfer | DeprecatedPlanTransfer = JSON.parse(`${event.target.result}`) as
+        | PlanTransfer
+        | DeprecatedPlanTransfer;
+      nameField.validateAndSet(planJSON.name);
+      const importedPlanTags = (planJSON.tags ?? []).reduce(
+        (previousTags: { existingTags: Tag[]; newTags: Pick<Tag, 'color' | 'name'>[] }, importedPlanTag) => {
+          const {
+            tag: { color: importedPlanTagColor, name: importedPlanTagName },
+          } = importedPlanTag;
+          const existingTag = $tags.find(({ name }) => importedPlanTagName === name);
+
+          if (existingTag) {
+            return {
+              ...previousTags,
+              existingTags: [...previousTags.existingTags, existingTag],
+            };
+          } else {
+            return {
+              ...previousTags,
+              newTags: [
+                ...previousTags.newTags,
+                {
+                  color: importedPlanTagColor,
+                  name: importedPlanTagName,
+                },
+              ],
+            };
+          }
+        },
+        {
+          existingTags: [],
+          newTags: [],
+        },
+      );
+
+      const newTags: Tag[] = flatten(
+        await Promise.all(
+          importedPlanTags.newTags.map(async ({ color: tagColor, name: tagName }) => {
+            return (
+              (await effects.createTags([{ color: tagColor ?? generateRandomPastelColor(), name: tagName }], user)) ||
+              []
+            );
+          }),
+        ),
+      );
+
+      planTags = [...importedPlanTags.existingTags, ...newTags];
+
+      // remove the `+00:00` timezone before parsing
+      const startTime = `${convertDoyToYmd(planJSON.start_time.replace(/\+00:00/, ''))}`;
+      await startTimeField.validateAndSet(getDoyTime(new Date(startTime), true));
+
+      if (isDeprecatedPlanTransfer(planJSON)) {
+        await endTimeField.validateAndSet(
+          getDoyTime(new Date(`${convertDoyToYmd(planJSON.end_time.replace(/\+00:00/, ''))}`), true),
+        );
+      } else {
+        const { duration } = planJSON;
+
+        await endTimeField.validateAndSet(getDoyTimeFromInterval(startTime, duration));
+      }
+
+      updateDurationString();
+    }
+  }
+
+  function onPlanFileChange(event: Event) {
+    const files = (event.target as HTMLInputElement).files;
+    if (files !== null && files.length) {
+      const reader = new FileReader();
+      reader.onload = onReaderLoad;
+      reader.readAsText(files[0]);
+    }
+  }
 </script>
 
 <PageTitle title="Plans" />
@@ -437,6 +539,22 @@
         <form on:submit|preventDefault={createPlan}>
           <AlertError class="m-2" error={$createPlanError} />
 
+          <fieldset>
+            <label for="file">Import Plan JSON File</label>
+            <input
+              class="w-100"
+              name="file"
+              type="file"
+              bind:files={planUploadFiles}
+              bind:this={fileInput}
+              use:permissionHandler={{
+                hasPermission: canCreate,
+                permissionError,
+              }}
+              on:change={onPlanFileChange}
+            />
+          </fieldset>
+
           <Field field={modelIdField}>
             <label for="model" slot="label">Models</label>
             <select
diff --git a/src/types/plan.ts b/src/types/plan.ts
index 91a78f2137..f760835cdb 100644
--- a/src/types/plan.ts
+++ b/src/types/plan.ts
@@ -2,6 +2,7 @@ import type { ActivityDirective } from './activity';
 import type { UserId } from './app';
 import type { ConstraintPlanSpec } from './constraint';
 import type { Model } from './model';
+import type { ArgumentsMap } from './parameter';
 import type { SchedulingPlanSpecification } from './scheduling';
 import type { Tag } from './tags';
 
@@ -92,14 +93,25 @@ export type PlanSchema = {
   updated_by: UserId;
 };
 
-export type PlanTransfer = Pick<PlanSchema, 'id' | 'model_id' | 'name' | 'start_time'> & {
+export type PlanTransfer = Pick<PlanSchema, 'id' | 'duration' | 'model_id' | 'name' | 'start_time'> & {
   activities: Pick<
     ActivityDirective,
-    'anchor_id' | 'anchored_to_start' | 'arguments' | 'id' | 'metadata' | 'name' | 'start_offset' | 'type'
+    | 'anchor_id'
+    | 'anchored_to_start'
+    | 'arguments'
+    | 'id'
+    | 'metadata'
+    | 'name'
+    | 'start_offset'
+    | ('type' & { tags: { tag: Pick<Tag, 'color' | 'name'> }[] })
   >[];
+  simulation_arguments: ArgumentsMap;
+  tags?: { tag: Pick<Tag, 'color' | 'name'> }[];
+};
+
+export type DeprecatedPlanTransfer = Omit<PlanTransfer, 'duration' | 'simulation_arguments'> & {
   end_time: string;
   sim_id: number;
-  tags: { tag: Pick<Tag, 'id' | 'name'> }[];
 };
 
 export type PlanMetadata = Pick<
diff --git a/src/utilities/effects.ts b/src/utilities/effects.ts
index 8c49707283..25c9dc7f5e 100644
--- a/src/utilities/effects.ts
+++ b/src/utilities/effects.ts
@@ -201,7 +201,7 @@ import {
   showRestorePlanSnapshotModal,
   showUploadViewModal,
 } from './modal';
-import { queryPermissions } from './permissions';
+import { gatewayPermissions, queryPermissions } from './permissions';
 import { reqExtension, reqGateway, reqHasura } from './requests';
 import { sampleProfiles } from './resources';
 import { convertResponseToMetadata } from './scheduling';
@@ -3166,6 +3166,19 @@ const effects = {
     }
   },
 
+  async getPlanLatestSimulation(planId: number, user: User | null): Promise<Simulation | null> {
+    const query = convertToQuery(gql.SUB_SIMULATION);
+    const data = await reqHasura<Simulation[]>(query, { planId }, user);
+
+    const { simulation } = data;
+
+    if (simulation) {
+      return simulation[0];
+    }
+
+    return null;
+  },
+
   async getPlanMergeConflictingActivities(
     merge_request_id: number,
     user: User | null,
@@ -3805,6 +3818,48 @@ const effects = {
     }
   },
 
+  async importPlan(
+    name: string,
+    modelId: number,
+    startTime: string,
+    endTime: string,
+    simulationTemplateId: number | null,
+    tagIds: number[],
+    files: FileList,
+    user: User | null,
+  ): Promise<PlanSlim | null> {
+    try {
+      if (!gatewayPermissions.IMPORT_PLAN(user)) {
+        throwPermissionError('import a plan');
+      }
+      const file: File = files[0];
+
+      const duration = getIntervalFromDoyRange(startTime, endTime);
+
+      const body = new FormData();
+      body.append('name', `${name}`);
+      body.append('model_id', `${modelId}`);
+      body.append('start_time', `${startTime}`);
+      body.append('duration', `${duration}`);
+      if (simulationTemplateId !== null) {
+        body.append('simulation_template_id', `${simulationTemplateId}`);
+      }
+      body.append('tags', JSON.stringify(tagIds));
+      body.append('plan_file', file, file.name);
+
+      const createdPlan = await reqGateway<PlanSlim | null>('/importPlan', 'POST', body, user, true);
+
+      if (createdPlan != null) {
+        return createdPlan;
+      }
+
+      return null;
+    } catch (e) {
+      catchError(e as Error);
+      return null;
+    }
+  },
+
   async initialSimulationUpdate(
     plan_id: number,
     simulation_template_id: number | null = null,
diff --git a/src/utilities/permissions.ts b/src/utilities/permissions.ts
index df944a6ed5..b29b28725b 100644
--- a/src/utilities/permissions.ts
+++ b/src/utilities/permissions.ts
@@ -1050,6 +1050,26 @@ const queryPermissions = {
   VALIDATE_ACTIVITY_ARGUMENTS: () => true,
 };
 
+const gatewayPermissions = {
+  IMPORT_PLAN: (user: User | null) => {
+    return (
+      isUserAdmin(user) ||
+      getPermission(
+        [
+          Queries.INSERT_PLAN,
+          Queries.INSERT_PLAN_TAGS,
+          Queries.INSERT_ACTIVITY_DIRECTIVE,
+          Queries.UPDATE_ACTIVITY_DIRECTIVE,
+          Queries.UPDATE_SIMULATIONS,
+          Queries.TAGS,
+          Queries.DELETE_PLAN,
+        ],
+        user,
+      )
+    );
+  },
+};
+
 type ShapeOf<T> = Record<keyof T, any>;
 type AssertKeysEqual<X extends ShapeOf<Y>, Y extends ShapeOf<X>> = never;
 type GQLKeys = Record<keyof typeof gql, any>;
@@ -1096,6 +1116,10 @@ interface CRUDPermission<T = null> extends BaseCRUDPermission<T> {
   canUpdate: UpdatePermissionCheck<T>;
 }
 
+interface PlanCRUDPermission extends CRUDPermission<PlanWithOwners> {
+  canImport: CreatePermissionCheck;
+}
+
 interface PlanBranchCRUDPermission {
   canCreateBranch: RolePlanPermissionCheck;
   canCreateRequest: RolePlanBranchPermissionCheck;
@@ -1185,7 +1209,7 @@ interface FeaturePermissions {
   model: CRUDPermission<void>;
   parameterDictionary: CRUDPermission<void>;
   parcels: CRUDPermission<AssetWithOwner<Parcel>>;
-  plan: CRUDPermission<PlanWithOwners>;
+  plan: PlanCRUDPermission;
   planBranch: PlanBranchCRUDPermission;
   planCollaborators: PlanCollaboratorsCRUDPermission;
   planSnapshot: PlanSnapshotCRUDPermission;
@@ -1285,6 +1309,7 @@ const featurePermissions: FeaturePermissions = {
   plan: {
     canCreate: user => queryPermissions.CREATE_PLAN(user),
     canDelete: (user, plan) => queryPermissions.DELETE_PLAN(user, plan),
+    canImport: user => gatewayPermissions.IMPORT_PLAN(user),
     canRead: user => queryPermissions.GET_PLAN(user),
     canUpdate: (user, plan) => queryPermissions.UPDATE_PLAN(user, plan),
   },
@@ -1395,6 +1420,7 @@ function hasNoAuthorization(user: User | null) {
 export {
   changeUserRole,
   featurePermissions,
+  gatewayPermissions,
   hasNoAuthorization,
   isAdminRole,
   isPlanCollaborator,
diff --git a/src/utilities/plan.test.ts b/src/utilities/plan.test.ts
index 08292a108d..328b188576 100644
--- a/src/utilities/plan.test.ts
+++ b/src/utilities/plan.test.ts
@@ -85,10 +85,23 @@ describe('Plan utility', () => {
               source_scheduling_goal_id: null,
               start_offset: '0:00:00',
               start_time_ms: 0,
-              tags: [],
+              tags: [
+                {
+                  tag: {
+                    color: '#ff0000',
+                    created_at: '',
+                    id: 1,
+                    name: 'test tag',
+                    owner: 'test',
+                  },
+                },
+              ],
               type: 'TestActivity',
             },
           ],
+          {
+            test: 1,
+          },
         ),
       ).toEqual({
         activities: [
@@ -102,19 +115,29 @@ describe('Plan utility', () => {
             metadata: {},
             name: 'Test Activity',
             start_offset: '0:00:00',
+            tags: [
+              {
+                tag: {
+                  color: '#ff0000',
+                  name: 'test tag',
+                },
+              },
+            ],
             type: 'TestActivity',
           },
         ],
-        end_time: '2025-01-01T00:00:00+00:00',
+        duration: '1y',
         id: 1,
         model_id: 1,
         name: 'Foo plan',
-        sim_id: 3,
+        simulation_arguments: {
+          test: 1,
+        },
         start_time: '2024-01-01T00:00:00+00:00',
         tags: [
           {
             tag: {
-              id: 0,
+              color: '#fff',
               name: 'test tag',
             },
           },
diff --git a/src/utilities/plan.ts b/src/utilities/plan.ts
index 940d30af2b..8535c0801e 100644
--- a/src/utilities/plan.ts
+++ b/src/utilities/plan.ts
@@ -1,11 +1,16 @@
 import type { ActivityDirective } from '../types/activity';
-import type { Plan, PlanTransfer } from '../types/plan';
+import type { ArgumentsMap } from '../types/parameter';
+import type { DeprecatedPlanTransfer, Plan, PlanTransfer } from '../types/plan';
 import { convertDoyToYmd } from './time';
 
-export function getPlanForTransfer(plan: Plan, activities: ActivityDirective[]): PlanTransfer {
+export function getPlanForTransfer(
+  plan: Plan,
+  activities: ActivityDirective[],
+  simulationArguments: ArgumentsMap,
+): PlanTransfer {
   return {
     activities: activities.map(
-      ({ anchor_id, anchored_to_start, arguments: activityArguments, id, metadata, name, start_offset, type }) => ({
+      ({
         anchor_id,
         anchored_to_start,
         arguments: activityArguments,
@@ -13,15 +18,32 @@ export function getPlanForTransfer(plan: Plan, activities: ActivityDirective[]):
         metadata,
         name,
         start_offset,
+        tags,
+        type,
+      }) => ({
+        anchor_id,
+        anchored_to_start,
+        arguments: activityArguments,
+        id,
+        metadata,
+        name,
+        start_offset,
+        tags: tags.map(({ tag: { color, name } }) => ({ tag: { color, name } })),
         type,
       }),
     ),
-    end_time: (convertDoyToYmd(plan.end_time_doy) as string).replace('Z', '+00:00'),
+    duration: plan.duration,
     id: plan.id,
     model_id: plan.model_id,
     name: plan.name,
-    sim_id: plan.simulations[0].id,
+    simulation_arguments: simulationArguments,
     start_time: (convertDoyToYmd(plan.start_time_doy) as string).replace('Z', '+00:00'),
-    tags: plan.tags.map(({ tag: { id, name } }) => ({ tag: { id, name } })),
+    tags: plan.tags.map(({ tag: { color, name } }) => ({ tag: { color, name } })),
   };
 }
+
+export function isDeprecatedPlanTransfer(
+  planTransfer: PlanTransfer | DeprecatedPlanTransfer,
+): planTransfer is DeprecatedPlanTransfer {
+  return (planTransfer as DeprecatedPlanTransfer).end_time != null;
+}
diff --git a/src/utilities/requests.ts b/src/utilities/requests.ts
index 9d355fec2b..c416432538 100644
--- a/src/utilities/requests.ts
+++ b/src/utilities/requests.ts
@@ -61,6 +61,8 @@ export async function reqGateway<T = any>(
   const headers: HeadersInit = {
     Authorization: `Bearer ${user?.token ?? ''}`,
     ...(excludeContentType ? {} : { 'Content-Type': 'application/json' }),
+    'x-hasura-role': (user as User)?.activeRole ?? '',
+    'x-hasura-user-id': user?.id ?? '',
   };
   const options: RequestInit = {
     headers,
diff --git a/src/utilities/time.test.ts b/src/utilities/time.test.ts
index 42344c30f9..70e0c45bc5 100644
--- a/src/utilities/time.test.ts
+++ b/src/utilities/time.test.ts
@@ -202,6 +202,7 @@ test('convertDoyToYmd', () => {
   expect(convertDoyToYmd('2023-001T00:00:00', false)).toEqual('2023-01-01T00:00:00Z');
   expect(convertDoyToYmd('2023-032T00:00:00', false)).toEqual('2023-02-01T00:00:00Z');
   expect(convertDoyToYmd('2023-048T10:32:44.123', true)).toEqual('2023-02-17T10:32:44.123Z');
+  expect(convertDoyToYmd('2023-04-10T10:32:44.123', true)).toEqual('2023-04-10T10:32:44.123Z');
 });
 
 test('getDaysInMonth', () => {
@@ -425,6 +426,17 @@ test('parseDurationString', () => {
     seconds: 0.01,
     years: 0,
   });
+
+  expect(parseDurationString('24:00:00')).toEqual({
+    days: 0,
+    hours: 24,
+    isNegative: false,
+    microseconds: 0,
+    milliseconds: 0,
+    minutes: 0,
+    seconds: 0,
+    years: 0,
+  });
 });
 
 test('isTimeBalanced', () => {
diff --git a/src/utilities/time.ts b/src/utilities/time.ts
index d40b073224..2d1c3ab2d9 100644
--- a/src/utilities/time.ts
+++ b/src/utilities/time.ts
@@ -383,7 +383,7 @@ export function convertDoyToYmd(doyString: string, includeMsecs = true): string
       return `${ymdString.replace(/(\.\d+)/, '')}Z`;
     } else {
       // doyString is already in ymd format
-      return doyString;
+      return `${doyString}Z`;
     }
   }