diff --git a/web/apps/photos/src/components/UploadProgress.tsx b/web/apps/photos/src/components/UploadProgress.tsx
index 94bc2e46e3..fa8b2232e3 100644
--- a/web/apps/photos/src/components/UploadProgress.tsx
+++ b/web/apps/photos/src/components/UploadProgress.tsx
@@ -1,6 +1,6 @@
 import { FilledIconButton } from "@/base/components/mui";
 import { useBaseContext } from "@/base/context";
-import { UPLOAD_RESULT, type UploadPhase } from "@/gallery/services/upload";
+import { type UploadPhase, type UploadResult } from "@/gallery/services/upload";
 import { SpaceBetweenFlex } from "@ente/shared/components/Container";
 import CloseIcon from "@mui/icons-material/Close";
 import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
@@ -265,13 +265,12 @@ function UploadProgressDialog() {
 
     useEffect(() => {
         if (
-            finishedUploads.get(UPLOAD_RESULT.ALREADY_UPLOADED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.BLOCKED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.FAILED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE)
-                ?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.TOO_LARGE)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.UNSUPPORTED)?.length > 0
+            finishedUploads.get("alreadyUploaded")?.length > 0 ||
+            finishedUploads.get("blocked")?.length > 0 ||
+            finishedUploads.get("failed")?.length > 0 ||
+            finishedUploads.get("largerThanAvailableStorage")?.length > 0 ||
+            finishedUploads.get("tooLarge")?.length > 0 ||
+            finishedUploads.get("unsupported")?.length > 0
         ) {
             setHasUnUploadedFiles(true);
         } else {
@@ -290,13 +289,11 @@ function UploadProgressDialog() {
                 <DialogContent sx={{ "&&&": { px: 0 } }}>
                     {uploadPhase === "uploading" && <InProgressSection />}
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.UPLOADED}
+                        uploadResult="uploaded"
                         sectionTitle={t("SUCCESSFUL_UPLOADS")}
                     />
                     <ResultSection
-                        uploadResult={
-                            UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL
-                        }
+                        uploadResult="uploadedWithStaticThumbnail"
                         sectionTitle={t("THUMBNAIL_GENERATION_FAILED_UPLOADS")}
                         sectionInfo={t("THUMBNAIL_GENERATION_FAILED_INFO")}
                     />
@@ -306,12 +303,12 @@ function UploadProgressDialog() {
                         </NotUploadSectionHeader>
                     )}
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.BLOCKED}
+                        uploadResult="blocked"
                         sectionTitle={t("BLOCKED_UPLOADS")}
                         sectionInfo={<Trans i18nKey={"ETAGS_BLOCKED"} />}
                     />
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.FAILED}
+                        uploadResult="failed"
                         sectionTitle={t("FAILED_UPLOADS")}
                         sectionInfo={
                             uploadPhase == "done"
@@ -320,26 +317,24 @@ function UploadProgressDialog() {
                         }
                     />
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.ALREADY_UPLOADED}
+                        uploadResult="alreadyUploaded"
                         sectionTitle={t("SKIPPED_FILES")}
                         sectionInfo={t("SKIPPED_INFO")}
                     />
                     <ResultSection
-                        uploadResult={
-                            UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE
-                        }
+                        uploadResult="largerThanAvailableStorage"
                         sectionTitle={t(
                             "LARGER_THAN_AVAILABLE_STORAGE_UPLOADS",
                         )}
                         sectionInfo={t("LARGER_THAN_AVAILABLE_STORAGE_INFO")}
                     />
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.UNSUPPORTED}
+                        uploadResult="unsupported"
                         sectionTitle={t("UNSUPPORTED_FILES")}
                         sectionInfo={t("UNSUPPORTED_INFO")}
                     />
                     <ResultSection
-                        uploadResult={UPLOAD_RESULT.TOO_LARGE}
+                        uploadResult="tooLarge"
                         sectionTitle={t("TOO_LARGE_UPLOADS")}
                         sectionInfo={t("TOO_LARGE_INFO")}
                     />
@@ -457,7 +452,7 @@ const NotUploadSectionHeader = styled("div")(
 );
 
 interface ResultSectionProps {
-    uploadResult: UPLOAD_RESULT;
+    uploadResult: UploadResult;
     sectionTitle: string;
     sectionInfo?: React.ReactNode;
 }
@@ -552,8 +547,8 @@ const DoneFooter: React.FC = () => {
     return (
         <DialogActions>
             {uploadPhase == "done" &&
-                (finishedUploads?.get(UPLOAD_RESULT.FAILED)?.length > 0 ||
-                finishedUploads?.get(UPLOAD_RESULT.BLOCKED)?.length > 0 ? (
+                (finishedUploads?.get("failed")?.length > 0 ||
+                finishedUploads?.get("blocked")?.length > 0 ? (
                     <Button fullWidth onClick={retryFailed}>
                         {t("RETRY_FAILED")}
                     </Button>
diff --git a/web/apps/photos/src/services/upload/upload-service.ts b/web/apps/photos/src/services/upload/upload-service.ts
index 35e59e445d..149eda3228 100644
--- a/web/apps/photos/src/services/upload/upload-service.ts
+++ b/web/apps/photos/src/services/upload/upload-service.ts
@@ -14,7 +14,7 @@ import {
 import type { UploadItem } from "@/gallery/services/upload";
 import {
     RANDOM_PERCENTAGE_PROGRESS_FOR_PUT,
-    UPLOAD_RESULT,
+    type UploadResult,
 } from "@/gallery/services/upload";
 import {
     detectFileTypeInfoFromChunk,
@@ -528,7 +528,7 @@ type MakeProgressTracker = (
 ) => unknown;
 
 interface UploadResponse {
-    uploadResult: UPLOAD_RESULT;
+    uploadResult: UploadResult;
     uploadedFile?: EncryptedEnteFile | EnteFile;
 }
 
@@ -574,7 +574,7 @@ export const uploader = async (
         } catch (e) {
             if (isFileTypeNotSupportedError(e)) {
                 log.error(`Not uploading ${fileName}`, e);
-                return { uploadResult: UPLOAD_RESULT.UNSUPPORTED };
+                return { uploadResult: "unsupported" };
             }
             throw e;
         }
@@ -582,8 +582,7 @@ export const uploader = async (
         const { fileTypeInfo, fileSize, lastModifiedMs } = assetDetails;
 
         const maxFileSize = 4 * 1024 * 1024 * 1024; /* 4 GB */
-        if (fileSize >= maxFileSize)
-            return { uploadResult: UPLOAD_RESULT.TOO_LARGE };
+        if (fileSize >= maxFileSize) return { uploadResult: "tooLarge" };
 
         abortIfCancelled();
 
@@ -608,7 +607,7 @@ export const uploader = async (
             );
             if (matchInSameCollection) {
                 return {
-                    uploadResult: UPLOAD_RESULT.ALREADY_UPLOADED,
+                    uploadResult: "alreadyUploaded",
                     uploadedFile: matchInSameCollection,
                 };
             } else {
@@ -616,10 +615,7 @@ export const uploader = async (
                 const symlink = Object.assign({}, anyMatch);
                 symlink.collectionID = collection.id;
                 await addToCollection(collection, [symlink]);
-                return {
-                    uploadResult: UPLOAD_RESULT.ADDED_SYMLINK,
-                    uploadedFile: symlink,
-                };
+                return { uploadResult: "addedSymlink", uploadedFile: symlink };
             }
         }
 
@@ -669,8 +665,8 @@ export const uploader = async (
 
         return {
             uploadResult: metadata.hasStaticThumbnail
-                ? UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL
-                : UPLOAD_RESULT.UPLOADED,
+                ? "uploadedWithStaticThumbnail"
+                : "uploaded",
             uploadedFile: uploadedFile,
         };
     } catch (e) {
@@ -683,13 +679,11 @@ export const uploader = async (
         const error = handleUploadError(e);
         switch (error.message) {
             case CustomError.ETAG_MISSING:
-                return { uploadResult: UPLOAD_RESULT.BLOCKED };
+                return { uploadResult: "blocked" };
             case CustomError.FILE_TOO_LARGE:
-                return {
-                    uploadResult: UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE,
-                };
+                return { uploadResult: "largerThanAvailableStorage" };
             default:
-                return { uploadResult: UPLOAD_RESULT.FAILED };
+                return { uploadResult: "failed" };
         }
     }
 };
diff --git a/web/apps/photos/src/services/upload/uploadManager.ts b/web/apps/photos/src/services/upload/uploadManager.ts
index 5674144d91..bb72f6d873 100644
--- a/web/apps/photos/src/services/upload/uploadManager.ts
+++ b/web/apps/photos/src/services/upload/uploadManager.ts
@@ -9,9 +9,9 @@ import { ComlinkWorker } from "@/base/worker/comlink-worker";
 import type { UploadItem } from "@/gallery/services/upload";
 import {
     RANDOM_PERCENTAGE_PROGRESS_FOR_PUT,
-    UPLOAD_RESULT,
     shouldDisableCFUploadProxy,
     type UploadPhase,
+    type UploadResult,
 } from "@/gallery/services/upload";
 import type { Collection } from "@/media/collection";
 import {
@@ -64,14 +64,14 @@ export interface InProgressUpload {
 
 export interface FinishedUpload {
     localFileID: FileID;
-    result: UPLOAD_RESULT;
+    result: UploadResult;
 }
 
 export type InProgressUploads = Map<FileID, PercentageUploaded>;
 
-export type FinishedUploads = Map<FileID, UPLOAD_RESULT>;
+export type FinishedUploads = Map<FileID, UploadResult>;
 
-export type SegregatedFinishedUploads = Map<UPLOAD_RESULT, FileID[]>;
+export type SegregatedFinishedUploads = Map<UploadResult, FileID[]>;
 
 export interface ProgressUpdater {
     setPercentComplete: React.Dispatch<React.SetStateAction<number>>;
@@ -161,7 +161,7 @@ class UIService {
         this.setTotalFileCount(count);
         this.filesUploadedCount = 0;
         this.inProgressUploads = new Map<number, number>();
-        this.finishedUploads = new Map<number, UPLOAD_RESULT>();
+        this.finishedUploads = new Map<number, UploadResult>();
         this.updateProgressBarUI();
     }
 
@@ -205,7 +205,7 @@ class UIService {
         this.updateProgressBarUI();
     }
 
-    moveFileToResultList(key: number, uploadResult: UPLOAD_RESULT) {
+    moveFileToResultList(key: number, uploadResult: UploadResult) {
         this.finishedUploads.set(key, uploadResult);
         this.inProgressUploads.delete(key);
         this.updateProgressBarUI();
@@ -595,39 +595,36 @@ class UploadManager {
 
     private async postUploadTask(
         uploadableItem: UploadableUploadItem,
-        uploadResult: UPLOAD_RESULT,
+        uploadResult: UploadResult,
         uploadedFile: EncryptedEnteFile | EnteFile | undefined,
     ) {
-        const key = UPLOAD_RESULT[uploadResult];
-        log.info(
-            `Uploaded ${uploadableItem.fileName} with result ${uploadResult} (${key})`,
-        );
+        log.info(`Uploaded ${uploadableItem.fileName} (${uploadResult})`);
         try {
             const electron = globalThis.electron;
             if (electron) await markUploaded(electron, uploadableItem);
 
             let decryptedFile: EnteFile;
             switch (uploadResult) {
-                case UPLOAD_RESULT.FAILED:
-                case UPLOAD_RESULT.BLOCKED:
+                case "failed":
+                case "blocked":
                     this.failedItems.push(uploadableItem);
                     break;
-                case UPLOAD_RESULT.ALREADY_UPLOADED:
+                case "alreadyUploaded":
                     decryptedFile = uploadedFile as EnteFile;
                     break;
-                case UPLOAD_RESULT.ADDED_SYMLINK:
+                case "addedSymlink":
                     decryptedFile = uploadedFile as EnteFile;
-                    uploadResult = UPLOAD_RESULT.UPLOADED;
+                    uploadResult = "uploaded";
                     break;
-                case UPLOAD_RESULT.UPLOADED:
-                case UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL:
+                case "uploaded":
+                case "uploadedWithStaticThumbnail":
                     decryptedFile = await decryptFile(
                         uploadedFile as EncryptedEnteFile,
                         uploadableItem.collection.key,
                     );
                     break;
-                case UPLOAD_RESULT.UNSUPPORTED:
-                case UPLOAD_RESULT.TOO_LARGE:
+                case "unsupported":
+                case "tooLarge":
                     // no-op
                     break;
                 default:
@@ -635,9 +632,9 @@ class UploadManager {
             }
             if (
                 [
-                    UPLOAD_RESULT.ADDED_SYMLINK,
-                    UPLOAD_RESULT.UPLOADED,
-                    UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL,
+                    "addedSymlink",
+                    "uploaded",
+                    "uploadedWithStaticThumbnail",
                 ].includes(uploadResult)
             ) {
                 const uploadItem =
@@ -645,9 +642,8 @@ class UploadManager {
                     uploadableItem.livePhotoAssets.image;
                 if (
                     uploadItem &&
-                    (uploadResult == UPLOAD_RESULT.UPLOADED ||
-                        uploadResult ==
-                            UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL)
+                    (uploadResult == "uploaded" ||
+                        uploadResult == "uploadedWithStaticThumbnail")
                 ) {
                     indexNewUpload(decryptedFile, uploadItem);
                 }
@@ -661,12 +657,12 @@ class UploadManager {
             return uploadResult;
         } catch (e) {
             log.error("failed to do post file upload action", e);
-            return UPLOAD_RESULT.FAILED;
+            return "failed";
         }
     }
 
     private async watchFolderCallback(
-        fileUploadResult: UPLOAD_RESULT,
+        fileUploadResult: UploadResult,
         fileWithCollection: ClusteredUploadItem,
         uploadedFile: EncryptedEnteFile,
     ) {
diff --git a/web/apps/photos/src/services/watch.ts b/web/apps/photos/src/services/watch.ts
index 0430d0a644..f0720247e4 100644
--- a/web/apps/photos/src/services/watch.ts
+++ b/web/apps/photos/src/services/watch.ts
@@ -11,7 +11,7 @@ import type {
     FolderWatch,
     FolderWatchSyncedFile,
 } from "@/base/types/ipc";
-import { UPLOAD_RESULT } from "@/gallery/services/upload";
+import { type UploadResult } from "@/gallery/services/upload";
 import type { Collection } from "@/media/collection";
 import { EncryptedEnteFile } from "@/media/file";
 import {
@@ -324,7 +324,7 @@ class FolderWatcher {
      * {@link upload} gets uploaded.
      */
     async onFileUpload(
-        fileUploadResult: UPLOAD_RESULT,
+        fileUploadResult: UploadResult,
         item: UploadItemWithCollection,
         file: EncryptedEnteFile,
     ) {
@@ -333,10 +333,10 @@ class FolderWatcher {
         // file on disk).
         if (
             [
-                UPLOAD_RESULT.ADDED_SYMLINK,
-                UPLOAD_RESULT.UPLOADED,
-                UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL,
-                UPLOAD_RESULT.ALREADY_UPLOADED,
+                "addedSymlink",
+                "uploaded",
+                "uploadedWithStaticThumbnail",
+                "alreadyUploaded",
             ].includes(fileUploadResult)
         ) {
             if (item.isLivePhoto) {
@@ -354,11 +354,7 @@ class FolderWatcher {
                     file,
                 );
             }
-        } else if (
-            [UPLOAD_RESULT.UNSUPPORTED, UPLOAD_RESULT.TOO_LARGE].includes(
-                fileUploadResult,
-            )
-        ) {
+        } else if (["unsupported", "tooLarge"].includes(fileUploadResult)) {
             if (item.isLivePhoto) {
                 this.unUploadableFilePaths.add(
                     ensureString(item.livePhotoAssets.image),
diff --git a/web/packages/gallery/services/upload.ts b/web/packages/gallery/services/upload.ts
index e6b1040d73..36e5096814 100644
--- a/web/packages/gallery/services/upload.ts
+++ b/web/packages/gallery/services/upload.ts
@@ -94,17 +94,16 @@ export type UploadPhase =
     | "cancelling"
     | "done";
 
-export enum UPLOAD_RESULT {
-    FAILED,
-    ALREADY_UPLOADED,
-    UNSUPPORTED,
-    BLOCKED,
-    TOO_LARGE,
-    LARGER_THAN_AVAILABLE_STORAGE,
-    UPLOADED,
-    UPLOADED_WITH_STATIC_THUMBNAIL,
-    ADDED_SYMLINK,
-}
+export type UploadResult =
+    | "failed"
+    | "alreadyUploaded"
+    | "unsupported"
+    | "blocked"
+    | "tooLarge"
+    | "largerThanAvailableStorage"
+    | "uploaded"
+    | "uploadedWithStaticThumbnail"
+    | "addedSymlink";
 
 /**
  * Return true to disable the upload of files via Cloudflare Workers.