diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index a61861be3eaf..b3ed1d67b287 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -4609,6 +4609,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/tools/fetch/workbook": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Generate a template workbook to use with the activity builder UI */
+        get: operations["tools__fetch_workbook_download"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tools/fetch/workbook/parse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Generate a template workbook to use with the activity builder UI */
+        post: operations["tools__fetch_workbook_parse"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/tools/{tool_id}/icon": {
         parameters: {
             query?: never;
@@ -16872,6 +16906,88 @@ export interface components {
          * @default []
          */
         PageSummaryList: components["schemas"]["PageSummary"][];
+        /** ParseFetchWorkbook */
+        ParseFetchWorkbook: {
+            /**
+             * Workbook Content (Base 64 encoded)
+             * @description The workbook content (the contents of the xlsx file) that have been base64 encoded.
+             */
+            content: string;
+        };
+        /** ParseLogEntry */
+        ParseLogEntry: {
+            /** Message */
+            message: string;
+        };
+        /** ParsedColumn */
+        ParsedColumn: {
+            /** Title */
+            title: string;
+            /**
+             * Type
+             * @enum {string}
+             */
+            type:
+                | "list_identifiers"
+                | "paired_identifier"
+                | "paired_or_unpaired_identifier"
+                | "collection_name"
+                | "name_tag"
+                | "tags"
+                | "group_tags"
+                | "name"
+                | "dbkey"
+                | "hash_sha1"
+                | "hash_md5"
+                | "hash_sha256"
+                | "hash_sha512"
+                | "file_type"
+                | "url"
+                | "url_deferred"
+                | "info"
+                | "ftp_path";
+            /** Type Index */
+            type_index: number;
+        };
+        /** ParsedFetchWorkbookForCollections */
+        ParsedFetchWorkbookForCollections: {
+            /**
+             * Collection Type
+             * @enum {string}
+             */
+            collection_type: "list" | "list:paired" | "list:list" | "list:list:paired" | "list:paired_or_unpaired";
+            /** Columns */
+            columns: components["schemas"]["ParsedColumn"][];
+            /** Parse Log */
+            parse_log: components["schemas"]["ParseLogEntry"][];
+            /** Rows */
+            rows: {
+                [key: string]: string;
+            }[];
+            /**
+             * Workbook Type
+             * @default collection
+             * @enum {string}
+             */
+            workbook_type: "datasets" | "collection" | "collections";
+        };
+        /** ParsedFetchWorkbookForDatasets */
+        ParsedFetchWorkbookForDatasets: {
+            /** Columns */
+            columns: components["schemas"]["ParsedColumn"][];
+            /** Parse Log */
+            parse_log: components["schemas"]["ParseLogEntry"][];
+            /** Rows */
+            rows: {
+                [key: string]: string;
+            }[];
+            /**
+             * Workbook Type
+             * @default datasets
+             * @enum {string}
+             */
+            workbook_type: "datasets" | "collection" | "collections";
+        };
         /** PastedDataElement */
         PastedDataElement: {
             /** Md5 */
@@ -36370,6 +36486,99 @@ export interface operations {
             };
         };
     };
+    tools__fetch_workbook_download: {
+        parameters: {
+            query?: {
+                /** @description Generate a workbook for simple datasets or a collection. */
+                type?: "datasets" | "collection" | "collections";
+                /** @description Generate workbook for specified collection type (not all collection types are supported) */
+                collection_type?: "list" | "list:paired" | "list:list" | "list:list:paired" | "list:paired_or_unpaired";
+                /** @description Filename of the workbook download to generate */
+                filename?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    tools__fetch_workbook_parse: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ParseFetchWorkbook"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json":
+                        | components["schemas"]["ParsedFetchWorkbookForDatasets"]
+                        | components["schemas"]["ParsedFetchWorkbookForCollections"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     get_icon_api_tools__tool_id__icon_get: {
         parameters: {
             query?: never;
diff --git a/client/src/components/Collections/BuildFileSetWizard.vue b/client/src/components/Collections/BuildFileSetWizard.vue
index eab888d1e4bb..0871935695ab 100644
--- a/client/src/components/Collections/BuildFileSetWizard.vue
+++ b/client/src/components/Collections/BuildFileSetWizard.vue
@@ -2,24 +2,39 @@
 import { BCardGroup } from "bootstrap-vue";
 import { computed, ref } from "vue";
 
+import { GalaxyApi } from "@/api";
 import { getGalaxyInstance } from "@/app";
 import { attemptCreate, type CollectionCreatorComponent } from "@/components/Collections/common/useCollectionCreator";
+import { useWorkbookDropHandling } from "@/components/Collections/common/useWorkbooks";
 import { rawToTable } from "@/components/Collections/tables";
+import { forBuilder, type ForBuilderResponse } from "@/components/Collections/wizard/fetchWorkbooks";
 import { useWizard } from "@/components/Common/Wizard/useWizard";
 import { useToolRouting } from "@/composables/route";
 import localize from "@/utils/localization";
 
-import type { RemoteFile, RulesCreatingWhat, RulesSourceFrom } from "./wizard/types";
+import type {
+    ParsedFetchWorkbook,
+    ParsedFetchWorkbookForCollectionCollectionType,
+    RuleBuilderMapping,
+    RuleBuilderOptions,
+    RuleElementsType,
+    RulesCreatingWhat,
+    RuleSelectionType,
+    RulesSourceFrom,
+} from "./wizard/types";
 import { useFileSetSources } from "./wizard/useFileSetSources";
 
+import ConfigureFetchWorkbook from "./wizard/ConfigureFetchWorkbook.vue";
 import CreatingWhat from "./wizard/CreatingWhat.vue";
 import PasteData from "./wizard/PasteData.vue";
 import SelectDataset from "./wizard/SelectDataset.vue";
 import SelectFolder from "./wizard/SelectFolder.vue";
-import SourceFromCollection from "./wizard/SourceFromCollection.vue";
+import SourceFromCollectionApplyRules from "./wizard/SourceFromCollectionApplyRules.vue";
 import SourceFromDatasetAsTable from "./wizard/SourceFromDatasetAsTable.vue";
 import SourceFromPastedData from "./wizard/SourceFromPastedData.vue";
 import SourceFromRemoteFiles from "./wizard/SourceFromRemoteFiles.vue";
+import SourceFromWorkbook from "./wizard/SourceFromWorkbook.vue";
+import UploadFetchWorkbook from "./wizard/UploadFetchWorkbook.vue";
 import GenericWizard from "@/components/Common/Wizard/GenericWizard.vue";
 import RuleCollectionBuilder from "@/components/RuleCollectionBuilder.vue";
 
@@ -45,8 +60,14 @@ const sourceInstructions = computed(() => {
     return `${creatingWhatTitle.value} can be created from a set or files, URIs, or existing datasets.`;
 });
 const collectionCreator = ref<CollectionCreatorComponent | undefined>();
+const workbookCompleted = ref<boolean>(false);
+// workbook generation options
+const workbookCollectionType = ref<ParsedFetchWorkbookForCollectionCollectionType>("list");
+const workbookIncludeCollectionName = ref<boolean>(false);
 
 const sourceFrom = ref<RulesSourceFrom>("remote_files");
+// if we upload a workbook - just jump to the end with these properties
+const parsedWorkbookUploadProps = ref<ForBuilderResponse | undefined>(undefined);
 
 const { routeToTool } = useToolRouting();
 
@@ -83,6 +104,18 @@ const wizard = useWizard({
         isValid: () => sourceFrom.value === "dataset_as_table" && tabularDatasetContents.value.length > 0,
         isSkippable: () => sourceFrom.value !== "dataset_as_table",
     },
+    "configure-workbook": {
+        label: "Configure workbook",
+        instructions: "Configure a workbook to fill with URIs and metadata",
+        isValid: () => sourceFrom.value === "workbook" && workbookCollectionType.value !== undefined,
+        isSkippable: () => sourceFrom.value !== "workbook" || creatingWhat.value !== "collections",
+    },
+    "upload-workbook": {
+        label: "Upload workbook",
+        instructions: "Upload a workbook containing with URIs and metadata",
+        isValid: () => sourceFrom.value === "workbook" && workbookCompleted.value,
+        isSkippable: () => sourceFrom.value !== "workbook",
+    },
     "rule-builder": {
         label: "Specify Rules",
         instructions: "Use this form to describe rules for importing",
@@ -101,25 +134,15 @@ const importButtonLabel = computed(() => {
 });
 
 const emit = defineEmits(["dismiss", "created"]);
-type SelectionType = "raw" | "remote_files";
-type ElementsType = RemoteFile[] | string[][];
-
-// it would be nice to have a real type from the rule builder but
-// it is older code. This is really outlining what this component can
-// produce and not what the rule builder can consume which is a wide
-// superset of this.
-interface Entry {
-    dataType: RulesCreatingWhat;
-    ftpUploadSite?: string;
-    elements?: ElementsType | undefined;
-    content?: string;
-    selectionType: SelectionType;
-}
 
 const ruleBuilderModalEntryProps = computed(() => {
-    let elements: ElementsType | undefined = undefined;
-    let selectionType: SelectionType = "raw";
-    if (sourceFrom.value == "remote_files") {
+    let elements: RuleElementsType | undefined = undefined;
+    let initialMappings: RuleBuilderMapping | undefined = undefined;
+    let selectionType: RuleSelectionType = "raw";
+    if (parsedWorkbookUploadProps.value) {
+        elements = parsedWorkbookUploadProps.value.initialElements;
+        initialMappings = parsedWorkbookUploadProps.value.initialMapping;
+    } else if (sourceFrom.value == "remote_files") {
         elements = uris.value;
         selectionType = "remote_files";
     } else if (sourceFrom.value == "pasted_table") {
@@ -127,11 +150,12 @@ const ruleBuilderModalEntryProps = computed(() => {
     } else if (sourceFrom.value == "dataset_as_table") {
         elements = tabularDatasetContents.value;
     }
-    const entry: Entry = {
+    const entry: RuleBuilderOptions = {
         dataType: creatingWhat.value,
         ftpUploadSite: props.ftpUploadSite,
         selectionType: selectionType,
         elements: elements,
+        initialMappings: initialMappings,
     };
     return entry;
 });
@@ -172,6 +196,14 @@ function setSourceForm(newValue: RulesSourceFrom) {
     sourceFrom.value = newValue;
 }
 
+function setWorkbookCollectionType(newValue: ParsedFetchWorkbookForCollectionCollectionType) {
+    workbookCollectionType.value = newValue;
+}
+
+function setWorkbookIncludeCollectionName(newValue: boolean) {
+    workbookIncludeCollectionName.value = newValue;
+}
+
 function onRuleState(newRuleState: boolean) {
     ruleState.value = newRuleState;
 }
@@ -180,10 +212,68 @@ function onRuleCreate() {
     // axios response data for job currently sent, not really used but wanted to document what is available.
     emit("created");
 }
+
+const dropWorkbookTitle = computed(() => {
+    return localize(
+        "If you have a completed data import workbook just drop it here or click this icon to upload your local file and skip ahead to the end of the data import wizard."
+    );
+});
+
+function handleUploadedData(response: ParsedFetchWorkbook) {
+    sourceFrom.value = "workbook";
+    const builderPropsFromUpload = forBuilder(response);
+    creatingWhat.value = builderPropsFromUpload.rulesCreatingWhat;
+    parsedWorkbookUploadProps.value = builderPropsFromUpload;
+    workbookCompleted.value = true;
+    wizard.goTo("rule-builder");
+}
+
+async function handleWorkbook(base64Content: string) {
+    const parseBody = {
+        content: base64Content,
+    };
+    const { data, error } = await GalaxyApi().POST("/api/tools/fetch/workbook/parse", {
+        body: parseBody,
+    });
+    if (data) {
+        handleUploadedData(data);
+    } else {
+        console.log(error);
+        uploadErrorMessage.value = "There was an error processing the file.";
+    }
+}
+
+const {
+    browseFiles,
+    dropZoneClasses,
+    faUpload,
+    FontAwesomeIcon,
+    handleDrop,
+    HiddenWorkbookUploadInput,
+    isDragging,
+    onFileUpload,
+    uploadErrorMessage,
+    uploadRef,
+} = useWorkbookDropHandling(handleWorkbook);
 </script>
 
 <template>
     <GenericWizard :use="wizard" :submit-button-label="importButtonLabel" :title="title" @submit="submit">
+        <template v-slot:header>
+            <h2 data-galaxy-file-drop-target>
+                {{ title }}
+                <FontAwesomeIcon
+                    class="workbook-upload-helper mr-1"
+                    :class="dropZoneClasses"
+                    :title="dropWorkbookTitle"
+                    :icon="faUpload"
+                    @click.prevent="browseFiles"
+                    @drop.prevent="handleDrop"
+                    @dragover.prevent="isDragging = true"
+                    @dragleave.prevent="isDragging = false" />
+                <HiddenWorkbookUploadInput ref="uploadRef" @onFileUpload="onFileUpload" />
+            </h2>
+        </template>
         <div v-if="wizard.isCurrent('select-what')">
             <CreatingWhat :creating-what="creatingWhat" @onChange="setCreatingWhat" />
         </div>
@@ -192,7 +282,11 @@ function onRuleCreate() {
                 <SourceFromRemoteFiles :selected="sourceFrom === 'remote_files'" @select="setSourceForm" />
                 <SourceFromPastedData :selected="sourceFrom === 'pasted_table'" @select="setSourceForm" />
                 <SourceFromDatasetAsTable :selected="sourceFrom === 'dataset_as_table'" @select="setSourceForm" />
-                <SourceFromCollection
+                <SourceFromWorkbook
+                    :creating-what="creatingWhat"
+                    :selected="sourceFrom === 'workbook'"
+                    @select="setSourceForm" />
+                <SourceFromCollectionApplyRules
                     v-if="creatingWhat == 'collections'"
                     :selected="sourceFrom === 'collection'"
                     @select="setSourceForm" />
@@ -207,6 +301,20 @@ function onRuleCreate() {
         <div v-else-if="wizard.isCurrent('select-dataset')">
             <SelectDataset @onChange="setDatasetContents" />
         </div>
+        <div v-else-if="wizard.isCurrent('configure-workbook')">
+            <ConfigureFetchWorkbook
+                :collection-type="workbookCollectionType"
+                :include-collection-name="workbookIncludeCollectionName"
+                @onCollectionType="setWorkbookCollectionType"
+                @onIncludeCollectionName="setWorkbookIncludeCollectionName" />
+        </div>
+        <div v-else-if="wizard.isCurrent('upload-workbook')">
+            <UploadFetchWorkbook
+                :creating-what="creatingWhat"
+                :collection-type="workbookCollectionType"
+                :include-collection-name="workbookIncludeCollectionName"
+                @workbookContents="handleWorkbook" />
+        </div>
         <div v-else-if="wizard.isCurrent('rule-builder')" style="width: 100%">
             <RuleCollectionBuilder
                 ref="collectionCreator"
@@ -214,9 +322,20 @@ function onRuleCreate() {
                 :import-type="creatingWhat"
                 :elements-type="ruleBuilderModalEntryProps.selectionType"
                 :initial-elements="ruleBuilderElements"
+                :initial-mapping="ruleBuilderModalEntryProps.initialMappings"
                 mode="wizard"
                 @onCreate="onRuleCreate"
                 @validInput="onRuleState" />
         </div>
     </GenericWizard>
 </template>
+
+<style lang="scss" scoped>
+@import "theme/blue.scss";
+@import "@/components/Collections/wizard/workbook-dropzones.scss";
+
+// modeled a bit after upload-helper in the upload component...
+.workbook-upload-helper {
+    color: $border-color;
+}
+</style>
diff --git a/client/src/components/Collections/common/useCollectionCreator.ts b/client/src/components/Collections/common/useCollectionCreator.ts
index 876e28b42652..6bdee90319ec 100644
--- a/client/src/components/Collections/common/useCollectionCreator.ts
+++ b/client/src/components/Collections/common/useCollectionCreator.ts
@@ -67,11 +67,9 @@ export function useCollectionCreator(props: CommonCollectionBuilderProps, emit?:
 
     if (emit) {
         watch(collectionName, (newValue) => {
-            console.log("name upated...");
             emit("name", newValue);
         });
         watch(validInput, (newValue) => {
-            console.log("emitting...");
             emit("input-valid", newValue);
         });
     }
diff --git a/client/src/components/Collections/common/useWorkbooks.ts b/client/src/components/Collections/common/useWorkbooks.ts
new file mode 100644
index 000000000000..86043e9b3526
--- /dev/null
+++ b/client/src/components/Collections/common/useWorkbooks.ts
@@ -0,0 +1,101 @@
+import { faUpload } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { computed, ref } from "vue";
+
+import HiddenWorkbookUploadInput from "@/components/Collections/wizard/HiddenWorkbookUploadInput.vue";
+
+export const fileToBase64 = (file: File): Promise<string> =>
+    new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result as string);
+        reader.onerror = (error) => reject(error);
+        reader.readAsDataURL(file);
+    });
+
+export type WorkbookHandler = (workbookContentBase64: string) => Promise<void>;
+
+export function useWorkbookDropHandling(workbookHandler: WorkbookHandler) {
+    const uploadErrorMessage = ref<string | undefined>(undefined);
+    const isDragging = ref(false);
+    const isProcessingUpload = ref(false);
+
+    async function onFileUpload(event: Event) {
+        const input = event.target as HTMLInputElement;
+        const file = input.files?.[0] ?? null;
+        if (file) {
+            const base64Content = await readAsBase64(file);
+            workbookHandler(base64Content);
+        }
+    }
+
+    async function readAsBase64(file: File) {
+        const fileContent = await fileToBase64(file);
+        const base64Content = fileContent.split(",")[1] as string;
+        return base64Content;
+    }
+
+    function checkDrop(event: DragEvent): File | undefined {
+        const file = event.dataTransfer?.files[0];
+        if (!file || !file.name.endsWith(".xlsx")) {
+            uploadErrorMessage.value = "Please drop a valid XLSX file.";
+            return undefined;
+        }
+        return file;
+    }
+
+    const handleDrop = async (event: DragEvent) => {
+        const file = checkDrop(event);
+        if (!file) {
+            return;
+        }
+
+        isDragging.value = false;
+        isProcessingUpload.value = true;
+        try {
+            // Read and base64 encode the file
+            const base64Content = await readAsBase64(file);
+            await workbookHandler(base64Content);
+        } catch (error) {
+            console.error("Error uploading file:", error);
+            uploadErrorMessage.value = "There was an error processing the file.";
+        } finally {
+            isProcessingUpload.value = false;
+        }
+    };
+
+    const uploadRef = ref<InstanceType<typeof HiddenWorkbookUploadInput>>();
+
+    interface HasBrowse {
+        browse: () => void;
+    }
+
+    function browseFiles() {
+        const ref = uploadRef.value;
+        if (ref) {
+            (ref as unknown as HasBrowse).browse();
+        }
+    }
+
+    const dropZoneClasses = computed(() => {
+        const classes = ["dropzone"];
+        if (isDragging.value) {
+            classes.push("highlight");
+        }
+        return classes;
+    });
+
+    return {
+        browseFiles,
+        dropZoneClasses,
+        FontAwesomeIcon,
+        faUpload,
+        readAsBase64,
+        isDragging,
+        isProcessingUpload,
+        handleDrop,
+        HiddenWorkbookUploadInput,
+        onFileUpload,
+        uploadErrorMessage,
+        uploadRef,
+    };
+}
diff --git a/client/src/components/Collections/wizard/CardDownloadWorkbook.vue b/client/src/components/Collections/wizard/CardDownloadWorkbook.vue
new file mode 100644
index 000000000000..61e632024bdf
--- /dev/null
+++ b/client/src/components/Collections/wizard/CardDownloadWorkbook.vue
@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import { faDownload } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BCard, BCardTitle, BLink } from "bootstrap-vue";
+
+interface Props {
+    generateWorkbookLink: string;
+}
+
+defineProps<Props>();
+</script>
+
+<template>
+    <BCard>
+        <BCardTitle>
+            <b>Step 1: Download</b>
+        </BCardTitle>
+        <BLink :href="generateWorkbookLink"><FontAwesomeIcon size="xl" :icon="faDownload" /> Download workbook.</BLink>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/CardEditWorkbook.vue b/client/src/components/Collections/wizard/CardEditWorkbook.vue
new file mode 100644
index 000000000000..10fe17b728eb
--- /dev/null
+++ b/client/src/components/Collections/wizard/CardEditWorkbook.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import { faEdit } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BCard, BCardTitle } from "bootstrap-vue";
+</script>
+
+<template>
+    <BCard>
+        <BCardTitle>
+            <b>Step 2: Fill Out</b>
+        </BCardTitle>
+        <FontAwesomeIcon size="xl" :icon="faEdit" />Fill out the workbook with your favorite spreadsheet application and
+        save it to your local disk.
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/CardUploadWorkbook.vue b/client/src/components/Collections/wizard/CardUploadWorkbook.vue
new file mode 100644
index 000000000000..a98f3243246c
--- /dev/null
+++ b/client/src/components/Collections/wizard/CardUploadWorkbook.vue
@@ -0,0 +1,58 @@
+<script setup lang="ts">
+import { faUpload } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BAlert, BCard, BCardTitle, BLink } from "bootstrap-vue";
+
+import { useWorkbookDropHandling } from "@/components/Collections/common/useWorkbooks";
+
+async function handleWorkbook(base64Content: string) {
+    emit("workbookContents", base64Content);
+}
+
+const {
+    browseFiles,
+    dropZoneClasses,
+    handleDrop,
+    HiddenWorkbookUploadInput,
+    isDragging,
+    onFileUpload,
+    uploadErrorMessage,
+    uploadRef,
+} = useWorkbookDropHandling(handleWorkbook);
+
+const emit = defineEmits(["workbookContents"]);
+</script>
+<template>
+    <BCard
+        data-galaxy-file-drop-target
+        :class="dropZoneClasses"
+        @drop.prevent="handleDrop"
+        @dragover.prevent="isDragging = true"
+        @dragleave.prevent="isDragging = false">
+        <BCardTitle>
+            <b>Step 3: Upload</b>
+        </BCardTitle>
+        <div v-if="uploadErrorMessage">
+            <BAlert variant="danger" show>
+                {{ uploadErrorMessage }}
+            </BAlert>
+        </div>
+        <div>
+            <BLink href="#" @click.prevent="browseFiles">
+                <FontAwesomeIcon size="xl" :icon="faUpload" />
+                Drop completed workbook here or click to upload.
+            </BLink>
+            <HiddenWorkbookUploadInput ref="uploadRef" @onFileUpload="onFileUpload" />
+        </div>
+    </BCard>
+</template>
+
+<style scoped>
+@import "theme/blue.scss";
+@import "@/components/Collections/wizard/workbook-dropzones.scss";
+
+.dropzone {
+    padding: 7px !important;
+    width: 100%;
+}
+</style>
diff --git a/client/src/components/Collections/wizard/ConfigureFetchWorkbook.vue b/client/src/components/Collections/wizard/ConfigureFetchWorkbook.vue
new file mode 100644
index 000000000000..d265efcde36e
--- /dev/null
+++ b/client/src/components/Collections/wizard/ConfigureFetchWorkbook.vue
@@ -0,0 +1,50 @@
+<script setup lang="ts">
+import { BFormCheckbox } from "bootstrap-vue";
+import { ref, watch } from "vue";
+
+import type { ParsedFetchWorkbookForCollectionCollectionType } from "./types";
+
+import WhichWorkbookCollectionType from "./WhichWorkbookCollectionType.vue";
+
+interface Props {
+    collectionType: ParsedFetchWorkbookForCollectionCollectionType;
+    includeCollectionName: boolean;
+}
+
+const props = defineProps<Props>();
+
+const currentCollectionType = ref<ParsedFetchWorkbookForCollectionCollectionType>(props.collectionType);
+const currentIncludeCollectionName = ref<boolean>(props.includeCollectionName);
+
+const emit = defineEmits(["onCollectionType", "onIncludeCollectionName"]);
+
+function setCollectionType(type: ParsedFetchWorkbookForCollectionCollectionType) {
+    currentCollectionType.value = type;
+    emit("onCollectionType", currentCollectionType.value);
+}
+
+watch(currentIncludeCollectionName, (newValue) => {
+    emit("onIncludeCollectionName", newValue);
+});
+</script>
+
+<template>
+    <div class="configure-workbook">
+        <div class="which-question">What type of collection do you want to create?</div>
+        <WhichWorkbookCollectionType :value="collectionType" @onChange="setCollectionType" />
+        <BFormCheckbox v-model="currentIncludeCollectionName" class="multiple-collections" size="lg"
+            >Include a collection name column so multiple collections can be created using the workbook?</BFormCheckbox
+        >
+    </div>
+</template>
+
+<style scoped lang="scss">
+.which-question {
+    font-size: 1.2rem;
+}
+
+.multiple-collections {
+    margin-top: 1rem;
+    font-size: 1.2rem;
+}
+</style>
diff --git a/client/src/components/Collections/wizard/HiddenWorkbookUploadInput.vue b/client/src/components/Collections/wizard/HiddenWorkbookUploadInput.vue
new file mode 100644
index 000000000000..0e54ba459dc1
--- /dev/null
+++ b/client/src/components/Collections/wizard/HiddenWorkbookUploadInput.vue
@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import { ref } from "vue";
+
+const emit = defineEmits(["onFileUpload"]);
+const fileInputRef = ref<HTMLInputElement>();
+
+function browse() {
+    fileInputRef.value?.click();
+}
+
+function onFileUpload(event: Event) {
+    emit("onFileUpload", event);
+}
+
+defineExpose({
+    browse,
+});
+</script>
+
+<template>
+    <label style="display: none">
+        <input ref="fileInputRef" type="file" accept=".xlsx" @change="onFileUpload" />
+    </label>
+</template>
diff --git a/client/src/components/Collections/wizard/SourceFromCollection.vue b/client/src/components/Collections/wizard/SourceFromCollectionApplyRules.vue
similarity index 100%
rename from client/src/components/Collections/wizard/SourceFromCollection.vue
rename to client/src/components/Collections/wizard/SourceFromCollectionApplyRules.vue
diff --git a/client/src/components/Collections/wizard/SourceFromWorkbook.vue b/client/src/components/Collections/wizard/SourceFromWorkbook.vue
new file mode 100644
index 000000000000..6c2daa1b90e8
--- /dev/null
+++ b/client/src/components/Collections/wizard/SourceFromWorkbook.vue
@@ -0,0 +1,41 @@
+<script setup lang="ts">
+import { BCard, BCardTitle } from "bootstrap-vue";
+import { computed } from "vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+import type { RulesCreatingWhat } from "./types";
+
+interface Props {
+    selected: boolean;
+    creatingWhat: RulesCreatingWhat;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits(["select"]);
+
+const whatText = computed(() => {
+    if (props.creatingWhat == "datasets") {
+        return "dataset and metadata";
+    } else {
+        return "collection element metadata and structure";
+    }
+});
+</script>
+
+<template>
+    <BCard
+        data-import-source-from="workbook"
+        class="wizard-selection-card"
+        :border-variant="borderVariant(selected)"
+        @click="emit('select', 'workbook')">
+        <BCardTitle>
+            <b>External Workbook</b>
+        </BCardTitle>
+        <div>
+            This option le ts you fill in URLs/URIs in an external workbook using tools like Excel or Google Sheets and
+            specify {{ whatText }} in the workbook also.
+        </div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/UploadFetchWorkbook.vue b/client/src/components/Collections/wizard/UploadFetchWorkbook.vue
new file mode 100644
index 000000000000..428d17fbc46b
--- /dev/null
+++ b/client/src/components/Collections/wizard/UploadFetchWorkbook.vue
@@ -0,0 +1,51 @@
+<script setup lang="ts">
+import { BCardGroup } from "bootstrap-vue";
+import { computed } from "vue";
+
+import type { ParsedFetchWorkbookForCollectionCollectionType, RulesCreatingWhat } from "./types";
+
+import CardDownloadWorkbook from "./CardDownloadWorkbook.vue";
+import CardEditWorkbook from "./CardEditWorkbook.vue";
+import CardUploadWorkbook from "./CardUploadWorkbook.vue";
+
+async function handleWorkbook(base64Content: string) {
+    emit("workbookContents", base64Content);
+}
+
+interface Props {
+    creatingWhat: RulesCreatingWhat;
+    collectionType: ParsedFetchWorkbookForCollectionCollectionType;
+    includeCollectionName: boolean;
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits(["workbookContents"]);
+
+const generateWorkbookHref = computed(() => {
+    let type;
+    if (props.creatingWhat === "datasets") {
+        type = "dataset";
+    } else if (props.includeCollectionName) {
+        type = "collections";
+    } else {
+        type = "collection";
+    }
+    // const type = props.creatingWhat === "collections" ? "collection" : "dataset";
+    let url = `/api/tools/fetch/workbook?type=${type}`;
+    if (type === "collection" || type === "collections") {
+        url = `${url}&collection_type=${props.collectionType}`;
+    }
+    return url;
+});
+</script>
+
+<template>
+    <div class="generate-workbook">
+        <BCardGroup deck>
+            <CardDownloadWorkbook :generate-workbook-link="generateWorkbookHref" />
+            <CardEditWorkbook />
+            <CardUploadWorkbook @workbookContents="handleWorkbook" />
+        </BCardGroup>
+    </div>
+</template>
diff --git a/client/src/components/Collections/wizard/WhichWorkbookCollectionType.vue b/client/src/components/Collections/wizard/WhichWorkbookCollectionType.vue
new file mode 100644
index 000000000000..e05697967f6c
--- /dev/null
+++ b/client/src/components/Collections/wizard/WhichWorkbookCollectionType.vue
@@ -0,0 +1,92 @@
+<script setup lang="ts">
+import { BCard, BCardGroup, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+import type { ParsedFetchWorkbookForCollectionCollectionType } from "./types";
+
+interface Props {
+    value: ParsedFetchWorkbookForCollectionCollectionType;
+}
+
+const emit = defineEmits(["onChange"]);
+
+defineProps<Props>();
+</script>
+
+<template>
+    <div>
+        <BCardGroup deck>
+            <BCard
+                data-which-builder="list"
+                class="wizard-selection-card"
+                :border-variant="borderVariant(value === 'list')"
+                @click="emit('onChange', 'list')">
+                <BCardTitle>
+                    <b>Flat List</b>
+                </BCardTitle>
+                <div>
+                    This options creates a simple flat list of files. If your data isn't nested and does not contained
+                    paired datasets, this is the the option to choose.
+                </div>
+            </BCard>
+            <BCard
+                data-which-builder="list:paired"
+                class="wizard-selection-card"
+                :border-variant="borderVariant(value === 'list:paired')"
+                @click="emit('onChange', 'list:paired')">
+                <BCardTitle>
+                    <b>List of Paired Datasets</b>
+                </BCardTitle>
+                <div>
+                    This options creates a uniform list of paired datasets, use this option if all of your data should
+                    be paired off.
+                </div>
+            </BCard>
+        </BCardGroup>
+        <span>
+            <BCardGroup deck class="mt-3">
+                <BCard
+                    data-which-builder="list:paired_or_unpaired"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:paired_or_unpaired')"
+                    @click="emit('onChange', 'list:paired_or_unpaired')">
+                    <BCardTitle>
+                        <b>Mixed List of Paired and Unpaired Datasets</b>
+                    </BCardTitle>
+                    <div>
+                        For studies that have a mix of paired and unpaired data, this may be the right choice. Existing
+                        tools and workflows may have to be updated to allow this modality though.
+                    </div>
+                </BCard>
+                <BCard
+                    data-which-builder="list:list"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:list')"
+                    @click="emit('onChange', 'list:list')">
+                    <BCardTitle>
+                        <b>Nested List of Datasets</b>
+                    </BCardTitle>
+                    <div>
+                        A nested list of datasets. This type of collection is a list where each element is in turn a
+                        list of datasets. The outer list identifier might group samples together by condition, sample
+                        type, etc..
+                    </div>
+                </BCard>
+                <BCard
+                    data-which-builder="list:list:paired"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:list:paired')"
+                    @click="emit('onChange', 'list:list:paired')">
+                    <BCardTitle>
+                        <b>Nested List of Dataset Pairs</b>
+                    </BCardTitle>
+                    <div>
+                        A nested list of datasets. This type of collection is a list where each element is in turn a
+                        list of pairs of datasets.
+                    </div>
+                </BCard>
+            </BCardGroup>
+        </span>
+    </div>
+</template>
diff --git a/client/src/components/Collections/wizard/fetchWorkbooks.test.ts b/client/src/components/Collections/wizard/fetchWorkbooks.test.ts
new file mode 100644
index 000000000000..1cc0946d842e
--- /dev/null
+++ b/client/src/components/Collections/wizard/fetchWorkbooks.test.ts
@@ -0,0 +1,33 @@
+import { forBuilder } from "./fetchWorkbooks";
+import type { ParsedFetchWorkbook } from "./types";
+
+describe("forBuilder", () => {
+    it("should return the correct ForBuilderResponse for a valid ParsedFetchWorkbook", () => {
+        const parsedWorkbook: ParsedFetchWorkbook = {
+            rows: [
+                { list_identifiers: "Row1", url: "http://example.com/1", dbkey: "db1" },
+                { list_identifiers: "Row2", url: "http://example.com/2", dbkey: "db2" },
+            ],
+            columns: [
+                { type: "list_identifiers", title: "Name", type_index: 0 },
+                { type: "url", title: "URI", type_index: 0 },
+                { type: "dbkey", title: "Genome", type_index: 0 },
+            ],
+            workbook_type: "datasets",
+            parse_log: [],
+        };
+
+        const result = forBuilder(parsedWorkbook);
+
+        expect(result.initialElements).toEqual([
+            ["Row1", "http://example.com/1", "db1"],
+            ["Row2", "http://example.com/2", "db2"],
+        ]);
+        expect(result.rulesCreatingWhat).toBe("datasets");
+        expect(result.initialMapping).toEqual([
+            { type: "list_identifiers", columns: [0] },
+            { type: "url", columns: [1] },
+            { type: "dbkey", columns: [2] },
+        ]);
+    });
+});
diff --git a/client/src/components/Collections/wizard/fetchWorkbooks.ts b/client/src/components/Collections/wizard/fetchWorkbooks.ts
new file mode 100644
index 000000000000..79bed4141f46
--- /dev/null
+++ b/client/src/components/Collections/wizard/fetchWorkbooks.ts
@@ -0,0 +1,79 @@
+// utilities for populating the rule builder from parsed "fetch workbook"s.
+import type {
+    ColumnMappingType,
+    ParsedFetchWorkbook,
+    ParsedFetchWorkbookColumn,
+    RawRowData,
+    RuleBuilderMapping,
+    RulesCreatingWhat,
+} from "./types";
+
+export function hasData(parsedWorkbook: ParsedFetchWorkbook): boolean {
+    return parsedWorkbook.rows.length > 0;
+}
+
+export interface ForBuilderResponse {
+    initialElements: string[][];
+    rulesCreatingWhat: RulesCreatingWhat;
+    initialMapping: RuleBuilderMapping;
+}
+
+export function forBuilder(parsedWorkbook: ParsedFetchWorkbook): ForBuilderResponse {
+    const initialElements: RawRowData = [];
+    const rulesCreatingWhat = creatingWhat(parsedWorkbook);
+    for (const row of parsedWorkbook.rows) {
+        const rowAsString: string[] = [];
+        for (const column of parsedWorkbook.columns) {
+            const rowKey: string = columnToRowKey(column);
+            const cellValue = row[rowKey];
+            if (cellValue === undefined) {
+                throw Error("Error processing server response.");
+            }
+            rowAsString.push(cellValue);
+        }
+        initialElements.push(rowAsString);
+    }
+    const initialMapping = buildInitialMapping(parsedWorkbook);
+    return {
+        initialElements,
+        initialMapping,
+        rulesCreatingWhat,
+    };
+}
+
+function columnToRowKey(column: ParsedFetchWorkbookColumn): string {
+    if (column.type_index == 0) {
+        return column.type;
+    } else {
+        return `${column.type}_${column.type_index}`;
+    }
+}
+
+function creatingWhat(parsedWorkbook: ParsedFetchWorkbook): RulesCreatingWhat {
+    if (parsedWorkbook.workbook_type == "datasets") {
+        return "datasets";
+    } else {
+        return "collections";
+    }
+}
+
+function buildInitialMapping(parsedWorkbook: ParsedFetchWorkbook): RuleBuilderMapping {
+    const columnMappings: RuleBuilderMapping = [];
+    for (let index = 0; index < parsedWorkbook.columns.length; index++) {
+        const column = parsedWorkbook.columns[index] as ParsedFetchWorkbookColumn;
+        const type: ColumnMappingType = column.type;
+        if (column.type_index > 0) {
+            for (const columnMapping of columnMappings) {
+                if (columnMapping.type == type) {
+                    columnMapping.columns.push(index);
+                }
+            }
+        } else {
+            columnMappings.push({
+                type: type,
+                columns: [index],
+            });
+        }
+    }
+    return columnMappings;
+}
diff --git a/client/src/components/Collections/wizard/types.ts b/client/src/components/Collections/wizard/types.ts
index 911bbe3e850e..7ce84043291c 100644
--- a/client/src/components/Collections/wizard/types.ts
+++ b/client/src/components/Collections/wizard/types.ts
@@ -1,8 +1,42 @@
 import type { components } from "@/api/schema";
+import type { MAPPING_TARGETS } from "@/components/RuleBuilder/rule-definitions";
 
 export type RulesCreatingWhat = "datasets" | "collections";
-export type RulesSourceFrom = "remote_files" | "pasted_table" | "dataset_as_table" | "collection";
+export type RulesSourceFrom = "remote_files" | "pasted_table" | "dataset_as_table" | "collection" | "workbook";
 
 export type ListUriResponse = components["schemas"]["ListUriResponse"];
 export type RemoteFile = components["schemas"]["RemoteFile"];
 export type RemoteDirectory = components["schemas"]["RemoteDirectory"];
+export type ParsedFetchWorkbookForCollections = components["schemas"]["ParsedFetchWorkbookForCollections"];
+export type ParsedFetchWorkbookForDatasets = components["schemas"]["ParsedFetchWorkbookForDatasets"];
+export type ParsedFetchWorkbook = ParsedFetchWorkbookForCollections | ParsedFetchWorkbookForDatasets;
+export type ParsedFetchWorkbookColumn = components["schemas"]["ParsedColumn"];
+export type ParsedFetchWorkbookForCollectionCollectionType =
+    components["schemas"]["ParsedFetchWorkbookForCollections"]["collection_type"];
+
+export type RawRowData = string[][];
+
+// types and helpers around initializing the rule builder with data
+export type RuleSelectionType = "raw" | "remote_files";
+export type RuleElementsType = RemoteFile[] | string[][];
+export type ColumnMappingType = keyof typeof MAPPING_TARGETS;
+export type ParsedFetchWorkbookColumnType = ParsedFetchWorkbookColumn["type"];
+
+export interface RuleBuilderSingleMapping {
+    type: ColumnMappingType;
+    columns: number[];
+}
+export type RuleBuilderMapping = RuleBuilderSingleMapping[];
+
+// it would be nice to have a real type from the rule builder but
+// it is older code. This is really outlining what this component can
+// produce and not what the rule builder can consume which is a wide
+// superset of this.
+export interface RuleBuilderOptions {
+    dataType: RulesCreatingWhat;
+    ftpUploadSite?: string;
+    elements?: RuleElementsType | undefined;
+    content?: string;
+    selectionType: RuleSelectionType;
+    initialMappings?: RuleBuilderMapping;
+}
diff --git a/client/src/components/Collections/wizard/workbook-dropzones.scss b/client/src/components/Collections/wizard/workbook-dropzones.scss
new file mode 100644
index 000000000000..3f7c822753b4
--- /dev/null
+++ b/client/src/components/Collections/wizard/workbook-dropzones.scss
@@ -0,0 +1,9 @@
+@import "theme/blue.scss";
+
+.dropzone.highlight {
+    border-width: 2px;
+    border-color: $border-color;
+    border-style: dashed;
+    border-radius: $border-radius-large;
+    -moz-border-radius: $border-radius-large;
+}
diff --git a/client/src/components/Form/Elements/FormData/FormData.vue b/client/src/components/Form/Elements/FormData/FormData.vue
index dfadf6d9a1e0..707c324c9c60 100644
--- a/client/src/components/Form/Elements/FormData/FormData.vue
+++ b/client/src/components/Form/Elements/FormData/FormData.vue
@@ -592,7 +592,7 @@ function canAcceptSrc(historyContentType: "dataset" | "dataset_collection", coll
     }
 }
 
-const collectionTypesWithBuilders = [
+const collectionTypesWithBuilders: CollectionBuilderType[] = [
     "list",
     "list:paired",
     "paired",
@@ -602,8 +602,8 @@ const collectionTypesWithBuilders = [
 ];
 
 /** Allowed collection types for collection creation */
-const effectiveCollectionTypes = props.collectionTypes?.filter((collectionType) =>
-    collectionTypesWithBuilders.includes(collectionType)
+const effectiveCollectionTypes = props.collectionTypes?.filter((collectionType: string) =>
+    (collectionTypesWithBuilders as string[]).includes(collectionType)
 );
 
 const currentCollectionTypeTab = ref<CollectionBuilderType | undefined>(
diff --git a/client/src/components/Help/HelpText.vue b/client/src/components/Help/HelpText.vue
index b35a420a7dae..f24ea8c4fa74 100644
--- a/client/src/components/Help/HelpText.vue
+++ b/client/src/components/Help/HelpText.vue
@@ -23,13 +23,4 @@ const helpTarget = ref();
     </span>
 </template>
 
-<style scoped>
-/* Give visual indication of mouseover info */
-.help-text {
-    text-decoration-line: underline;
-    text-decoration-style: dashed;
-}
-.title-help-text {
-    text-decoration-thickness: 1px;
-}
-</style>
+<style scoped src="@/components/Help/help-text.scss" />
diff --git a/client/src/components/Help/help-text.scss b/client/src/components/Help/help-text.scss
new file mode 100644
index 000000000000..b84aea68a97e
--- /dev/null
+++ b/client/src/components/Help/help-text.scss
@@ -0,0 +1,8 @@
+/* Give visual indication of mouseover info */
+.help-text {
+    text-decoration-line: underline;
+    text-decoration-style: dashed;
+}
+.title-help-text {
+    text-decoration-thickness: 1px;
+}
diff --git a/client/src/components/RuleBuilder/ColumnSelector.vue b/client/src/components/RuleBuilder/ColumnSelector.vue
index 5acc6d14739c..3ccc9282aaa6 100644
--- a/client/src/components/RuleBuilder/ColumnSelector.vue
+++ b/client/src/components/RuleBuilder/ColumnSelector.vue
@@ -1,7 +1,7 @@
 <template>
     <div v-if="!multiple || !ordered" class="rule-column-selector">
         <label class="d-flex justify-content-end align-items-center">
-            <span v-b-tooltip.hover class="mr-auto" :title="help">{{ label }}</span>
+            <span v-b-tooltip.hover class="mr-auto help-text" :title="help">{{ label }}</span>
             <div v-b-tooltip.hover class="mr-1" :title="title">
                 <Select2 :value="target" :multiple="multiple" @input="handleInput">
                     <option v-for="(col, index) in colHeaders" :key="col" :value="index">{{ col }}</option>
@@ -11,7 +11,7 @@
         </label>
     </div>
     <div v-else class="rule-column-selector">
-        <span>{{ label }}</span>
+        <span class="help-text" :title="help">{{ label }}</span>
         <slot></slot>
         <ol>
             <li v-for="(targetEl, index) in target" :key="targetEl" :index="index" class="rule-column-selector-target">
@@ -136,3 +136,5 @@ export default {
     },
 };
 </script>
+
+<style scoped src="@/components/Help/help-text.scss" />
diff --git a/client/src/components/RuleBuilder/rule-definitions.js b/client/src/components/RuleBuilder/rule-definitions.js
index aec823b5a9bc..abf369514133 100644
--- a/client/src/components/RuleBuilder/rule-definitions.js
+++ b/client/src/components/RuleBuilder/rule-definitions.js
@@ -2,6 +2,8 @@ import pyre from "pyre-to-regexp";
 import _ from "underscore";
 import _l from "utils/localization";
 
+import MAPPING_TARGETS from "./rule_targets.yml";
+
 const NEW_COLUMN = "new";
 
 const multiColumnsToString = function (targetColumns, colHeaders) {
@@ -796,96 +798,6 @@ const RULES = {
     },
 };
 
-const MAPPING_TARGETS = {
-    list_identifiers: {
-        multiple: true,
-        label: _l("List Identifier(s)"),
-        columnHeader: _l("List Identifier"),
-        help: _l(
-            "This should be a short description of the replicate, sample name, condition, etc... that describes each level of the list structure."
-        ),
-        importType: "collections",
-    },
-    paired_identifier: {
-        label: _l("Paired-end Indicator"),
-        columnHeader: _l("Paired Indicator"),
-        help: _l(
-            "This should be set to '1', 'R1', 'forward', 'f', or 'F' to indicate forward reads, and '2', 'r', 'reverse', 'R2', 'R', or 'R2' to indicate reverse reads."
-        ),
-        importType: "collections",
-    },
-    collection_name: {
-        label: _l("Collection Name"),
-        help: _l(
-            "If this is set, all rows with the same collection name will be joined into a collection and it is possible to create multiple collections at once."
-        ),
-        modes: ["raw", "ftp", "datasets", "library_datasets"],
-        importType: "collections",
-    },
-    name_tag: {
-        label: _l("Name Tag"),
-        help: _l("Add a name tag or hash tag based on the specified column value for imported datasets."),
-        importType: "datasets",
-        modes: ["raw", "ftp"],
-    },
-    tags: {
-        multiple: true,
-        label: _l("General Purpose Tag(s)"),
-        help: _l(
-            "Add a general purpose tag based on the specified column value, use : to separate key-value pairs if desired. These tags are not propagated to derived datasets the way name and group tags are."
-        ),
-        modes: ["raw", "ftp", "datasets", "library_datasets", "collection_contents"],
-    },
-    group_tags: {
-        multiple: true,
-        label: _l("Group Tag(s)"),
-        help: _l(
-            "Add a group tag based on the specified column value, use : to separate key-value pairs. These tags are propagated to derived datasets and may be useful for factorial experiments."
-        ),
-        modes: ["raw", "ftp", "datasets", "library_datasets", "collection_contents"],
-    },
-    name: {
-        label: _l("Name"),
-        importType: "datasets",
-    },
-    dbkey: {
-        label: _l("Genome"),
-        modes: ["raw", "ftp"],
-    },
-    file_type: {
-        label: _l("Type"),
-        modes: ["raw", "ftp"],
-        help: _l("This should be the Galaxy file type corresponding to this file."),
-    },
-    url: {
-        label: _l("URL"),
-        modes: ["raw"],
-        help: _l("This should be a URL (or Galaxy-aware URI) the file can be downloaded from."),
-    },
-    url_deferred: {
-        label: _l("Deferred URL"),
-        modes: ["raw"],
-        help: _l(
-            "This should be a URL (or Galaxy-aware URI) th efile can be downloaded from - the file will not be downloaded until it used by a tool."
-        ),
-    },
-    info: {
-        label: _l("Info"),
-        help: _l(
-            "Unstructured text associated with the dataset that shows up in the history panel, this is optional and can be whatever you would like."
-        ),
-        modes: ["raw", "ftp"],
-    },
-    ftp_path: {
-        label: _l("FTP Path"),
-        modes: ["raw", "ftp"],
-        help: _l(
-            "This should be the path to the target file to include relative to your FTP directory on the Galaxy server"
-        ),
-        requiresFtp: true,
-    },
-};
-
 const columnDisplay = function (columns, colHeaders) {
     let columnNames;
     if (typeof columns == "object") {
diff --git a/client/src/components/RuleBuilder/rule_targets.yml b/client/src/components/RuleBuilder/rule_targets.yml
new file mode 120000
index 000000000000..323050dbe118
--- /dev/null
+++ b/client/src/components/RuleBuilder/rule_targets.yml
@@ -0,0 +1 @@
+../../../../lib/galaxy/model/dataset_collections/rule_targets.yml
\ No newline at end of file
diff --git a/client/src/components/RuleCollectionBuilder.vue b/client/src/components/RuleCollectionBuilder.vue
index c1ace0a568de..8a24f3cd2290 100644
--- a/client/src/components/RuleCollectionBuilder.vue
+++ b/client/src/components/RuleCollectionBuilder.vue
@@ -311,11 +311,25 @@
                                 </button>
                                 <div class="dropdown-menu" role="menu">
                                     <a
-                                        v-for="target in unmappedTargets"
+                                        v-for="target in basicUnmappedTargets"
                                         :key="target"
                                         :index="target"
                                         class="dropdown-item"
                                         href="javascript:void(0)"
+                                        :title="mappingTargets()[target].help"
+                                        :class="'rule-add-mapping-' + target.replace(/_/g, '-')"
+                                        @click="addIdentifier(target)"
+                                        >{{ mappingTargets()[target].label }}</a
+                                    >
+                                    <li><hr class="dropdown-divider" /></li>
+                                    <li><h6 class="dropdown-header">Advanced</h6></li>
+                                    <a
+                                        v-for="target in advancedUnmappedTargets"
+                                        :key="target"
+                                        :index="target"
+                                        class="dropdown-item"
+                                        href="javascript:void(0)"
+                                        :title="mappingTargets()[target].help"
                                         :class="'rule-add-mapping-' + target.replace(/_/g, '-')"
                                         @click="addIdentifier(target)"
                                         >{{ mappingTargets()[target].label }}</a
@@ -675,6 +689,11 @@ export default {
             required: false,
             type: Object,
         },
+        initialMapping: {
+            // only respected if elementsType is raw currently - other element types have their own default behaviors that make sense (e.g. assigning ftp paths to a URI implicitly)
+            required: false,
+            type: Array,
+        },
         defaultHideSourceItems: {
             type: Boolean,
             required: false,
@@ -721,6 +740,8 @@ export default {
                 mapping = [{ type: "url", columns: [0] }];
             } else if (this.elementsType == "datasets") {
                 mapping = [{ type: "list_identifiers", columns: [1] }];
+            } else if (this.initialMapping) {
+                mapping = this.initialMapping;
             } else {
                 mapping = [];
             }
@@ -956,6 +977,18 @@ export default {
             }
             return targets;
         },
+        basicUnmappedTargets() {
+            const unmappedTargets = this.unmappedTargets;
+            return unmappedTargets.filter((target) => {
+                return !MAPPING_TARGETS[target].advanced;
+            });
+        },
+        advancedUnmappedTargets() {
+            const unmappedTargets = this.unmappedTargets;
+            return unmappedTargets.filter((target) => {
+                return MAPPING_TARGETS[target].advanced;
+            });
+        },
         colHeaders() {
             const { data, columns } = this.hotData;
             return RuleDefs.colHeadersFor(data, columns);
@@ -1057,6 +1090,13 @@ export default {
                     collectionType = "paired";
                 }
             }
+            if (this.mappingAsDict.paired_or_unpaired_identifier) {
+                if (collectionType) {
+                    collectionType += ":paired_or_unpaired";
+                } else {
+                    collectionType = "paired_or_unpaired";
+                }
+            }
             return collectionType;
         },
         validName() {
@@ -1260,6 +1300,11 @@ export default {
                 this.$refs.hotTable.$el.click();
             }, 200);
         }
+        // is this comparable to watch immediate in newer Vue code?, I just need that event to
+        // to flair if it is initially okay also.
+        if (this.validInput) {
+            this.$emit("validInput", true);
+        }
     },
     methods: {
         restoreRules(event) {
@@ -1556,6 +1601,9 @@ export default {
             if (this.mappingAsDict.paired_identifier) {
                 identifierColumns.push(this.mappingAsDict.paired_identifier.columns[0]);
             }
+            if (this.mappingAsDict.paired_or_unpaired_identifier) {
+                identifierColumns.push(this.mappingAsDict.paired_or_unpaired_identifier.columns[0]);
+            }
             return identifierColumns;
         },
         buildRequestElements(createDatasetDescription, createSubcollectionDescription, subElementProp) {
@@ -1610,15 +1658,24 @@ export default {
                         let identifier = String(rowData[identifierColumns[identifierColumnIndex]]);
                         if (identifierColumnIndex + 1 == numIdentifierColumns) {
                             // At correct final position in nested structure for this dataset.
-                            if (collectionTypeAtDepth === "paired") {
+                            if (["paired", "paired_or_unpaired"].indexOf(collectionTypeAtDepth) > -1) {
                                 if (["f", "1", "r1", "forward"].indexOf(identifier.toLowerCase()) > -1) {
                                     identifier = "forward";
                                 } else if (["r", "2", "r2", "reverse"].indexOf(identifier.toLowerCase()) > -1) {
                                     identifier = "reverse";
+                                } else if (
+                                    collectionTypeAtDepth == "paired_or_unpaired" &&
+                                    ["unpaired", "u"].indexOf(identifier.toLowerCase()) > -1
+                                ) {
+                                    // assert collectionTypeAtDepth == paired_or_unpaired
+                                    identifier = "unpaired";
                                 } else {
                                     this.state = "error";
-                                    this.errorMessage =
-                                        "Unknown indicator of paired status encountered - only values of F, R, 1, 2, R1, R2, forward, or reverse are allowed.";
+                                    const allowedIndicators = ["F", "R", "1", "2", "R1", "R2", "forward", "reverse"];
+                                    if (collectionTypeAtDepth == "paired_or_unpaired") {
+                                        allowedIndicators.push("unpaired", "u");
+                                    }
+                                    this.errorMessage = `Unknown indicator (${identifier}) of paired status encountered - only values of (${allowedIndicators}) are allowed.`;
                                     return;
                                 }
                             }
@@ -1657,6 +1714,29 @@ export default {
                     }
                 }
 
+                // Recursively descend elements to handle "paired_or_unpaired" collections
+                const updateUnpairedIdentifiers = (elements) => {
+                    for (const value of Object.values(elements)) {
+                        if (typeof value !== "object" || value === null) {
+                            continue;
+                        }
+                        if (value.src === "new_collection" && value.collection_type === "paired_or_unpaired") {
+                            const subElements = value.elements;
+                            if (subElements["forward"] && !subElements["reverse"]) {
+                                subElements["unpaired"] = subElements["forward"];
+                                delete subElements["forward"];
+                            }
+                        }
+                        if (value.elements) {
+                            updateUnpairedIdentifiers(value.elements);
+                        }
+                    }
+                };
+
+                if (collectionType.endsWith("paired_or_unpaired")) {
+                    updateUnpairedIdentifiers(elements);
+                }
+
                 elementsByName[collectionName] = elements;
             }
 
@@ -1818,6 +1898,24 @@ export default {
                 const info = data[dataIndex][infoColumn];
                 res["info"] = info;
             }
+            const hashTypes = [
+                { key: "hash_md5", function: "MD5" },
+                { key: "hash_sha1", function: "SHA1" },
+                { key: "hash_sha256", function: "SHA256" },
+                { key: "hash_sha515", function: "SHA512" },
+            ];
+
+            hashTypes.forEach(({ key, function: hashFunction }) => {
+                if (mappingAsDict[key]) {
+                    const hashColumn = mappingAsDict[key].columns[0];
+                    const hash = data[dataIndex][hashColumn];
+                    if (res.hashes === undefined) {
+                        res["hashes"] = [];
+                    }
+                    res["hashes"].push({ hash_function: hashFunction, hash_value: hash });
+                }
+            });
+
             const tags = [];
             if (mappingAsDict.tags) {
                 const tagColumns = mappingAsDict.tags.columns;
diff --git a/lib/galaxy/app_unittest_utils/fetch_workbook.xlsx b/lib/galaxy/app_unittest_utils/fetch_workbook.xlsx
new file mode 100644
index 000000000000..8d1e3e394f03
Binary files /dev/null and b/lib/galaxy/app_unittest_utils/fetch_workbook.xlsx differ
diff --git a/lib/galaxy/app_unittest_utils/fetch_workbook_paired.xlsx b/lib/galaxy/app_unittest_utils/fetch_workbook_paired.xlsx
new file mode 100644
index 000000000000..a7ec750ede7b
Binary files /dev/null and b/lib/galaxy/app_unittest_utils/fetch_workbook_paired.xlsx differ
diff --git a/lib/galaxy/dependencies/pinned-requirements.txt b/lib/galaxy/dependencies/pinned-requirements.txt
index 3942ec3b2e57..5c4d1587b8b8 100644
--- a/lib/galaxy/dependencies/pinned-requirements.txt
+++ b/lib/galaxy/dependencies/pinned-requirements.txt
@@ -116,6 +116,7 @@ nodeenv==1.9.1
 numpy==2.0.2 ; python_full_version < '3.10'
 numpy==2.2.6 ; python_full_version >= '3.10'
 oauthlib==3.2.2
+openpyxl==3.1.5
 orjson==3.10.18
 oyaml==1.0
 packaging==24.2 ; python_full_version < '3.10'
diff --git a/lib/galaxy/managers/collections.py b/lib/galaxy/managers/collections.py
index 715f412f2445..dd23d8a527e4 100644
--- a/lib/galaxy/managers/collections.py
+++ b/lib/galaxy/managers/collections.py
@@ -744,14 +744,19 @@ def _build_elements_from_rule_data(self, collection_type_description, rule_set,
 
                 if i + 1 == len(identifier_columns):
                     # At correct final position in nested structure for this dataset.
-                    if collection_type_at_depth.collection_type == "paired":
+                    if collection_type_at_depth.collection_type in ["paired", "paired_or_unpaired"]:
                         if identifier.lower() in ["f", "1", "r1", "forward"]:
                             identifier = "forward"
                         elif identifier.lower() in ["r", "2", "r2", "reverse"]:
                             identifier = "reverse"
+                        elif identifier.lower() in ["u", "unpaired"]:
+                            identifier = "unpaired"
                         else:
+                            allow_identifiers = ["F", "R", "1", "2", "R1", "R2", "forward", "reverse"]
+                            if collection_type_at_depth == "paired_or_unpaired":
+                                allow_identifiers.extend(["unpaired", "u"])
                             raise Exception(
-                                "Unknown indicator of paired status encountered - only values of F, R, 1, 2, R1, R2, forward, or reverse are allowed."
+                                f"Unknown indicator of paired status encountered ({identifier}) - only values from ({allow_identifiers}) are allowed."
                             )
 
                     tags = []
@@ -769,7 +774,6 @@ def _build_elements_from_rule_data(self, collection_type_description, rule_set,
 
                     effective_dataset = handle_dataset(sources[data_index]["dataset"], tags)
                     elements_at_depth[identifier] = effective_dataset
-                    # log.info("Handling dataset [%s] with sources [%s], need to add tags [%s]" % (effective_dataset, sources, tags))
                 else:
                     collection_type_at_depth = collection_type_at_depth.child_collection_type_description()
                     found = False
@@ -788,6 +792,21 @@ def _build_elements_from_rule_data(self, collection_type_description, rule_set,
                         # Subsequent loop fills elements of newly created collection
                         elements_at_depth = sub_collection["elements"]
 
+        # Recursively descend elements to handle "paired_or_unpaired" collections
+        def update_unpaired_identifiers(elements):
+            for value in elements.values():
+                if not isinstance(value, dict):
+                    continue
+                if value.get("src") == "new_collection" and value.get("collection_type") == "paired_or_unpaired":
+                    sub_elements = value["elements"]
+                    if "forward" in sub_elements and "reverse" not in sub_elements:
+                        sub_elements["unpaired"] = sub_elements.pop("forward")
+                if "elements" in value:
+                    update_unpaired_identifiers(value["elements"])
+
+        if collection_type_description.collection_type.endswith("paired_or_unpaired"):
+            update_unpaired_identifiers(elements)
+
         return elements
 
     def __init_rule_data(self, elements, collection_type_description, parent_identifiers=None, parent_indices=None):
diff --git a/lib/galaxy/model/dataset_collections/rule_target_models.py b/lib/galaxy/model/dataset_collections/rule_target_models.py
new file mode 100644
index 000000000000..0fdf59d57b31
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/rule_target_models.py
@@ -0,0 +1,70 @@
+from typing import (
+    Dict,
+    List,
+    Literal,
+    Optional,
+)
+
+import yaml
+from pydantic import (
+    BaseModel,
+    RootModel,
+)
+
+from galaxy.util.resources import resource_string
+
+RuleBuilderImportType = Literal["datasets", "collections"]
+RuleBuilderModes = Literal[
+    "raw",
+    "ftp",
+    "datasets",
+    "library_datasets",
+    "collection_contents",
+]
+
+
+class ColumnTarget(BaseModel):
+    label: str
+    help: Optional[str]
+    modes: Optional[List[RuleBuilderModes]] = None
+    importType: Optional[RuleBuilderImportType] = None
+    multiple: Optional[bool] = False
+    columnHeader: Optional[str] = None
+    advanced: Optional[bool] = False
+    requiresFtp: Optional[bool] = False
+
+
+RuleBuilderMappingTargetKey = Literal[
+    "list_identifiers",
+    "paired_identifier",
+    "paired_or_unpaired_identifier",
+    "collection_name",
+    "name_tag",
+    "tags",
+    "group_tags",
+    "name",
+    "dbkey",
+    "hash_sha1",
+    "hash_md5",
+    "hash_sha256",
+    "hash_sha512",
+    "file_type",
+    "url",
+    "url_deferred",
+    "info",
+    "ftp_path",
+]
+
+
+ColumnTargetsConfig = Dict[RuleBuilderMappingTargetKey, ColumnTarget]
+ColumnTargetsConfigRootModel = RootModel[ColumnTargetsConfig]
+
+
+def target_models() -> ColumnTargetsConfig:
+    column_targets_str = resource_string(__name__, "rule_targets.yml")
+    column_targets_raw = yaml.safe_load(column_targets_str)
+    return ColumnTargetsConfigRootModel.model_validate(column_targets_raw).root
+
+
+def target_model_by_type(type: RuleBuilderMappingTargetKey) -> ColumnTarget:
+    return target_models()[type]
diff --git a/lib/galaxy/model/dataset_collections/rule_targets.yml b/lib/galaxy/model/dataset_collections/rule_targets.yml
new file mode 100644
index 000000000000..b39caf5dea49
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/rule_targets.yml
@@ -0,0 +1,164 @@
+# This file defines the column targets for the rule builder.
+list_identifiers:
+  multiple: true
+  label: "List Identifier(s)"
+  columnHeader: "List Identifier"
+  help: |
+    This should be a short description of the replicate, sample name, 
+    condition, etc... that describes each level of the list structure.
+  importType: "collections"
+paired_identifier:
+  label: "Paired-end Indicator"
+  columnHeader: "Paired Indicator"
+  help: |
+    This should be set to '1', 'R1', 'forward', 'f', or 'F' to indicate 
+    forward reads, and '2', 'r', 'reverse', 'R2', 'R', or 'R2' to indicate 
+    reverse reads.
+  importType: "collections"
+paired_or_unpaired_identifier:
+  label: "Optional Paired-end Indicator"
+  columnHeader: "Optional Paired Indicator"
+  help: |
+    This should be set to '1', 'R1', 'forward', 'f', or 'F' to indicate 
+    forward reads, and '2', 'r', 'reverse', 'R2', 'R', or 'R2' to indicate 
+    reverse reads. Unmatched '1' for 'forward' elements will be 'unpaired' 
+    in the resulting list, alternatively this column can be set to 'u' or 
+    'unpaired' to force the element to be unpaired.
+  importType: "collections"
+  advanced: true
+collection_name:
+  label: "Collection Name"
+  help: |
+    If this is set, all rows with the same collection name will be joined 
+    into a collection and it is possible to create multiple collections 
+    at once.
+  modes:
+    - "raw"
+    - "ftp"
+    - "datasets"
+    - "library_datasets"
+  importType: "collections"
+name_tag:
+  label: "Name Tag"
+  help: |
+    Add a name tag or hash tag based on the specified column value for 
+    imported datasets.
+  importType: "datasets"
+  modes:
+    - "raw"
+    - "ftp"
+tags:
+  multiple: true
+  label: "General Purpose Tag(s)"
+  help: |
+    Add a general purpose tag based on the specified column value, use : 
+    to separate key-value pairs if desired. These tags are not propagated 
+    to derived datasets the way name and group tags are.
+  modes:
+    - "raw"
+    - "ftp"
+    - "datasets"
+    - "library_datasets"
+    - "collection_contents"
+group_tags:
+  multiple: true
+  label: "Group Tag(s)"
+  help: |
+    Add a group tag based on the specified column value, use : to separate 
+    key-value pairs. These tags are propagated to derived datasets and may 
+    be useful for factorial experiments.
+  modes:
+    - "raw"
+    - "ftp"
+    - "datasets"
+    - "library_datasets"
+    - "collection_contents"
+name:
+  label: "Name"
+  importType: "datasets"
+  help: |
+    This is just the name of the dataset as it appears in the Galaxy history
+    panel.
+dbkey:
+  label: "Genome"
+  help: |
+    This should be the genome build (e.g. hg19, mm9, etc...) that the data 
+    is associated with. If this is not set, there will be no genome associated
+    with the dataset.
+  modes:
+    - "raw"
+    - "ftp"
+hash_sha1:
+  label: "Hash (SHA1)"
+  help: |
+    This is the SHA1 hash of the URI, this is used to verify that the file 
+    has not been corrupted during transfer.
+  modes:
+    - "raw"
+    - "ftp"
+  advanced: true
+hash_md5:
+  label: "Hash (MD5)"
+  help: |
+    This is the MD5 hash of the URI, this is used to verify that the file 
+    has not been corrupted during transfer.
+  modes:
+    - "raw"
+    - "ftp"
+  advanced: true
+hash_sha256:
+  label: "Hash (SHA256)"
+  help: |
+    This is the SHA256 hash of the URI, this is used to verify that the file 
+    has not been corrupted during transfer.
+  modes:
+    - "raw"
+    - "ftp"
+  advanced: true
+hash_sha512:
+  label: "Hash (SHA512)"
+  help: |
+    This is the SHA512 hash of the URI, this is used to verify that the file 
+    has not been corrupted during transfer.
+  modes:
+    - "raw"
+    - "ftp"
+  advanced: true
+file_type:
+  label: "Type"
+  modes:
+    - "raw"
+    - "ftp"
+  help: |
+    This should be the Galaxy file type corresponding to this file.
+url:
+  label: "URL"
+  modes:
+    - "raw"
+  help: |
+    This should be a URL (or Galaxy-aware URI) the file can be downloaded 
+    from.
+url_deferred:
+  label: "Deferred URL"
+  modes:
+    - "raw"
+  help: |
+    This should be a URL (or Galaxy-aware URI) the file can be downloaded 
+    from - the file will not be downloaded until it used by a tool.
+info:
+  label: "Info"
+  help: |
+    Unstructured text associated with the dataset that shows up in the 
+    history panel, this is optional and can be whatever you would like.
+  modes:
+    - "raw"
+    - "ftp"
+ftp_path:
+  label: "FTP Path"
+  modes:
+    - "raw"
+    - "ftp"
+  help: |
+    This should be the path to the target file to include relative to your 
+    FTP directory on the Galaxy server.
+  requiresFtp: true
diff --git a/lib/galaxy/model/dataset_collections/workbook_util.py b/lib/galaxy/model/dataset_collections/workbook_util.py
new file mode 100644
index 000000000000..4d62cdc6ab5d
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/workbook_util.py
@@ -0,0 +1,141 @@
+"""Shared code for working with workbook data.
+
+Module was developed for sample sheet work but extracted for reuse with fetch
+workbooks.
+"""
+
+import base64
+from dataclasses import dataclass
+from io import BytesIO
+from textwrap import wrap
+from typing import List
+
+from openpyxl import (
+    load_workbook,
+    Workbook,
+)
+from openpyxl.styles import Font
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.worksheet.worksheet import Worksheet
+
+from galaxy.exceptions import RequestParameterInvalidException
+
+Base64StringT = str
+
+
+def freeze_header_row(worksheet: Worksheet) -> None:
+    worksheet.freeze_panes = "A2"
+
+
+def make_headers_bold(worksheet: Worksheet, headers: list) -> None:
+    for index in range(len(headers)):
+        make_bold(worksheet, 1, index)
+
+
+def make_bold(worksheet: Worksheet, row: int, column: int):
+    """Make the target cell bold in the specified worksheet."""
+    bold_font = Font(bold=True)
+    worksheet[f"{index_to_excel_column(column)}{row}"].font = bold_font
+
+
+def index_to_excel_column(index: int) -> str:
+    """Converts a numeric index (0-based) into an Excel column label."""
+    if index < 0:
+        raise ValueError("Index must be 0 or greater")
+
+    column_label = ""
+    while index >= 0:
+        column_label = chr(index % 26 + 65) + column_label
+        index = index // 26 - 1  # Move to the next "digit" in base-26, adjusting for zero-based indexing
+
+    return column_label
+
+
+def uri_data_validation(column: str) -> DataValidation:
+    # Add data validation for "URI" column
+    # We cannot assume http/https since drs, gxfiles, etc... are all fine
+    uri_validation = DataValidation(type="custom", formula1=f'=ISNUMBER(FIND("://", {column}2))', allow_blank=True)
+    uri_validation.error = "Invalid URI"
+    uri_validation.errorTitle = "Error"
+    uri_validation.showErrorMessage = True
+    return uri_validation
+
+
+def add_column_validation(column: str, data_validation: DataValidation, worksheet: Worksheet):
+    data_validation.add(f"{column}2:{column}1048576")
+    worksheet.add_data_validation(data_validation)
+
+
+def set_column_width(worksheet: Worksheet, column_index: int, width: int):
+    worksheet.column_dimensions[index_to_excel_column(column_index)].width = width
+
+
+def load_workbook_from_base64(content: str) -> Workbook:
+    decoded_content = base64.b64decode(content)
+    file_like = BytesIO(decoded_content)
+    try:
+        workbook = load_workbook(file_like, data_only=True)
+    except Exception:
+        raise RequestParameterInvalidException(
+            "The provided content is not a valid Excel file. Please check the content and try again."
+        )
+    return workbook
+
+
+def workbook_to_bytes(workbook: "Workbook") -> BytesIO:
+    output = BytesIO()
+    workbook.save(output)
+    output.seek(0)
+    return output
+
+
+@dataclass
+class HasHelp:
+    title: str
+    help: str
+
+
+@dataclass
+class HelpConfiguration:
+    instructions: List[str]
+    columns: List[HasHelp]
+    text_width: int
+    column_width: int
+    help_row_start: int = 3
+
+
+def wrap_instructions(instruction: str, help_config: HelpConfiguration) -> List[str]:
+    return wrap(instruction, width=help_config.text_width)
+
+
+def add_instructions_to_sheet(worksheet: Worksheet, help_configuration: HelpConfiguration):
+    columns = help_configuration.columns
+    num_columns = len(columns)
+    help_label_index = num_columns + 2
+    # why is the width not +1
+    set_column_width(worksheet, help_label_index, help_configuration.column_width)
+
+    help_start_row = help_configuration.help_row_start
+    current_row = help_start_row
+
+    worksheet.cell(row=current_row, column=help_label_index, value="Instructions")
+    make_bold(worksheet, current_row, help_label_index - 1)
+
+    current_row += 1
+
+    for instruction_index, instruction in enumerate(help_configuration.instructions):
+        worksheet.cell(row=current_row, column=help_label_index, value=f"> {instruction_index + 1}.")
+        instruction_lines = wrap_instructions(instruction, help_configuration)
+        for line in instruction_lines:
+            worksheet.cell(row=current_row, column=help_label_index + 1, value=line)
+            current_row += 1
+
+    current_row += 2
+    worksheet.cell(row=current_row, column=help_label_index, value="Columns")
+    make_bold(worksheet, current_row, help_label_index - 1)
+    current_row += 1
+
+    for column in columns:
+        worksheet.cell(row=current_row, column=help_label_index, value=column.title)
+        worksheet.cell(row=current_row, column=help_label_index + 1, value=column.help)
+        current_row += 1
diff --git a/lib/galaxy/model/migrations/alembic/versions_gxy/f070559879f1_create_user_dynamic_tool_association_.py b/lib/galaxy/model/migrations/alembic/versions_gxy/f070559879f1_create_user_dynamic_tool_association_.py
index 5691466b3305..c68c0cf8e444 100644
--- a/lib/galaxy/model/migrations/alembic/versions_gxy/f070559879f1_create_user_dynamic_tool_association_.py
+++ b/lib/galaxy/model/migrations/alembic/versions_gxy/f070559879f1_create_user_dynamic_tool_association_.py
@@ -1,7 +1,7 @@
 """Create user_dynamic_tool_association table
 
 Revision ID: f070559879f1
-Revises: 75348cfb3715
+Revises: ec25b23b08e2
 Create Date: 2024-12-06 14:56:18.494243
 
 """
diff --git a/lib/galaxy/tools/fetch/__init__.py b/lib/galaxy/tools/fetch/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/lib/galaxy/tools/fetch/workbooks.py b/lib/galaxy/tools/fetch/workbooks.py
new file mode 100644
index 000000000000..40c1f08e6c84
--- /dev/null
+++ b/lib/galaxy/tools/fetch/workbooks.py
@@ -0,0 +1,503 @@
+from dataclasses import dataclass
+from typing import (
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from openpyxl import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+from pydantic import (
+    BaseModel,
+    Field,
+)
+from typing_extensions import Literal
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.model.dataset_collections.rule_target_models import (
+    ColumnTarget,
+    RuleBuilderMappingTargetKey,
+    target_model_by_type,
+)
+from galaxy.model.dataset_collections.workbook_util import (
+    add_column_validation,
+    add_instructions_to_sheet,
+    Base64StringT,
+    freeze_header_row,
+    HasHelp,
+    HelpConfiguration,
+    load_workbook_from_base64,
+    make_headers_bold,
+    set_column_width,
+    uri_data_validation,
+)
+
+FetchWorkbookType = Literal["datasets", "collection", "collections"]
+FetchWorkbookCollectionType = Literal["list", "list:paired", "list:list", "list:list:paired", "list:paired_or_unpaired"]
+
+DEFAULT_FETCH_WORKBOOK_TYPE: FetchWorkbookType = "datasets"
+DEFAULT_FETCH_WORKBOOK_COLLECTION_TYPE: FetchWorkbookCollectionType = "list"
+DEFAULT_WORKBOOK_TITLE: str = "Galaxy Data Import"
+
+INSTRUCTION_USE_THIS = "Use this spreadsheet to describe your datasets. For each dataset (i.e. each file), ensure all the labeled columns are specified and correct."
+INSTRUCTION_EXTRA_COLUMNS = "Additional columns can be added if we you wish to specify additional metadata."  # mention second tab when implemented
+INSTRUCTION_ONCE_COMPLETE_DATASETS = (
+    "Once data entry is complete, drop this file back into Galaxy to finish creating datasets for your inputs."
+)
+INSTRUCTION_ONCE_COMPLETE_COLLECTION = (
+    "Once data entry is complete, drop this file back into Galaxy to finish creating a collection for your inputs."
+)
+INSTRUCTION_ONCE_COMPLETE_COLLECTIONS = (
+    "Once data entry is complete, drop this file back into Galaxy to finish creating collections for your inputs."
+)
+INSTRUCTIONS_BY_TYPE: Dict[FetchWorkbookType, List[str]] = {
+    "datasets": [
+        INSTRUCTION_USE_THIS,
+        INSTRUCTION_EXTRA_COLUMNS,
+        INSTRUCTION_ONCE_COMPLETE_DATASETS,
+    ],
+    "collection": [
+        INSTRUCTION_USE_THIS,
+        INSTRUCTION_EXTRA_COLUMNS,
+        INSTRUCTION_ONCE_COMPLETE_COLLECTION,
+    ],
+    "collections": [
+        INSTRUCTION_USE_THIS,
+        INSTRUCTION_EXTRA_COLUMNS,
+        INSTRUCTION_ONCE_COMPLETE_COLLECTIONS,
+    ],
+}
+
+EXCEPTION_TOO_MANY_URI_COLUMNS = "Too many URI/URL columns in the supplied workbook."
+EXCEPTION_NO_URIS_FOUND = "Failed to find any URI or URL like column in the supplied workbook."
+
+
+@dataclass
+class GenerateFetchWorkbookRequest:
+    type: FetchWorkbookType = DEFAULT_FETCH_WORKBOOK_TYPE
+    collection_type: FetchWorkbookCollectionType = DEFAULT_FETCH_WORKBOOK_COLLECTION_TYPE
+    title: str = DEFAULT_WORKBOOK_TITLE
+
+
+WorkbookContentField: Base64StringT = Field(
+    ...,
+    title="Workbook Content (Base 64 encoded)",
+    description="The workbook content (the contents of the xlsx file) that have been base64 encoded.",
+)
+
+
+class ParseFetchWorkbook(BaseModel):
+    content: Base64StringT = WorkbookContentField
+
+
+@dataclass
+class HeaderColumn:
+    type: RuleBuilderMappingTargetKey
+    title: str  # user facing
+    # e.g. for paired data will have two columns of URIs, record types maybe have any number
+    # and after dataset hash may have multiples of those also
+    type_index: int
+
+    @property
+    def width(self):
+        if self.type in ["url", "url_deferred", "ftp_path"]:
+            return 50
+        else:
+            return 20
+
+    @property
+    def name(self):
+        if self.type_index == 0:
+            return self.type
+        else:
+            return f"{self.type}_{self.type_index}"
+
+    @property
+    def help(self) -> str:
+        column_target = _column_header_to_column_target(self)
+        return column_target.help if column_target.help else ""
+
+    @property
+    def parsed_column(self) -> "ParsedColumn":
+        return ParsedColumn(
+            type=self.type,
+            type_index=self.type_index,
+            title=self.title,
+        )
+
+
+def generate(request: GenerateFetchWorkbookRequest) -> Workbook:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.title = request.title
+    header_columns = _request_to_columns(request)
+
+    header_titles = [h.title for h in header_columns]
+    worksheet.append(header_titles)
+    make_headers_bold(worksheet, header_titles)
+    freeze_header_row(worksheet)
+    for i, column in enumerate(header_columns):
+        set_column_width(worksheet, i, column.width)
+
+    uri_data_validator = uri_data_validation("A")
+    add_column_validation("A", uri_data_validator, worksheet)
+
+    columns_for_help = [HasHelp(c.title, c.help) for c in header_columns]
+    help_configuration = HelpConfiguration(
+        instructions=INSTRUCTIONS_BY_TYPE[request.type],
+        columns=columns_for_help,
+        text_width=50,
+        column_width=50,
+    )
+    add_instructions_to_sheet(
+        worksheet,
+        help_configuration,
+    )
+
+    return workbook
+
+
+ParsedRow = Dict[str, str]
+ParsedRows = List[ParsedRow]
+
+
+class ParsedColumn(BaseModel):
+    type: RuleBuilderMappingTargetKey
+    type_index: int
+    title: str
+
+
+class ParseLogEntry(BaseModel):
+    message: str
+
+
+class SplitUpPairedDataLogEntry(ParseLogEntry):
+    message: str
+    old_forward_column: ParsedColumn
+    old_reverse_column: ParsedColumn
+    new_paired_status_column: int
+
+
+class InferredCollectionTypeLogEntry(ParseLogEntry):
+    message: str
+    from_columns: List[ParsedColumn]
+
+
+ParseLog = List[ParseLogEntry]
+
+
+class BaseParsedFetchWorkbook(BaseModel):
+    rows: ParsedRows
+    columns: List[ParsedColumn]
+    workbook_type: FetchWorkbookType
+    parse_log: ParseLog
+
+
+class ParsedFetchWorkbookForDatasets(BaseParsedFetchWorkbook):
+    workbook_type: FetchWorkbookType = "datasets"
+
+
+class ParsedFetchWorkbookForCollections(BaseParsedFetchWorkbook):
+    workbook_type: FetchWorkbookType = "collection"
+    collection_type: FetchWorkbookCollectionType
+
+
+ParsedFetchWorkbook = Union[ParsedFetchWorkbookForDatasets, ParsedFetchWorkbookForCollections]
+
+
+def parse(payload: ParseFetchWorkbook) -> ParsedFetchWorkbook:
+    parse_log: ParseLog = []
+    workbook = load_workbook_from_base64(payload.content)
+    column_headers = _read_column_headers(workbook.active)
+    _validate_parsed_column_headers(column_headers)
+    raw_rows = _load_row_data(workbook, payload)
+
+    # the rule builder does require splitting the paired data in this way but it might
+    # be worth it to do it with an "initial rule" instead to demo how you'd do it
+    # with actual rule builder rules? Not sure.
+    rows, column_headers, split_data_log_entry = _split_paired_data_if_needed(raw_rows, column_headers)
+    if split_data_log_entry:
+        parse_log.append(split_data_log_entry)
+    columns = [ParsedColumn(title=c.title, type=c.type, type_index=c.type_index) for c in column_headers]
+    if _is_fetch_workbook_for_collections(column_headers):
+        collection_type, log_entry = _infer_fetch_workbook_collection_type(column_headers)
+        parse_log.append(log_entry)
+        assert collection_type in ["list", "list:paired", "list:list", "list:list:paired", "list:paired_or_unpaired"]
+        return ParsedFetchWorkbookForCollections(
+            collection_type=collection_type, rows=rows, columns=columns, parse_log=parse_log
+        )
+    else:
+        return ParsedFetchWorkbookForDatasets(rows=rows, columns=columns, parse_log=parse_log)
+
+
+def _validate_parsed_column_headers(column_headers: List[HeaderColumn]) -> None:
+    uri_like_columns = _uri_like_columns(column_headers)
+    if len(uri_like_columns) > 2:
+        raise RequestParameterInvalidException(
+            f"{EXCEPTION_TOO_MANY_URI_COLUMNS}. Relevant headers are {[c.title for c in uri_like_columns]}"
+        )
+    if len(uri_like_columns) == 0:
+        raise RequestParameterInvalidException(EXCEPTION_NO_URIS_FOUND)
+
+
+def _request_to_columns(request: GenerateFetchWorkbookRequest) -> List[HeaderColumn]:
+    if request.type == "datasets":
+        return [
+            HeaderColumn("url", "URI", 0),
+            HeaderColumn("name", "Name", 0),
+        ]
+    else:
+        if request.collection_type == "list":
+            header_columns = [
+                HeaderColumn("url", "URI", 0),
+                HeaderColumn("list_identifiers", "List Identifier", 0),
+            ]
+        elif request.collection_type == "list:paired":
+            header_columns = [
+                HeaderColumn("url", "URI 1 (Forward)", 0),
+                HeaderColumn("url", "URI 2 (Reverse)", 1),
+                HeaderColumn("list_identifiers", "List Identifier", 0),
+            ]
+        elif request.collection_type == "list:list":
+            header_columns = [
+                HeaderColumn("url", "URI", 0),
+                HeaderColumn("list_identifiers", "Outer List Identifier", 0),
+                HeaderColumn("list_identifiers", "Inner List Identifier", 1),
+            ]
+        elif request.collection_type == "list:list:paired":
+            header_columns = [
+                HeaderColumn("url", "URI 1 (Forward)", 0),
+                HeaderColumn("url", "URI 2 (Reverse)", 1),
+                HeaderColumn("list_identifiers", "Outer List Identifier", 0),
+                HeaderColumn("list_identifiers", "Inner List Identifier", 1),
+            ]
+        elif request.collection_type == "list:paired_or_unpaired":
+            header_columns = [
+                HeaderColumn("url", "URI 1 (Forward)", 0),
+                HeaderColumn("url", "URI 2 (Optional/Reverse)", 1),
+                HeaderColumn("list_identifiers", "List Identifier", 0),
+            ]
+        else:
+            raise NotImplementedError()
+        if request.type == "collections":
+            header_columns.append(
+                HeaderColumn(
+                    type="collection_name",
+                    title="Collection Name",
+                    type_index=0,
+                )
+            )
+        return header_columns
+
+
+def _load_row_data(workbook: Workbook, payload: ParseFetchWorkbook) -> ParsedRows:
+    sheet = workbook.active  # Get the first sheet
+
+    rows: ParsedRows = []
+
+    column_headers = _read_column_headers(sheet)
+    columns_to_read = len(column_headers)
+
+    for row_index, row in enumerate(sheet.iter_rows(max_col=columns_to_read, values_only=True)):
+        if row_index == 0:  # skip column headers
+            continue
+        if not row[0]:
+            break
+        parsed_row: ParsedRow = {}
+        for value, column in zip(row, column_headers):
+            parsed_row[column.name] = value
+        rows.append(parsed_row)
+    return rows
+
+
+def _split_paired_data_if_needed(
+    rows: ParsedRows, column_headers: List[HeaderColumn]
+) -> Tuple[ParsedRows, List[HeaderColumn], Optional[SplitUpPairedDataLogEntry]]:
+    split_rows: ParsedRows = []
+    uri_like_columns = _uri_like_columns(column_headers)
+    if len(_uri_like_columns(column_headers)) != 2:
+        return rows, column_headers, None
+
+    url_column_0 = uri_like_columns[0]
+    url_column_1 = uri_like_columns[1]
+
+    # Split the data up
+    split_rows = []
+    for row in rows:
+        url_0 = row.pop(url_column_0.name)
+        url_1 = row.pop(url_column_1.name)
+        row_0 = row.copy()
+        row_1 = row.copy()
+        row_0[url_column_0.name] = url_0
+        row_1[url_column_0.name] = url_1
+        row_0["paired_identifier"] = "1"
+        row_1["paired_identifier"] = "2"
+        split_rows.append(row_0)
+        split_rows.append(row_1)
+
+    # Adjust the columns accordingly
+    column_headers.remove(url_column_1)
+    column_headers.append(
+        HeaderColumn(
+            type="paired_identifier",
+            title="Paired Identifier",
+            type_index=0,
+        )
+    )
+    split_log_entry = SplitUpPairedDataLogEntry(
+        message="Merged paired data URIs columns into single column and added paired identifier column.",
+        old_forward_column=url_column_0.parsed_column,
+        old_reverse_column=url_column_1.parsed_column,
+        new_paired_status_column=len(column_headers) - 1,
+    )
+    return split_rows, column_headers, split_log_entry
+
+
+def _read_column_header_titles(worksheet: Worksheet) -> List[str]:
+    # TODO: capture parsing information messages, a lot less structure here than sample sheet
+    # stuff where we know expected columns... I think.
+    index = 1
+    titles: List[str] = []
+    while True:
+        value = worksheet.cell(1, index).value
+        if not value:
+            break
+        titles.append(value)
+        index += 1
+    return titles
+
+
+def _read_column_headers(worksheet: Worksheet) -> List[HeaderColumn]:
+    column_titles = _read_column_header_titles(worksheet)
+    return _column_titles_to_headers(column_titles)
+
+
+COLUMN_TITLE_PREFIXES: Dict[str, RuleBuilderMappingTargetKey] = {
+    "name": "name",
+    "listname": "collection_name",
+    "collectionname": "collection_name",
+    "uri": "url",
+    "url": "url",
+    "urldeferred": "url_deferred",
+    "deferredurl": "url_deferred",
+    "genome": "dbkey",
+    "dbkey": "dbkey",
+    "filetype": "file_type",
+    "info": "info",
+    "tag": "tags",
+    "grouptag": "group_tags",
+    "nametag": "name_tag",
+    "listidentifier": "list_identifiers",
+    "pairedidentifier": "paired_identifier",
+}
+
+
+def _column_titles_to_headers(column_titles: List[str]) -> List[HeaderColumn]:
+    headers: List[HeaderColumn] = []
+    headers_of_type_seen: Dict[RuleBuilderMappingTargetKey, int] = {}
+
+    for column_title in column_titles:
+        normalized_title = (
+            column_title.lower()
+            .replace(" ", "")
+            .replace("optional", "")
+            .replace("(", "")
+            .replace(")", "")
+            .replace(")", "")
+        )
+        print(normalized_title)
+        if normalized_title not in COLUMN_TITLE_PREFIXES:
+            for key in COLUMN_TITLE_PREFIXES.keys():
+                if normalized_title.startswith(key):
+                    normalized_title = key
+                    break
+                elif normalized_title.endswith(key):
+                    normalized_title = key
+                    break
+
+        if normalized_title not in COLUMN_TITLE_PREFIXES:
+            print(f"Unknown column title: {column_title}")
+            break
+
+        column_type: RuleBuilderMappingTargetKey = COLUMN_TITLE_PREFIXES[normalized_title]
+        if column_type in headers_of_type_seen:
+            type_index = headers_of_type_seen[column_type]
+            headers_of_type_seen[column_type] += 1
+        else:
+            type_index = 0
+            headers_of_type_seen[column_type] = 1
+        header_column = HeaderColumn(
+            type=column_type,
+            type_index=type_index,
+            title=column_title,
+        )
+        if header_column.type == "paired_identifier" and _implied_paired_or_unpaired_column_header(header_column):
+            header_column.type = "paired_or_unpaired_identifier"
+        headers.append(header_column)
+
+    return headers
+
+
+def _uri_like_columns(column_headers: List[HeaderColumn]) -> List[HeaderColumn]:
+    return [c for c in column_headers if c.type == "url" or c.type == "url_deferred"]
+
+
+def _infer_fetch_workbook_collection_type(
+    column_headers: List[HeaderColumn],
+) -> Tuple[str, InferredCollectionTypeLogEntry]:
+    paired_identifier_columns = [c for c in column_headers if c.type == "paired_identifier"]
+    paired_or_unpaired_identifier_columns = [c for c in column_headers if c.type == "paired_or_unpaired_identifier"]
+    any_paired = len(paired_identifier_columns) > 0
+    uri_columns = _uri_like_columns(column_headers)
+    num_uris = len(uri_columns)
+
+    inference_on_columns: List[ParsedColumn] = []
+
+    list_type: str = ""
+    for column_header in column_headers:
+        if column_header.type == "list_identifiers":
+            inference_on_columns.append(column_header.parsed_column)
+            if list_type:
+                list_type = f"list:{list_type}"
+            else:
+                list_type = "list"
+    if any_paired or num_uris == 2:
+        if num_uris == 2:
+            inference_on_columns.append(uri_columns[0].parsed_column)
+            inference_on_columns.append(uri_columns[1].parsed_column)
+            if _implied_paired_or_unpaired_column_header(uri_columns[1]):
+                collection_type = f"{list_type}:paired_or_unpaired"
+            else:
+                collection_type = f"{list_type}:paired"
+        else:
+            paired_identifier_column = paired_identifier_columns[0]
+            inference_on_columns.append(paired_identifier_column.parsed_column)
+            if _implied_paired_or_unpaired_column_header(paired_identifier_column):
+                collection_type = f"{list_type}:paired_or_unpaired"
+            else:
+                collection_type = f"{list_type}:paired"
+    elif len(paired_or_unpaired_identifier_columns) > 0:
+        inference_on_columns.append(paired_or_unpaired_identifier_columns[0].parsed_column)
+        collection_type = f"{list_type}:paired_or_unpaired"
+    else:
+        collection_type = list_type
+    return collection_type, InferredCollectionTypeLogEntry(
+        message="Inferred collection type from column headers.",
+        from_columns=inference_on_columns,
+    )
+
+
+def _implied_paired_or_unpaired_column_header(column_header: HeaderColumn) -> bool:
+    # URI 2 - Reverse (Optional), Optional URI 2, Optional Paired Identifier all
+    # imply paired_or_unpaired lists using this logic.
+    return "optional" in column_header.title.lower()
+
+
+def _is_fetch_workbook_for_collections(column_headers: List[HeaderColumn]) -> bool:
+    return _infer_fetch_workbook_collection_type(column_headers)[0] != ""
+
+
+def _column_header_to_column_target(column_header: HeaderColumn) -> ColumnTarget:
+    return target_model_by_type(column_header.type)
diff --git a/lib/galaxy/util/rules_dsl.py b/lib/galaxy/util/rules_dsl.py
index 7657eebebc3d..516ece43c94a 100644
--- a/lib/galaxy/util/rules_dsl.py
+++ b/lib/galaxy/util/rules_dsl.py
@@ -596,6 +596,8 @@ def identifier_columns(self):
             identifier_columns.extend(mapping_as_dict["list_identifiers"]["columns"])
         if "paired_identifier" in mapping_as_dict:
             identifier_columns.append(mapping_as_dict["paired_identifier"]["columns"][0])
+        if "paired_or_unpaired_identifier" in mapping_as_dict:
+            identifier_columns.append(mapping_as_dict["paired_or_unpaired_identifier"]["columns"][0])
 
         return identifier_columns
 
@@ -609,6 +611,11 @@ def collection_type(self):
                 collection_type += ":paired"
             else:
                 collection_type = "paired"
+        if "paired_or_unpaired_identifier" in mapping_as_dict:
+            if collection_type:
+                collection_type += ":paired_or_unpaired"
+            else:
+                collection_type = "paired_or_unpaired"
         return collection_type
 
     @property
diff --git a/lib/galaxy/webapps/galaxy/api/common.py b/lib/galaxy/webapps/galaxy/api/common.py
index 44d68626fc71..228d68871ec7 100644
--- a/lib/galaxy/webapps/galaxy/api/common.py
+++ b/lib/galaxy/webapps/galaxy/api/common.py
@@ -1,5 +1,6 @@
 """This module contains utility functions shared across the api package."""
 
+from io import BytesIO
 from typing import (
     Any,
     List,
@@ -13,6 +14,7 @@
     Query,
     Request,
 )
+from starlette.responses import StreamingResponse
 from typing_extensions import Annotated
 
 from galaxy.schema import (
@@ -294,3 +296,12 @@ def parse_elements(
         return elements
 
     return parse_elements
+
+
+def serve_workbook(content: BytesIO, filename: Optional[str]) -> StreamingResponse:
+    filename = filename or "galaxy_sample_sheet_workbook.xlsx"
+    return StreamingResponse(
+        content,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": f"attachment; filename={filename}"},
+    )
diff --git a/lib/galaxy/webapps/galaxy/api/tools.py b/lib/galaxy/webapps/galaxy/api/tools.py
index 17d2e6cadab6..e3f605d91085 100644
--- a/lib/galaxy/webapps/galaxy/api/tools.py
+++ b/lib/galaxy/webapps/galaxy/api/tools.py
@@ -16,12 +16,14 @@
 from fastapi import (
     Body,
     Depends,
+    Query,
     Request,
     Response,
     UploadFile,
 )
 from fastapi.responses import FileResponse
 from starlette.datastructures import UploadFile as StarletteUploadFile
+from starlette.responses import StreamingResponse
 
 from galaxy import (
     exceptions,
@@ -33,6 +35,7 @@
 from galaxy.managers.context import ProvidesHistoryContext
 from galaxy.managers.hdas import HDAManager
 from galaxy.managers.histories import HistoryManager
+from galaxy.model.dataset_collections.workbook_util import workbook_to_bytes
 from galaxy.schema.fetch_data import (
     FetchDataFormPayload,
     FetchDataPayload,
@@ -40,6 +43,15 @@
 from galaxy.tool_util.verify import ToolTestDescriptionDict
 from galaxy.tool_util_models import UserToolSource
 from galaxy.tools.evaluation import global_tool_errors
+from galaxy.tools.fetch.workbooks import (
+    FetchWorkbookCollectionType,
+    FetchWorkbookType,
+    generate,
+    GenerateFetchWorkbookRequest,
+    parse,
+    ParsedFetchWorkbook,
+    ParseFetchWorkbook,
+)
 from galaxy.util.hash_util import (
     HashFunctionNameEnum,
     memory_bound_hexdigest,
@@ -53,6 +65,7 @@
 )
 from galaxy.webapps.base.controller import UsesVisualizationMixin
 from galaxy.webapps.base.webapp import GalaxyWebTransaction
+from galaxy.webapps.galaxy.api.common import serve_workbook
 from galaxy.webapps.galaxy.services.tools import ToolsService
 from . import (
     APIContentTypeRoute,
@@ -86,6 +99,22 @@ class PNGIconResponse(FileResponse):
     media_type = "image/png"
 
 
+FetchWorkbookTypeQueryParam: FetchWorkbookType = Query(
+    default="datasets",
+    title="Workbook Type",
+    description="Generate a workbook for simple datasets or a collection.",
+)
+FetchWorkbookCollectionTypeQueryParam: FetchWorkbookCollectionType = Query(
+    default="list",
+    title="Collection Type",
+    description="Generate workbook for specified collection type (not all collection types are supported)",
+)
+FetchWorkbookFilenameQueryParam: Optional[str] = Query(
+    None,
+    description="Filename of the workbook download to generate",
+)
+
+
 router = Router(tags=["tools"])
 
 FetchDataForm = as_form(FetchDataFormPayload)
@@ -123,6 +152,39 @@ def fetch_form(
     ):
         return self.service.create_fetch(trans, payload, files)
 
+    @router.get(
+        "/api/tools/fetch/workbook",
+        summary="Generate a template workbook to use with the activity builder UI",
+        response_class=StreamingResponse,
+        operation_id="tools__fetch_workbook_download",
+    )
+    def fetch_workbook(
+        self,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+        type: FetchWorkbookType = FetchWorkbookTypeQueryParam,
+        collection_type: FetchWorkbookCollectionType = FetchWorkbookCollectionTypeQueryParam,
+        filename: Optional[str] = FetchWorkbookFilenameQueryParam,
+    ):
+        generate_request = GenerateFetchWorkbookRequest(
+            type=type,
+            collection_type=collection_type,
+        )
+        workbook = generate(generate_request)
+        contents = workbook_to_bytes(workbook)
+        return serve_workbook(contents, filename)
+
+    @router.post(
+        "/api/tools/fetch/workbook/parse",
+        summary="Generate a template workbook to use with the activity builder UI",
+        operation_id="tools__fetch_workbook_parse",
+    )
+    def parse_workbook(
+        self,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+        payload: ParseFetchWorkbook = Body(...),
+    ) -> ParsedFetchWorkbook:
+        return parse(payload)
+
     @router.get(
         "/api/tools/{tool_id}/icon",
         summary="Get the icon image associated with a tool",
diff --git a/lib/galaxy_test/api/test_tools.py b/lib/galaxy_test/api/test_tools.py
index 2b5fbafe66b0..00a8168190d4 100644
--- a/lib/galaxy_test/api/test_tools.py
+++ b/lib/galaxy_test/api/test_tools.py
@@ -23,6 +23,7 @@
 from galaxy.util.unittest_utils import skip_if_github_down
 from galaxy_test.base import rules_test_data
 from galaxy_test.base.api_asserts import (
+    assert_file_looks_like_xlsx,
     assert_has_keys,
     assert_status_code_is,
 )
@@ -398,6 +399,10 @@ def test_model_attributes_sanitization(self):
             )
             assert sanitized_address.strip() == cool_name_without_quote
 
+    def test_fetch_workbook_generate(self):
+        workbook_path = self.dataset_populator.download_fetch_workbook()
+        assert_file_looks_like_xlsx(workbook_path)
+
     @skip_without_tool("composite_output")
     def test_test_data_filepath_security(self):
         test_data_response = self._get("tools/composite_output/test_data_path?filename=../CONTRIBUTORS.md", admin=True)
@@ -862,6 +867,54 @@ def _apply_rules_and_check(self, example: Dict[str, Any]) -> None:
             output_hdca = self.dataset_populator.get_history_collection_details(history_id, hid=output_hid, wait=False)
             example["check"](output_hdca, self.dataset_populator)
 
+    def test_apply_rules_with_error_in_mapping(self):
+        # this would produce a list:paired but the child identifiers are incorrectly spelled
+        example_with_mapping_error = {
+            "rules": {
+                "rules": [
+                    {
+                        "type": "add_column_metadata",
+                        "value": "identifier0",
+                    },
+                    {
+                        "type": "add_column_metadata",
+                        "value": "identifier1",
+                    },
+                ],
+                "mapping": [
+                    {
+                        "type": "list_identifiers",
+                        "columns": [0],
+                    },
+                    {
+                        "type": "paired_identifier",
+                        "columns": [1],
+                    },
+                ],
+            },
+            "test_data": {
+                "type": "list:list",
+                "elements": [
+                    {
+                        "identifier": "sample1",
+                        "elements": [
+                            {"identifier": "floorward", "class": "File", "contents": "TestData123forward"},
+                            {"identifier": "reverb", "class": "File", "contents": "TestData123reverse"},
+                        ],
+                    },
+                ],
+            },
+        }
+        with self.dataset_populator.test_history(require_new=False) as history_id:
+            inputs = stage_rules_example(self.galaxy_interactor, history_id, example_with_mapping_error)
+            hdca = inputs["input"]
+            inputs = {"input": {"src": "hdca", "id": hdca["id"]}, "rules": example_with_mapping_error["rules"]}
+
+            self.dataset_populator.wait_for_history(history_id)
+            response = self._run("__APPLY_RULES__", history_id, inputs, assert_ok=False)
+            assert_status_code_is(response, 400)
+            assert "Unknown indicator of paired status encountered (floorward)" in response.json()["err_msg"]
+
     def test_apply_rules_flatten_paired_unpaired(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_PAIRED_OR_UNPAIRED)
 
@@ -883,6 +936,9 @@ def test_apply_rules_5(self):
     def test_apply_rules_6(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_6)
 
+    def test_apply_rules_create_paired_or_unpaired_list(self):
+        self._apply_rules_and_check(rules_test_data.EXAMPLE_CREATE_PAIRED_OR_UNPAIRED_COLLECTION)
+
     def test_apply_rules_flatten_with_indices(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_USING_INDICES)
 
diff --git a/lib/galaxy_test/base/api_asserts.py b/lib/galaxy_test/base/api_asserts.py
index ec51a38844f2..fcc3c5c83444 100644
--- a/lib/galaxy_test/base/api_asserts.py
+++ b/lib/galaxy_test/base/api_asserts.py
@@ -113,3 +113,11 @@ def _as_dict(response: Union[Response, dict]) -> Dict[str, Any]:
 
 
 assert_has_key = assert_has_keys
+
+
+def assert_file_looks_like_xlsx(xlsx_file: str):
+    # Check the file header
+    with open(xlsx_file, "rb") as file:
+        header = file.read(4)
+        # The ZIP file signature is 0x50 0x4B 0x03 0x04
+        return header == b"\x50\x4b\x03\x04"
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index 804338757df3..4451693dfe77 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -420,8 +420,11 @@ def _get_to_tempfile(self, route, suffix=None, **kwd) -> str:
         """Perform a _get and store the result in a tempfile."""
         get_response = self._get(route, **kwd)
         get_response.raise_for_status()
+        return self._get_response_to_tempfile(get_response)
+
+    def _get_response_to_tempfile(self, response, suffix=None) -> str:
         temp_file = tempfile.NamedTemporaryFile("wb", delete=False, suffix=suffix)
-        temp_file.write(get_response.content)
+        temp_file.write(response.content)
         temp_file.flush()
         return temp_file.name
 
@@ -1108,6 +1111,12 @@ def get_remote_files(self, target: str = "ftp") -> dict:
         response.raise_for_status()
         return response.json()
 
+    def download_fetch_workbook(self) -> str:
+        url = "tools/fetch/workbook"
+        download_response = self._get(url)
+        api_asserts.assert_status_code_is_ok(download_response)
+        return self._get_response_to_tempfile(download_response)
+
     def run_tool_payload(self, tool_id: Optional[str], inputs: dict, history_id: str, **kwds) -> dict:
         # Remove files_%d|file_data parameters from inputs dict and attach
         # as __files dictionary.
diff --git a/lib/galaxy_test/base/rules_test_data.py b/lib/galaxy_test/base/rules_test_data.py
index 3eb7cea1f09d..5f2c445980af 100644
--- a/lib/galaxy_test/base/rules_test_data.py
+++ b/lib/galaxy_test/base/rules_test_data.py
@@ -348,6 +348,100 @@ def check_example_flatten_with_indices(hdca, dataset_populator):
 }
 
 
+def check_example_create_paired_or_unpaired_with_unmatched_forward_becoming_unpaired(hdca, dataset_populator):
+    assert hdca["collection_type"] == "list:paired_or_unpaired"
+    assert hdca["element_count"] == 4
+    sample1_el = hdca["elements"][0]
+    assert "object" in sample1_el, hdca
+    assert "element_identifier" in sample1_el
+    assert sample1_el["element_identifier"] == "sample1", hdca
+    child_collection_level = sample1_el["object"]
+    assert child_collection_level["collection_type"] == "paired_or_unpaired"
+    assert child_collection_level["elements"][0]["element_identifier"] == "forward", hdca
+
+    sample2_el = hdca["elements"][1]
+    assert "object" in sample2_el, hdca
+    assert "element_identifier" in sample2_el
+    assert sample2_el["element_identifier"] == "sample2", hdca
+    child_collection_level = sample2_el["object"]
+    assert child_collection_level["collection_type"] == "paired_or_unpaired"
+    assert child_collection_level["elements"][0]["element_identifier"] == "unpaired", hdca
+
+    sample3_el = hdca["elements"][2]
+    assert "object" in sample3_el, hdca
+    assert "element_identifier" in sample3_el
+    assert sample3_el["element_identifier"] == "sample3", hdca
+    child_collection_level = sample3_el["object"]
+    assert child_collection_level["collection_type"] == "paired_or_unpaired"
+    assert child_collection_level["elements"][0]["element_identifier"] == "unpaired", hdca
+
+    sample4_el = hdca["elements"][2]
+    assert "object" in sample4_el, hdca
+    assert "element_identifier" in sample4_el
+    assert sample4_el["element_identifier"] == "sample3", hdca
+    child_collection_level = sample4_el["object"]
+    assert child_collection_level["collection_type"] == "paired_or_unpaired"
+    assert child_collection_level["elements"][0]["element_identifier"] == "unpaired", hdca
+
+
+EXAMPLE_CREATE_PAIRED_OR_UNPAIRED_COLLECTION = {
+    "rules": {
+        "rules": [
+            {
+                "type": "add_column_metadata",
+                "value": "identifier0",
+            },
+            {
+                "type": "add_column_metadata",
+                "value": "identifier1",
+            },
+        ],
+        "mapping": [
+            {
+                "type": "list_identifiers",
+                "columns": [0],
+            },
+            {
+                "type": "paired_or_unpaired_identifier",
+                "columns": [1],
+            },
+        ],
+    },
+    "test_data": {
+        "type": "list:list",
+        "elements": [
+            {
+                "identifier": "sample1",
+                "elements": [
+                    {"identifier": "forward", "class": "File", "contents": "TestData123forward"},
+                    {"identifier": "reverse", "class": "File", "contents": "TestData123reverse"},
+                ],
+            },
+            {
+                "identifier": "sample2",
+                "elements": [
+                    {"identifier": "unpaired", "class": "File", "contents": "TestData123unpaired"},
+                ],
+            },
+            {
+                "identifier": "sample3",
+                "elements": [
+                    {"identifier": "u", "class": "File", "contents": "TestData123unpaired-2"},
+                ],
+            },
+            {
+                "identifier": "sample4",
+                "elements": [
+                    {"identifier": "forward", "class": "File", "contents": "TestData123unpaired-3"},
+                ],
+            },
+        ],
+    },
+    "check": check_example_create_paired_or_unpaired_with_unmatched_forward_becoming_unpaired,
+    "output_hid": 12,
+}
+
+
 def check_example_flatten_paired_or_unpaired(hdca, dataset_populator):
     assert hdca["collection_type"] == "list"
     assert hdca["element_count"] == 3
diff --git a/lib/galaxy_test/selenium/test_tool_form.py b/lib/galaxy_test/selenium/test_tool_form.py
index 79a7f0b3cae1..4d49d09523f8 100644
--- a/lib/galaxy_test/selenium/test_tool_form.py
+++ b/lib/galaxy_test/selenium/test_tool_form.py
@@ -392,6 +392,12 @@ def test_run_apply_rules_paired_unpaired_flatten(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_PAIRED_OR_UNPAIRED)
         self.screenshot("tool_apply_rules_example_flatten_paired_unpaired_final")
 
+    @selenium_test
+    @managed_history
+    def test_run_apply_rules_create_paired_or_unpaired_list(self):
+        self._apply_rules_and_check(rules_test_data.EXAMPLE_CREATE_PAIRED_OR_UNPAIRED_COLLECTION)
+        self.screenshot("tool_apply_rules_example_flatten_paired_unpaired_final")
+
     @selenium_test
     def test_run_apply_rules_flatten_with_indices(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_USING_INDICES)
diff --git a/packages/data/MANIFEST.in b/packages/data/MANIFEST.in
index e08e1a3a8206..7bf27d3257fa 100644
--- a/packages/data/MANIFEST.in
+++ b/packages/data/MANIFEST.in
@@ -3,6 +3,7 @@ include galaxy/datatypes/set_metadata_tool.xml
 include galaxy/datatypes/converters/*.xml
 graft galaxy/datatypes/display_applications/configs/
 graft galaxy/datatypes/display_applications/xsd/
+include galaxy/model/dataset_collections/rule_targets.yml
 include galaxy/model/migrations/alembic.ini
 recursive-include galaxy/model/migrations/alembic/ *.py
 include galaxy/model/migrations/README.md
diff --git a/packages/data/setup.cfg b/packages/data/setup.cfg
index e9b66834563f..8559e47fc663 100644
--- a/packages/data/setup.cfg
+++ b/packages/data/setup.cfg
@@ -49,6 +49,7 @@ install_requires =
     msal
     mrcfile
     numpy
+    openpyxl>=3.1.5
     parsley
     pycryptodome
     pydantic[email]>=2.7.4
diff --git a/pyproject.toml b/pyproject.toml
index abbcba232d7e..bcb7aa5b8684 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -62,6 +62,7 @@ dependencies = [
     "nodeenv",
     "numpy>=1.26.0",  # Python 3.12 support
     "numpy>=2.1.0 ; python_version>='3.10'",  # Python 3.13 support
+    "openpyxl>=3.1.5",  # Minimum version ever tested with
     "packaging",
     "paramiko!=2.9.0,!=2.9.1",  # https://github.com/paramiko/paramiko/issues/1961
     "Parsley",
diff --git a/test/unit/app/tools/test_fetch_workbooks.py b/test/unit/app/tools/test_fetch_workbooks.py
new file mode 100644
index 000000000000..1d4eff513d34
--- /dev/null
+++ b/test/unit/app/tools/test_fetch_workbooks.py
@@ -0,0 +1,256 @@
+import base64
+import os
+
+import pytest
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.model.dataset_collections.rule_target_models import target_models
+from galaxy.tools.fetch.workbooks import (
+    _column_titles_to_headers,
+    _infer_fetch_workbook_collection_type,
+    _read_column_header_titles,
+    _validate_parsed_column_headers,
+    DEFAULT_WORKBOOK_TITLE,
+    EXCEPTION_NO_URIS_FOUND,
+    EXCEPTION_TOO_MANY_URI_COLUMNS,
+    generate,
+    GenerateFetchWorkbookRequest,
+    parse,
+    ParseFetchWorkbook,
+)
+from galaxy.util.resources import resource_path
+
+WRITE_TEST_WORKBOOKS = False
+
+
+def test_fetch_datasets_workbook():
+    request = GenerateFetchWorkbookRequest()
+    workbook = generate(request)
+    assert workbook
+    worksheet = workbook.active
+    assert worksheet.title == DEFAULT_WORKBOOK_TITLE
+    assert worksheet.cell(1, 1).value == "URI"
+
+    header_titles = _read_column_header_titles(worksheet)
+    assert header_titles == ["URI", "Name"]
+
+    if WRITE_TEST_WORKBOOKS:
+        path = "~/fetch_workbook.xlsx"
+        expanded_path = os.path.expanduser(path)
+        workbook.save(expanded_path)
+
+
+def test_fetch_list_workbook():
+    request = GenerateFetchWorkbookRequest(
+        type="collection",
+        collection_type="list",
+    )
+    workbook = generate(request)
+    assert workbook
+    worksheet = workbook.active
+
+    header_titles = _read_column_header_titles(worksheet)
+    assert header_titles == ["URI", "List Identifier"]
+
+
+def test_fetch_multiple_lists_workbook():
+    request = GenerateFetchWorkbookRequest(
+        type="collections",
+        collection_type="list",
+    )
+    workbook = generate(request)
+    assert workbook
+    worksheet = workbook.active
+
+    header_titles = _read_column_header_titles(worksheet)
+    assert header_titles == ["URI", "List Identifier", "Collection Name"]
+
+
+def test_fetch_list_paired_workbook():
+    request = GenerateFetchWorkbookRequest(
+        type="collection",
+        collection_type="list:paired",
+    )
+    workbook = generate(request)
+    assert workbook
+    worksheet = workbook.active
+
+    header_titles = _read_column_header_titles(worksheet)
+    assert header_titles == ["URI 1 (Forward)", "URI 2 (Reverse)", "List Identifier"]
+
+    if WRITE_TEST_WORKBOOKS:
+        path = "~/fetch_workbook_paired.xlsx"
+        expanded_path = os.path.expanduser(path)
+        workbook.save(expanded_path)
+
+
+def test_fetch_list_paired_or_unpaired_workbook():
+    request = GenerateFetchWorkbookRequest(
+        type="collection",
+        collection_type="list:paired_or_unpaired",
+    )
+    workbook = generate(request)
+    assert workbook
+    worksheet = workbook.active
+
+    header_titles = _read_column_header_titles(worksheet)
+    assert header_titles == ["URI 1 (Forward)", "URI 2 (Optional/Reverse)", "List Identifier"]
+
+
+def test_parse_datasets():
+    content = unittest_file_to_base64("fetch_workbook.xlsx")
+    parse_request = ParseFetchWorkbook(
+        content=content,
+    )
+    parsed = parse(parse_request)
+    assert len(parsed.rows) == 1
+    row0 = parsed.rows[0]
+    assert row0["url"] == "https://raw.githubusercontent.com/galaxyproject/galaxy/dev/test-data/4.bed"
+    assert row0["name"] == "4.bed"
+
+    assert len(parsed.columns) == 2
+
+
+def test_parse_paired_list():
+    # workbook has URI 1 and URI 2 columns - make sure they are broken out and have a paired_indicator column
+    # for the rule builder.
+    content = unittest_file_to_base64("fetch_workbook_paired.xlsx")
+    parse_request = ParseFetchWorkbook(
+        content=content,
+    )
+    parsed = parse(parse_request)
+    assert len(parsed.rows) == 2
+    row0 = parsed.rows[0]
+    assert row0["url"] == "https://raw.githubusercontent.com/galaxyproject/galaxy/dev/test-data/1.bed"
+    assert row0["list_identifiers"] == "sample1"
+    assert row0["paired_identifier"] == "1"
+
+    row1 = parsed.rows[1]
+    assert row1["url"] == "https://raw.githubusercontent.com/galaxyproject/galaxy/dev/test-data/4.bed"
+    assert row1["list_identifiers"] == "sample1"
+    assert row1["paired_identifier"] == "2"
+
+    assert len(parsed.columns) == 3
+
+
+def test_read_column_headers_from_titles():
+    # datasets...
+    column_headers = _column_titles_to_headers(["URI", "Name", "Genome"])
+    assert len(column_headers) == 3
+    assert column_headers[0].type == "url"
+    assert column_headers[0].title == "URI"
+    assert column_headers[1].type == "name"
+    assert column_headers[1].title == "Name"
+    assert column_headers[2].type == "dbkey"
+    assert column_headers[2].title == "Genome"
+
+    # simple list...
+    column_headers = _column_titles_to_headers(["URI", "List Identifier"])
+    assert len(column_headers) == 2
+    assert column_headers[0].type == "url"
+    assert column_headers[0].title == "URI"
+    assert column_headers[1].type == "list_identifiers"
+    assert column_headers[1].title == "List Identifier"
+
+    # paired list with list two URIs per row....
+    column_headers = _column_titles_to_headers(["URI 1 (Forward)", "URI 2 (Reverse)", "List Identifier"])
+    assert len(column_headers) == 3
+    assert column_headers[0].type == "url"
+    assert column_headers[0].title == "URI 1 (Forward)"
+    assert column_headers[0].type_index == 0
+
+    assert column_headers[1].type == "url"
+    assert column_headers[1].title == "URI 2 (Reverse)"
+    assert column_headers[1].type_index == 1
+
+    assert column_headers[2].type == "list_identifiers"
+    assert column_headers[2].title == "List Identifier"
+
+    # paired list with paired identifier as a row...
+    column_headers = _column_titles_to_headers(["URI", "List Identifier", "Paired Identifier"])
+    assert len(column_headers) == 3
+    assert column_headers[0].type == "url"
+    assert column_headers[0].title == "URI"
+    assert column_headers[0].type_index == 0
+
+    assert column_headers[2].type == "paired_identifier"
+    assert column_headers[2].title == "Paired Identifier"
+    assert column_headers[2].type_index == 0
+
+    # nested list
+    column_headers = _column_titles_to_headers(["URI", "Outer List Identifier", "Inner List Identifier"])
+
+    assert len(column_headers) == 3
+    assert column_headers[0].type == "url"
+    assert column_headers[0].title == "URI"
+    assert column_headers[0].type_index == 0
+
+    assert column_headers[1].type == "list_identifiers"
+    assert column_headers[1].title == "Outer List Identifier"
+    assert column_headers[1].type_index == 0
+
+    assert column_headers[2].type == "list_identifiers"
+    assert column_headers[2].title == "Inner List Identifier"
+    assert column_headers[2].type_index == 1
+
+
+def test_infer_fetch_workbook_collection_type():
+    column_headers = _column_titles_to_headers(["URI", "List Identifier", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list"
+
+    column_headers = _column_titles_to_headers(["URI", "List Identifier 1", "List Identifier 2", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:list"
+
+    column_headers = _column_titles_to_headers(["URI", "List Identifier", "Paired Identifier", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:paired"
+
+    # probably more usable - two URI style list:paired
+    column_headers = _column_titles_to_headers(["URI 1", "URI 2", "List Identifier", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:paired"
+
+    column_headers = _column_titles_to_headers(
+        ["URI", "List Identifier 1", "List Identifier 2", "Paired Identifier", "Genome"]
+    )
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:list:paired"
+
+    column_headers = _column_titles_to_headers(["URI 1", "URI 2", "List Identifier 1", "List Identifier 2", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:list:paired"
+
+    # paired/unpaired sheets
+    column_headers = _column_titles_to_headers(["URI 1", "URI 2 (Optional)", "List Identifier", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:paired_or_unpaired"
+
+    # paired/unpaired sheets
+    column_headers = _column_titles_to_headers(["URI", "List Identifier", "Paired Identifier (Optional)", "Genome"])
+    collection_type = _infer_fetch_workbook_collection_type(column_headers)[0]
+    assert collection_type == "list:paired_or_unpaired"
+
+
+def test_column_target_model_parsing():
+    target_models()
+
+
+def test_validate_parsed_column_headers():
+    headers = _column_titles_to_headers(["URI 1", "URI 2", "URI 3"])
+    with pytest.raises(RequestParameterInvalidException) as exception_info:
+        _validate_parsed_column_headers(headers)
+    assert EXCEPTION_TOO_MANY_URI_COLUMNS in str(exception_info.value)
+
+    headers = _column_titles_to_headers(["Name", "Paired Indicator"])
+    with pytest.raises(RequestParameterInvalidException) as exception_info:
+        _validate_parsed_column_headers(headers)
+    assert EXCEPTION_NO_URIS_FOUND in str(exception_info.value)
+
+
+def unittest_file_to_base64(filename: str) -> str:
+    path = resource_path("galaxy.app_unittest_utils", filename)
+    example_as_bytes = path.read_bytes()
+    content_base64 = base64.b64encode(example_as_bytes).decode("utf-8")
+    return content_base64
diff --git a/test/unit/data/dataset_collections/test_workbook_util.py b/test/unit/data/dataset_collections/test_workbook_util.py
new file mode 100644
index 000000000000..042bcb497d32
--- /dev/null
+++ b/test/unit/data/dataset_collections/test_workbook_util.py
@@ -0,0 +1,24 @@
+import base64
+
+import pytest
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.model.dataset_collections.workbook_util import (
+    index_to_excel_column,
+    load_workbook_from_base64,
+)
+
+
+def test_index_to_excel_column():
+    assert index_to_excel_column(0) == "A"
+    assert index_to_excel_column(25) == "Z"
+    assert index_to_excel_column(26) == "AA"
+    assert index_to_excel_column(700) == "ZY"
+    assert index_to_excel_column(701) == "ZZ"
+    assert index_to_excel_column(702) == "AAA"
+
+
+def test_loading_invalid_workbook():
+    base64Tabular = base64.b64encode(b"1\t2\t3\n").decode("utf-8")
+    with pytest.raises(RequestParameterInvalidException):
+        load_workbook_from_base64(base64Tabular)
diff --git a/test/unit/data/model/test_model_discovery.py b/test/unit/data/model/test_model_discovery.py
index 50ec49440f1d..af3685669c6a 100644
--- a/test/unit/data/model/test_model_discovery.py
+++ b/test/unit/data/model/test_model_discovery.py
@@ -215,6 +215,65 @@ def test_persist_target_hdca():
         assert f.read().startswith("file 2 contents")
 
 
+def test_persist_target_list_paired():
+    work_directory = mkdtemp()
+    with open(os.path.join(work_directory, "file1.txt"), "w") as f:
+        f.write("hello world\nhello world line 2")
+    with open(os.path.join(work_directory, "file2.txt"), "w") as f:
+        f.write("file 2 contents")
+
+    target = {
+        "destination": {
+            "type": "hdca",
+        },
+        "name": "My HDCA",
+        "collection_type": "list:paired",
+        "elements": [
+            {
+                "name": "sample1",
+                "elements": [
+                    {
+                        "filename": "file1.txt",
+                        "ext": "txt",
+                        "dbkey": "hg19",
+                        "info": "dataset info",
+                        "name": "forward",
+                    },
+                    {
+                        "filename": "file2.txt",
+                        "ext": "txt",
+                        "dbkey": "hg18",
+                        "info": "dataset info 2",
+                        "name": "reverse",
+                    },
+                ],
+            }
+        ],
+    }
+
+    app = _mock_app()
+    temp_directory = mkdtemp()
+    with store.DirectoryModelExportStore(temp_directory, serialize_dataset_objects=True) as export_store:
+        persist_target_to_export_store(target, export_store, app.object_store, work_directory)
+
+    import_history = _import_directory_to_history(app, temp_directory, work_directory)
+    assert len(import_history.dataset_collections) == 1
+    assert len(import_history.datasets) == 2
+
+    import_hdca = import_history.dataset_collections[0]
+    assert import_hdca.collection.collection_type == "list:paired"
+    datasets = import_hdca.collection.elements[0].child_collection.dataset_instances
+    assert import_hdca.collection.elements[0].child_collection.collection_type == "paired"
+    assert len(datasets) == 2
+    dataset0 = datasets[0]
+    dataset1 = datasets[1]
+
+    with open(dataset0.get_file_name()) as f:
+        assert f.read().startswith("hello world\n")
+    with open(dataset1.get_file_name()) as f:
+        assert f.read().startswith("file 2 contents")
+
+
 def _assert_one_library_created(sa_session):
     all_libraries = sa_session.scalars(select(model.Library)).all()
     assert len(all_libraries) == 1, len(all_libraries)