diff --git a/client/src/api/index.ts b/client/src/api/index.ts
index 6f9ce9d0213d..798bde4aa951 100644
--- a/client/src/api/index.ts
+++ b/client/src/api/index.ts
@@ -312,4 +312,8 @@ export type ObjectExportTaskResponse = components["schemas"]["ObjectExportTaskRe
 export type ExportObjectRequestMetadata = components["schemas"]["ExportObjectRequestMetadata"];
 export type ExportObjectResultMetadata = components["schemas"]["ExportObjectResultMetadata"];
 
+export type SampleSheetColumnDefinition = components["schemas"]["SampleSheetColumnDefinitionModel"];
+export type SampleSheetColumnDefinitionType = SampleSheetColumnDefinition["type"];
+export type SampleSheetColumnDefinitions = SampleSheetColumnDefinition[] | null;
+
 export type AsyncTaskResultSummary = components["schemas"]["AsyncTaskResultSummary"];
diff --git a/client/src/components/Collections/CollectionCreatorModal.vue b/client/src/components/Collections/CollectionCreatorModal.vue
index 6bd17b96ab1e..4370f56b6863 100644
--- a/client/src/components/Collections/CollectionCreatorModal.vue
+++ b/client/src/components/Collections/CollectionCreatorModal.vue
@@ -17,6 +17,7 @@ import ListCollectionCreator from "./ListCollectionCreator.vue";
 import PairCollectionCreator from "./PairCollectionCreator.vue";
 import PairedListCollectionCreator from "./PairedListCollectionCreator.vue";
 import PairedOrUnpairedListCollectionCreator from "./PairedOrUnpairedListCollectionCreator.vue";
+import SampleSheetCollectionCreator from "./SampleSheetCollectionCreator.vue";
 import Heading from "@/components/Common/Heading.vue";
 import GenericItem from "@/components/History/Content/GenericItem.vue";
 import LoadingSpan from "@/components/LoadingSpan.vue";
@@ -323,6 +324,15 @@ function resetModal() {
             :extensions="props.extensions"
             @clicked-create="createPairedCollection"
             @on-cancel="hideModal" />
+        <SampleSheetCollectionCreator
+            v-else-if="props.collectionType === 'sample_sheet'"
+            :history-id="props.historyId"
+            :initial-elements="creatorItems || []"
+            :default-hide-source-items="props.defaultHideSourceItems"
+            :from-selection="fromSelection"
+            :extensions="props.extensions"
+            @clicked-create="createPairedCollection"
+            @on-cancel="hideModal" />
     </BModal>
 </template>
 
diff --git a/client/src/components/Collections/SampleSheetCollectionCreator.vue b/client/src/components/Collections/SampleSheetCollectionCreator.vue
new file mode 100644
index 000000000000..6a949c3f656e
--- /dev/null
+++ b/client/src/components/Collections/SampleSheetCollectionCreator.vue
@@ -0,0 +1,52 @@
+<script lang="ts" setup>
+import { useConfig } from "@/composables/config";
+
+import SampleSheetWizard from "./SampleSheetWizard.vue";
+
+const { config, isConfigLoaded } = useConfig();
+
+interface Props {
+    fileSourcesConfigured: boolean;
+    ftpUploadSite?: string;
+}
+
+defineProps<Props>();
+
+/*
+const initialElements = [
+    ["https://zenodo.org/records/3263975/files/DRR000770.fastqsanger.gz", 1, "treatment1", false],
+    ["https://zenodo.org/records/3263975/files/DRR000771.fastqsanger.gz", 2, "treatment1", false],
+    ["https://zenodo.org/records/3263975/files/DRR000772.fastqsanger.gz", 1, "none", true],
+    ["https://zenodo.org/records/3263975/files/DRR000773.fastqsanger.gz", 1, "treatment2", false],
+    ["https://zenodo.org/records/3263975/files/DRR000774.fastqsanger.gz", 2, "treatment3", false],
+];
+*/
+
+const columnDefinitions = [
+    { name: "replicate number", type: "int", description: "The replicate number of this sample." },
+    {
+        name: "treatment",
+        type: "string",
+        restrictions: ["treatment1", "treatment2", "none"],
+        description: "The treatment code for this sample.",
+    },
+    {
+        name: "is control?",
+        type: "boolean",
+        description: "Was this sample a control? If TRUE, please ensure treatment is set to none.",
+    },
+];
+</script>
+
+<template>
+    <div class="sample-sheet-collection-creator">
+        <SampleSheetWizard
+            v-if="isConfigLoaded"
+            :file-sources-configured="config.file_sources_configured"
+            :ftp-upload-site="config.ftp_upload_site"
+            :column-definitions="columnDefinitions" />
+        <!--
+        <SampleSheetGrid :initial-elements="initialElements" :columnDefinitions="columnDefinitions" />
+        -->
+    </div>
+</template>
diff --git a/client/src/components/Collections/SampleSheetWizard.vue b/client/src/components/Collections/SampleSheetWizard.vue
new file mode 100644
index 000000000000..1511041243b5
--- /dev/null
+++ b/client/src/components/Collections/SampleSheetWizard.vue
@@ -0,0 +1,139 @@
+<script setup lang="ts">
+import { BCardGroup } from "bootstrap-vue";
+import { computed, ref } from "vue";
+
+import { type SampleSheetColumnDefinitions } from "@/api";
+import { useWizard } from "@/components/Common/Wizard/useWizard";
+
+import { type RulesSourceFrom } from "./wizard/types";
+import { useFileSetSources } from "./wizard/useFileSetSources";
+
+import SampleSheetGrid from "./sheet/SampleSheetGrid.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 SourceFromDatasetAsTable from "./wizard/SourceFromDatasetAsTable.vue";
+import SourceFromPastedData from "./wizard/SourceFromPastedData.vue";
+import SourceFromRemoteFiles from "./wizard/SourceFromRemoteFiles.vue";
+import GenericWizard from "@/components/Common/Wizard/GenericWizard.vue";
+
+const isBusy = ref<boolean>(false);
+const { pasteData, tabularDatasetContents, uris, setRemoteFilesFolder, onFtp, setDatasetContents, setPasteTable } =
+    useFileSetSources(isBusy);
+
+interface Props {
+    fileSourcesConfigured: boolean;
+    ftpUploadSite?: string;
+    columnDefinitions: SampleSheetColumnDefinitions;
+}
+
+defineProps<Props>();
+
+const sourceInstructions = computed(() => {
+    return `Sample sheets can be initialized from a set or files, URIs, or existing datasets.`;
+});
+
+const sourceFrom = ref<RulesSourceFrom>("remote_files");
+
+function setSourceForm(newValue: RulesSourceFrom) {
+    sourceFrom.value = newValue;
+}
+
+const targetCollectionId = ref<string | undefined>(undefined);
+
+const wizard = useWizard({
+    "select-source": {
+        label: "Select source",
+        instructions: sourceInstructions,
+        isValid: () => true,
+        isSkippable: () => false,
+    },
+    "select-remote-files-folder": {
+        label: "Select folder",
+        instructions: "Select folder of files to import.",
+        isValid: () => sourceFrom.value === "remote_files" && Boolean(uris.value.length > 0),
+        isSkippable: () => sourceFrom.value !== "remote_files",
+    },
+    "paste-data": {
+        label: "Paste data",
+        instructions: "Paste data containing URIs and optional extra metadata.",
+        isValid: () => sourceFrom.value === "pasted_table" && pasteData.value.length > 0,
+        isSkippable: () => sourceFrom.value !== "pasted_table",
+    },
+    "select-dataset": {
+        label: "Select dataset",
+        instructions: "Select tabular dataset to load URIs and metadata from.",
+        isValid: () => sourceFrom.value === "dataset_as_table" && tabularDatasetContents.value.length > 0,
+        isSkippable: () => sourceFrom.value !== "dataset_as_table",
+    },
+    "select-collection": {
+        label: "Select collection",
+        instructions: "Select existing collection to transform into a sample sheet.",
+        isValid: () => sourceFrom.value === "collection" && Boolean(targetCollectionId.value),
+        isSkippable: () => sourceFrom.value !== "collection",
+    },
+    "fill-grid": {
+        label: "Fill sheet",
+        instructions: "Fill in metadata to describe the files you're importing.",
+        isValid: () => true,
+        isSkippable: () => false,
+    },
+});
+
+const importButtonLabel = computed(() => {
+    if (sourceFrom.value == "collection") {
+        return "Build";
+    } else {
+        return "Import";
+    }
+});
+
+const emit = defineEmits(["dismiss"]);
+
+const initialElements = computed<string[]>(() => {
+    if (sourceFrom.value == "remote_files") {
+        const rows: string[] = [];
+        for (const uri of uris.value) {
+            rows.push(uri.uri);
+        }
+        return rows;
+    }
+    return [];
+});
+
+function submit() {
+    emit("dismiss");
+}
+</script>
+
+<template>
+    <GenericWizard :use="wizard" :submit-button-label="importButtonLabel" @submit="submit">
+        <div v-if="wizard.isCurrent('select-source')">
+            <BCardGroup deck>
+                <SourceFromRemoteFiles :selected="sourceFrom === 'remote_files'" @select="setSourceForm" />
+                <SourceFromPastedData :selected="sourceFrom === 'pasted_table'" @select="setSourceForm" />
+                <SourceFromDatasetAsTable :selected="sourceFrom === 'dataset_as_table'" @select="setSourceForm" />
+                <SourceFromCollection :selected="sourceFrom === 'collection'" @select="setSourceForm" />
+            </BCardGroup>
+        </div>
+        <div v-else-if="wizard.isCurrent('paste-data')">
+            <PasteData @onChange="setPasteTable" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-remote-files-folder')">
+            <SelectFolder :ftp-upload-site="ftpUploadSite" @onChange="setRemoteFilesFolder" @onFtp="onFtp" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-dataset')">
+            <SelectDataset @onChange="setDatasetContents" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-collection')">
+            <SelectDataset @onChange="setDatasetContents" />
+        </div>
+        <div v-else-if="wizard.isCurrent('fill-grid')">
+            <SampleSheetGrid
+                :column-definitions="columnDefinitions"
+                :initial-elements="initialElements"
+                height="300px" />
+        </div>
+    </GenericWizard>
+</template>
diff --git a/client/src/components/Collections/sheet/DownloadWorkbookButton.vue b/client/src/components/Collections/sheet/DownloadWorkbookButton.vue
new file mode 100644
index 000000000000..aec1084ec9e8
--- /dev/null
+++ b/client/src/components/Collections/sheet/DownloadWorkbookButton.vue
@@ -0,0 +1,22 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faFileExcel } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BButton } from "bootstrap-vue";
+
+library.add(faFileExcel);
+
+interface Props {
+    title: string;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits(["click"]);
+</script>
+
+<template>
+    <BButton :title="title" role="button" variant="link" size="sm" class="ml-0" @click="emit('click')">
+        <FontAwesomeIcon icon="file-excel" />
+    </BButton>
+</template>
diff --git a/client/src/components/Collections/sheet/SampleSheetGrid.vue b/client/src/components/Collections/sheet/SampleSheetGrid.vue
new file mode 100644
index 000000000000..22ef1f33caf5
--- /dev/null
+++ b/client/src/components/Collections/sheet/SampleSheetGrid.vue
@@ -0,0 +1,247 @@
+<script lang="ts" setup>
+import { type ColDef, type ValueSetterParams } from "ag-grid-community";
+import { BLink } from "bootstrap-vue";
+import { computed, ref } from "vue";
+
+import { GalaxyApi, type SampleSheetColumnDefinition, type SampleSheetColumnDefinitions } from "@/api";
+import { downloadWorkbook, initialValue } from "@/components/Collections/sheet/workbooks";
+import { useAgGrid } from "@/composables/useAgGrid";
+
+type RemoteFiles = string[];
+type InitialElements = RemoteFiles;
+
+interface Props {
+    columnDefinitions: SampleSheetColumnDefinitions;
+    initialElements: InitialElements;
+    height?: string;
+    width?: string;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    height: "500px",
+    width: "576px",
+});
+
+function initializeRowData(rowData: Record<string, unknown>[]) {
+    for (const initialElement of props.initialElements) {
+        const row: Record<string, unknown> = { uri: initialElement };
+        (props.columnDefinitions || []).forEach((colDef) => {
+            row[colDef.name] = initialValue(colDef);
+        });
+        rowData.push(row);
+    }
+}
+
+const rowData = ref<Record<string, unknown>[]>([]);
+
+function initialize() {
+    rowData.value.splice(0, rowData.value.length);
+    initializeRowData(rowData.value);
+}
+
+// Example Row Data
+// const rowData = ref([{ "replicate number": 1, treatment: "treatment1", "is control?": true }]);
+
+const { gridApi, AgGridVue, onGridReady, theme } = useAgGrid(resize);
+
+function resize() {
+    if (gridApi.value) {
+        gridApi.value.sizeColumnsToFit();
+    }
+}
+
+function validate(value: string, columnDefinition: SampleSheetColumnDefinition): boolean {
+    if (columnDefinition.restrictions && !columnDefinition.restrictions.includes(value)) {
+        return false; // Invalid if not in restrictions
+    }
+
+    switch (columnDefinition.type) {
+        case "int":
+            return Number.isInteger(Number(value));
+        case "float":
+            return !isNaN(parseFloat(value));
+        case "boolean":
+            return value === "true" || value === "false";
+        case "string":
+        default:
+            return true;
+    }
+}
+
+function valueSetter(params: ValueSetterParams, columnDefinition: SampleSheetColumnDefinition): boolean {
+    const value = params.newValue;
+    if (validate(value, columnDefinition)) {
+        params.data[params.colDef.field!] = value;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+// Generate Column Definitions from Schema
+function generateGridColumnDefs(columnDefinitions: SampleSheetColumnDefinitions): ColDef[] {
+    const columns = [uriColumn()];
+    (columnDefinitions || []).forEach((colDef) => {
+        const baseDef: ColDef = {
+            headerName: colDef.name,
+            field: colDef.name,
+            editable: true,
+            cellEditorParams: {},
+            valueSetter: (params) => {
+                return valueSetter(params, colDef);
+            },
+        };
+
+        // Restrictions: Add dropdown editor for string type with restrictions
+        if (colDef.restrictions && colDef.type === "string") {
+            baseDef.cellEditor = "agSelectCellEditor";
+            baseDef.cellEditorParams = {
+                values: colDef.restrictions,
+            };
+        }
+        // Validators
+        baseDef.cellEditorParams.validate = (value: string) => validate(value, colDef);
+        columns.push(baseDef);
+    });
+    return columns;
+}
+
+function uriColumn(): ColDef {
+    const baseDef: ColDef = {
+        headerName: "URI",
+        field: "uri",
+        editable: false,
+        cellEditorParams: {},
+    };
+    return baseDef;
+}
+
+// Column Definitions
+const columnDefs = computed(() => {
+    return generateGridColumnDefs(props.columnDefinitions);
+});
+
+// Default Column Properties
+const defaultColDef = ref<ColDef>({
+    editable: true,
+    sortable: true,
+    filter: true,
+    resizable: true,
+});
+
+const style = computed(() => {
+    return { width: props.width, height: props.height };
+});
+
+const isDragging = ref(false);
+const isProcessingUpload = ref(false);
+const uploadErrorMessage = ref<string | undefined>(undefined);
+
+type ParsedRowT = { [key: string]: string | number | boolean };
+type ParsedRowsT = ParsedRowT[];
+
+function handleUploadedData(rows: ParsedRowsT) {
+    const currentRowData = rowData.value;
+    for (const index in rows) {
+        const row = rows[index];
+        if (row) {
+            for (const columnDefinition of props.columnDefinitions || []) {
+                const updatedValue = row[columnDefinition.name];
+                if (updatedValue !== undefined) {
+                    const currentRow = currentRowData[index];
+                    if (currentRow) {
+                        currentRow[columnDefinition.name] = updatedValue;
+                    }
+                }
+            }
+        }
+    }
+    if (gridApi.value) {
+        const params = {
+            force: true,
+            suppressFlash: true,
+        };
+        gridApi.value!.refreshCells(params);
+    }
+}
+
+const handleDrop = async (event: DragEvent) => {
+    const file = event.dataTransfer?.files[0];
+    if (!file || !file.name.endsWith(".xlsx")) {
+        uploadErrorMessage.value = "Please drop a valid XLSX file.";
+        return;
+    }
+
+    isDragging.value = false;
+    isProcessingUpload.value = true;
+
+    try {
+        // Read and base64 encode the file
+        const fileContent = await fileToBase64(file);
+        const base64Content = fileContent.split(",")[1] as string;
+        const parseBody = {
+            column_definitions: props.columnDefinitions || [],
+            content: base64Content,
+        };
+        const { data, error } = await GalaxyApi().POST("/api/sample_sheet_workbook/parse", {
+            body: parseBody,
+        });
+        if (data) {
+            console.log("handling...");
+            handleUploadedData(data.rows);
+        } else {
+            console.log("IN ERRROR!!!");
+            console.log(error);
+            uploadErrorMessage.value = "There was an error processing the file.";
+        }
+    } catch (error) {
+        console.error("Error uploading file:", error);
+        uploadErrorMessage.value = "There was an error processing the file.";
+    } finally {
+        isProcessingUpload.value = false;
+    }
+};
+
+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);
+    });
+
+const rootClasses = computed(() => {
+    const classes: string[] = [theme, "dropzone"];
+    if (isDragging.value) {
+        classes.push("highlight");
+    }
+    return classes;
+});
+
+function downloadSeededWorkbook() {
+    const initialRows = [];
+    for (const initialItem of props.initialElements) {
+        initialRows.push([initialItem]);
+    }
+    downloadWorkbook(props.columnDefinitions, initialRows);
+}
+
+initialize();
+</script>
+
+<template>
+    <div
+        :class="rootClasses"
+        :style="style"
+        @drop.prevent="handleDrop"
+        @dragover.prevent="isDragging = true"
+        @dragleave.prevent="isDragging = false">
+        <AgGridVue
+            :row-data="rowData"
+            :column-defs="columnDefs"
+            :default-col-def="defaultColDef"
+            :style="style"
+            @gridReady="onGridReady" />
+        <BLink @click="downloadSeededWorkbook">Download this as spreadsheet and fill it in outside of Galaxy.</BLink>
+    </div>
+</template>
diff --git a/client/src/components/Collections/sheet/workbooks.ts b/client/src/components/Collections/sheet/workbooks.ts
new file mode 100644
index 000000000000..021a77c5ff29
--- /dev/null
+++ b/client/src/components/Collections/sheet/workbooks.ts
@@ -0,0 +1,33 @@
+import { type SampleSheetColumnDefinition, type SampleSheetColumnDefinitions } from "@/api";
+import { withPrefix } from "@/utils/redirect";
+
+export function getDownloadWorkbookUrl(columnDefinitions: SampleSheetColumnDefinitions, initialRows?: string[][]) {
+    const columnDefinitionsJson = JSON.stringify(columnDefinitions);
+    const columnDefinitionsJsonBase64 = Buffer.from(columnDefinitionsJson).toString("base64");
+    let url = withPrefix(`/api/sample_sheet_workbook/generate?column_definitions=${columnDefinitionsJsonBase64}`);
+    if (initialRows) {
+        const initialRowsJson = JSON.stringify(initialRows);
+        const initialRowsJsonBase64 = Buffer.from(initialRowsJson).toString("base64");
+        url = `${url}&initial_rows=${initialRowsJsonBase64}`;
+    }
+    return url;
+}
+
+export function downloadWorkbook(columnDefinitions: SampleSheetColumnDefinitions, initialRows?: string[][]) {
+    const url = getDownloadWorkbookUrl(columnDefinitions, initialRows);
+    window.location.assign(url);
+}
+
+export function initialValue(columnDefinition: SampleSheetColumnDefinition) {
+    switch (columnDefinition.type) {
+        case "int":
+            return 0;
+        case "float":
+            return 0.0;
+        case "boolean":
+            return false;
+        case "string":
+        default:
+            return "";
+    }
+}
diff --git a/client/src/components/Form/Elements/FormData/FormData.vue b/client/src/components/Form/Elements/FormData/FormData.vue
index b13dd87ae8e9..80663d75aae7 100644
--- a/client/src/components/Form/Elements/FormData/FormData.vue
+++ b/client/src/components/Form/Elements/FormData/FormData.vue
@@ -33,6 +33,7 @@ const COLLECTION_TYPE_TO_LABEL: Record<string, string> = {
     list: "list",
     "list:paired": "list of dataset pairs",
     paired: "dataset pair",
+    sample_sheet: "sample sheet derived",
 };
 
 type SelectOption = {
@@ -88,7 +89,7 @@ const dragTarget: Ref<EventTarget | null> = ref(null);
 
 // Collection creator modal settings
 const collectionModalShow = ref(false);
-const collectionModalType = ref<"list" | "list:paired" | "paired">("list");
+const collectionModalType = ref<"list" | "list:paired" | "paired" | "sample_sheet">("list");
 const { currentHistoryId } = storeToRefs(useHistoryStore());
 const restrictsExtensions = computed(() => {
     const extensions = props.extensions;
@@ -497,7 +498,7 @@ function canAcceptSrc(historyContentType: "dataset" | "dataset_collection", coll
     }
 }
 
-const collectionTypesWithBuilders = ["list", "list:paired", "paired"];
+const collectionTypesWithBuilders = ["list", "list:paired", "paired", "list:paired_or_unpaired", "sample_sheet"];
 
 /** Allowed collection types for collection creation */
 const effectiveCollectionTypes = props.collectionTypes?.filter((collectionType) =>
@@ -508,7 +509,7 @@ function buildNewCollection(collectionType: string) {
     if (!collectionTypesWithBuilders.includes(collectionType)) {
         throw Error(`Unknown collection type: ${collectionType}`);
     }
-    collectionModalType.value = collectionType as "list" | "list:paired" | "paired";
+    collectionModalType.value = collectionType as "list" | "list:paired" | "paired" | "sample_sheet";
     collectionModalShow.value = true;
 }
 
diff --git a/client/src/components/History/adapters/buildCollectionModal.ts b/client/src/components/History/adapters/buildCollectionModal.ts
index cf1b24ba8ebe..35225d2cbbc9 100644
--- a/client/src/components/History/adapters/buildCollectionModal.ts
+++ b/client/src/components/History/adapters/buildCollectionModal.ts
@@ -14,8 +14,7 @@ import jQuery from "jquery";
 import type { HDASummary, HistoryItemSummary } from "@/api";
 import RULE_BASED_COLLECTION_CREATOR from "@/components/Collections/RuleBasedCollectionCreatorModal";
 
-export type CollectionType = "list" | "paired" | "list:paired" | "rules";
-
+export type CollectionType = "list" | "paired" | "list:paired" | "rules" | "list:paired_or_unpaired" | "sample_sheet";
 interface HasName {
     name: string | null;
 }
diff --git a/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
index a93cb5ded6f1..77b5aa8161f2 100644
--- a/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
+++ b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
@@ -23,6 +23,7 @@ const collectionTypeOptions = [
     { value: "list", label: "List of Datasets" },
     { value: "paired", label: "Dataset Pair" },
     { value: "list:paired", label: "List of Dataset Pairs" },
+    { value: "sample_sheet", label: "Sample Sheet of Datasets" },
 ];
 
 function updateValue(newValue: string | undefined) {
diff --git a/client/src/components/Workflow/Editor/Forms/FormColumnDefinition.vue b/client/src/components/Workflow/Editor/Forms/FormColumnDefinition.vue
new file mode 100644
index 000000000000..0068bacbadbf
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormColumnDefinition.vue
@@ -0,0 +1,235 @@
+<script setup lang="ts">
+import { BFormCheckbox } from "bootstrap-vue";
+import { computed, ref, watch } from "vue";
+
+import { type SampleSheetColumnDefinition, type SampleSheetColumnDefinitionType } from "@/api";
+
+import FormColumnDefinitionType from "./FormColumnDefinitionType.vue";
+import FormElement from "@/components/Form/FormElement.vue";
+
+interface Props {
+    value: SampleSheetColumnDefinition;
+    index: number;
+    prefix: string; // prefix for ID objects
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits(["onChange"]);
+
+function stateCopy(): SampleSheetColumnDefinition {
+    return JSON.parse(JSON.stringify(props.value));
+}
+
+function onName(name: string) {
+    const state = stateCopy();
+    state.name = name;
+    emit("onChange", state, props.index);
+}
+
+function onType(newType: SampleSheetColumnDefinitionType) {
+    const state = stateCopy();
+
+    state.type = newType;
+    if (isOptional.value && newType != "string") {
+        state.default_value = null;
+    } else {
+        state.default_value = _defaultByType(newType);
+    }
+    emit("onChange", state, props.index);
+}
+
+function onRestrictions(restrictionsAsText: string) {
+    const state = stateCopy();
+    state.suggestions = null;
+    state.restrictions = parseCommaSeparatedValues(restrictionsAsText);
+    emit("onChange", state, props.index);
+}
+
+function onSuggestions(restrictionsAsText: string) {
+    const state = stateCopy();
+    state.restrictions = null;
+    state.suggestions = parseCommaSeparatedValues(restrictionsAsText);
+    emit("onChange", state, props.index);
+}
+
+type EnumerateType = "staticRestrictions" | "staticSuggestions" | "none";
+
+const initialEnumerateType = computed<EnumerateType>(() => {
+    if (props.value.restrictions) {
+        return "staticRestrictions";
+    } else if (props.value.suggestions) {
+        return "staticSuggestions";
+    } else {
+        return "none";
+    }
+});
+
+const showOptional = computed(() => {
+    return props.value.type !== "string";
+});
+
+const isOptional = computed(() => {
+    return props.value.default_value == null;
+});
+
+// Modeled after language and values from workflow/modules.py for step parameters.
+const enumerateTypes = [
+    {
+        value: "none",
+        label: "Do not specify restrictions (default).",
+    },
+    {
+        value: "staticRestrictions",
+        label: "Provide list of all possible values.",
+    },
+    {
+        value: "staticSuggestions",
+        label: "Provide list of suggested values.",
+    },
+];
+const enumerateType = ref<EnumerateType>(initialEnumerateType.value);
+
+function onEnumerateType(newEnumerateType: EnumerateType) {
+    enumerateType.value = newEnumerateType;
+}
+
+function parseCommaSeparatedValues(input: string): string[] {
+    return input
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item !== "");
+}
+
+function asString(value: (string | number | boolean)[] | null | undefined): string {
+    if (value) {
+        return value.map((item) => item.toString()).join(",");
+    } else {
+        return "";
+    }
+}
+
+const restrictionsAsString = computed(() => {
+    return asString(props.value.restrictions);
+});
+
+const suggestionsAsString = computed(() => {
+    return asString(props.value.suggestions);
+});
+
+function _defaultByType(valueType_: string | undefined = undefined) {
+    const valueType = valueType_ || props.value.type;
+    if (valueType == "string") {
+        return defaultString.value;
+    } else if (valueType == "int") {
+        return defaultInt.value;
+    } else if (valueType == "float") {
+        return defaultFloat.value;
+    } else if (valueType == "boolean") {
+        return defaultBoolean.value;
+    } else {
+        return "";
+    }
+}
+
+function setIsOptional(isOptional: boolean) {
+    console.log(isOptional);
+    console.log("^ isOptional");
+    const state = stateCopy();
+    if (isOptional) {
+        state.default_value = null;
+    } else {
+        state.default_value = _defaultByType();
+    }
+    emit("onChange", state, props.index);
+}
+
+function setDefaultByType() {
+    const state = stateCopy();
+    state.default_value = _defaultByType();
+    emit("onChange", state, props.index);
+}
+
+const defaultInt = ref(0);
+const defaultFloat = ref(0.0);
+const defaultBoolean = ref(false);
+const defaultString = ref("");
+
+watch(defaultInt, setDefaultByType);
+watch(defaultFloat, setDefaultByType);
+watch(defaultBoolean, setDefaultByType);
+watch(defaultString, setDefaultByType);
+</script>
+
+<template>
+    <div>
+        <FormElement
+            :id="prefix + '_name'"
+            :value="value.name"
+            title="Name"
+            type="text"
+            help="Provide a short, unique name to describe this column."
+            @input="onName" />
+        <FormColumnDefinitionType :value="value.type" :prefix="prefix" @onChange="onType" />
+        <FormElement
+            :id="prefix + '_description'"
+            :value="value.description"
+            title="Description"
+            type="text"
+            help="Provide a longer description to help people running this workflow under what is expected to be entered in this column."
+            @input="onName" />
+        <FormElement
+            :id="prefix + '_enumerate_type'"
+            :value="enumerateType"
+            :attributes="{ data: enumerateTypes }"
+            title="Restrict or Suggest Text Values?"
+            :optional="false"
+            type="select"
+            @input="onEnumerateType" />
+        <FormElement
+            v-if="enumerateType == 'staticRestrictions'"
+            :id="prefix + '_restrictions'"
+            :value="restrictionsAsString"
+            title="Restricted Values"
+            type="text"
+            help="Comma-separated list of all permitted values"
+            @input="onRestrictions" />
+        <FormElement
+            v-if="enumerateType == 'staticSuggestions'"
+            :id="prefix + '_suggestions'"
+            :value="suggestionsAsString"
+            title="Suggested Values"
+            type="text"
+            help="Comma-separated list of all suggested values"
+            @input="onSuggestions" />
+        <div class="ui-form-title">
+            <span class="ui-form-title-text"> Default Value </span>
+        </div>
+        <BFormCheckbox v-if="showOptional" :id="prefix + '_optional'" :checked="isOptional" @input="setIsOptional">
+            Is this input optional? If not you must specify a default value.
+        </BFormCheckbox>
+        <FormElement
+            v-if="!isOptional && value.type == 'int'"
+            :id="prefix + '_default_value_int'"
+            v-model="defaultInt"
+            type="integer" />
+        <FormElement
+            v-if="!isOptional && value.type == 'float'"
+            :id="prefix + '_default_value_float'"
+            v-model="defaultFloat"
+            type="float" />
+        <FormElement
+            v-if="!isOptional && value.type == 'string'"
+            :id="prefix + '_default_value_string'"
+            v-model="defaultString"
+            type="string" />
+
+        TODO: There are more fields to enter here including validations that vary based on the type chosen. There will
+        be a lot of overlap with the same validation options for workflow parameters so it might be best to wait until
+        those components can be developed in parallel.
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "@/components/Form/_form-elements.scss";
+</style>
diff --git a/client/src/components/Workflow/Editor/Forms/FormColumnDefinitionType.vue b/client/src/components/Workflow/Editor/Forms/FormColumnDefinitionType.vue
new file mode 100644
index 000000000000..c8ec62eb08d1
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormColumnDefinitionType.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+
+import { type SampleSheetColumnDefinitionType } from "@/api";
+
+import FormElement from "@/components/Form/FormElement.vue";
+
+interface Props {
+    value: SampleSheetColumnDefinitionType;
+    prefix: string;
+}
+
+const props = defineProps<Props>();
+
+const currentValue = ref<SampleSheetColumnDefinitionType>(props.value);
+
+function onInput(newType: SampleSheetColumnDefinitionType) {
+    emit("onChange", newType);
+}
+
+function updateValue(newValue: SampleSheetColumnDefinitionType) {
+    currentValue.value = newValue;
+}
+
+// workflow/modules.py uses:
+// {"value": "text", "label": "Text"},
+// {"value": "integer", "label": "Integer"},
+// {"value": "float", "label": "Float"},
+// {"value": "boolean", "label": "Boolean (True or False)"},
+const columnTypes = [
+    { value: "string", label: "Text" },
+    { value: "int", label: "Integer" },
+    { value: "float", label: "Float" },
+    { value: "boolean", label: "Boolean (True or False)" },
+];
+
+watch(() => props.value, updateValue, { immediate: true });
+const emit = defineEmits(["onChange"]);
+</script>
+
+<template>
+    <div>
+        <FormElement
+            :id="prefix + '_type'"
+            :value="currentValue"
+            :attributes="{ data: columnTypes }"
+            title="Column type"
+            :optional="false"
+            type="select"
+            @input="onInput" />
+    </div>
+</template>
diff --git a/client/src/components/Workflow/Editor/Forms/FormColumnDefinitions.vue b/client/src/components/Workflow/Editor/Forms/FormColumnDefinitions.vue
new file mode 100644
index 000000000000..5512a4d56f79
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormColumnDefinitions.vue
@@ -0,0 +1,157 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown, faCaretUp, faPlus, faTrashAlt } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BLink } from "bootstrap-vue";
+import { computed } from "vue";
+
+import { type SampleSheetColumnDefinition, type SampleSheetColumnDefinitions } from "@/api";
+import { downloadWorkbook } from "@/components/Collections/sheet/workbooks";
+import localize from "@/utils/localization";
+
+import FormColumnDefinition from "./FormColumnDefinition.vue";
+import DownloadWorkbookButton from "@/components/Collections/sheet/DownloadWorkbookButton.vue";
+import FormCard from "@/components/Form/FormCard.vue";
+
+library.add(faPlus, faTrashAlt, faCaretUp, faCaretDown);
+
+interface Props {
+    value: SampleSheetColumnDefinitions;
+}
+
+const props = defineProps<Props>();
+
+function addColumn() {
+    const state = stateCopy();
+    state.push({ type: "int", name: "column" });
+    emit("onChange", state);
+}
+
+function stateCopy(): SampleSheetColumnDefinition[] {
+    return JSON.parse(JSON.stringify(props.value || []));
+}
+
+function onRemove(index: number) {
+    const state = stateCopy();
+    state.splice(index, 1);
+    emit("onChange", state);
+}
+
+function titleForColumnDefinition(index: number) {
+    return `Column ${index + 1}`;
+}
+
+function getPrefix(index: number) {
+    const name = `column_definition_${index}`;
+    return name;
+}
+
+function getButtonId(index: number, direction: "up" | "down") {
+    const prefix = getPrefix(index);
+    return `${prefix}_${direction}`;
+}
+
+function swap(index: number, swapWith: number, direction: "up" | "down") {
+    // the FormRepeat version does cool highlighting - probably worth implementing
+    // on next pass
+    const state = stateCopy();
+    if (swapWith >= 0 && swapWith < state.length && index >= 0 && index < state.length) {
+        const wasSwapped = state[swapWith] as SampleSheetColumnDefinition;
+        state[swapWith] = state[index] as SampleSheetColumnDefinition;
+        state[index] = wasSwapped;
+    }
+    emit("onChange", state);
+}
+
+function onChildUpdate(childState: SampleSheetColumnDefinition, index: number) {
+    const state = stateCopy();
+    state[index] = childState;
+    emit("onChange", state);
+}
+
+const deleteTooltip = computed(() => {
+    return localize(`Click to delete column definition`);
+});
+
+const saveTooltip = computed(() => {
+    return localize(`Click to download an example workbook (xlsx file) for these columns`);
+});
+
+const emit = defineEmits(["onChange"]);
+</script>
+
+<template>
+    <div class="ui-form-element section-row">
+        <div class="ui-form-title">
+            <span class="ui-form-title-text">Column definitions</span>
+            <span v-b-tooltip.hover.bottom :title="saveTooltip">
+                <DownloadWorkbookButton title="download example workbook" @click="downloadWorkbook(value)" />
+            </span>
+        </div>
+        <FormCard
+            v-for="(columnDefinition, index) in value"
+            v-bind:key="index"
+            data-description="column definition block"
+            class="card"
+            :title="titleForColumnDefinition(index)">
+            <template v-slot:operations>
+                <!-- code modelled after FormRepeat -->
+                <span class="float-right">
+                    <b-button-group>
+                        <b-button
+                            :id="getButtonId(index, 'up')"
+                            v-b-tooltip.hover.bottom
+                            title="move up"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => swap(index, index - 1, 'up')">
+                            <FontAwesomeIcon icon="caret-up" />
+                        </b-button>
+                        <b-button
+                            :id="getButtonId(index, 'down')"
+                            v-b-tooltip.hover.bottom
+                            title="move down"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => swap(index, index + 1, 'down')">
+                            <FontAwesomeIcon icon="caret-down" />
+                        </b-button>
+                    </b-button-group>
+
+                    <span v-b-tooltip.hover.bottom :title="deleteTooltip">
+                        <b-button
+                            title="delete"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => onRemove(index)">
+                            <FontAwesomeIcon icon="trash-alt" />
+                        </b-button>
+                    </span>
+                </span>
+            </template>
+            <template v-slot:body>
+                <FormColumnDefinition
+                    :index="index"
+                    :value="columnDefinition"
+                    :prefix="getPrefix(index)"
+                    @onChange="onChildUpdate" />
+            </template>
+        </FormCard>
+        <BLink @click="addColumn">Add column.</BLink>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "../../../Form/_form-elements.scss";
+
+.column-definition-list {
+    padding: 0px;
+    list-style-type: none;
+}
+</style>
diff --git a/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue b/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue
index ea17f09fb50d..ef5379b0e0d1 100644
--- a/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue
+++ b/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue
@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { computed, toRef } from "vue";
 
+import { type SampleSheetColumnDefinitions } from "@/api";
 import type { DatatypesMapperModel } from "@/components/Datatypes/model";
 import type { Step } from "@/stores/workflowStepStore";
 
@@ -8,6 +9,7 @@ import { useToolState } from "../composables/useToolState";
 
 import FormElement from "@/components/Form/FormElement.vue";
 import FormCollectionType from "@/components/Workflow/Editor/Forms/FormCollectionType.vue";
+import FormColumnDefinitions from "@/components/Workflow/Editor/Forms/FormColumnDefinitions.vue";
 import FormDatatype from "@/components/Workflow/Editor/Forms/FormDatatype.vue";
 
 interface ToolState {
@@ -15,6 +17,7 @@ interface ToolState {
     optional: boolean;
     format: string | null;
     tag: string | null;
+    column_definitions: SampleSheetColumnDefinitions;
 }
 
 const props = defineProps<{
@@ -34,6 +37,7 @@ function cleanToolState(): ToolState {
             optional: false,
             tag: null,
             format: null,
+            column_definitions: null,
         };
     }
 }
@@ -64,6 +68,13 @@ function onCollectionType(newCollectionType: string | null) {
     emit("onChange", state);
 }
 
+function onColumnDefinitions(newColumnDefinitions: SampleSheetColumnDefinitions) {
+    const state = cleanToolState();
+    console.log(newColumnDefinitions);
+    state.column_definitions = newColumnDefinitions;
+    emit("onChange", state);
+}
+
 const formatsAsList = computed(() => {
     const formatStr = toolState.value?.format as string | string[] | null;
     if (formatStr && typeof formatStr === "string") {
@@ -100,5 +111,9 @@ emit("onChange", cleanToolState());
             type="text"
             help="Tags to automatically filter inputs"
             @input="onTags" />
+        <FormColumnDefinitions
+            v-if="toolState?.collection_type == 'sample_sheet'"
+            :value="toolState?.column_definitions"
+            @onChange="onColumnDefinitions" />
     </div>
 </template>
diff --git a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
index cc48c2a69117..8012d2f2aefa 100644
--- a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
+++ b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
@@ -129,7 +129,7 @@ export class CollectionTypeDescription implements CollectionTypeDescriptor {
     }
 }
 
-const collectionTypeRegex = /^(list|paired)(:(list|paired))*$/;
+const collectionTypeRegex = /^((list|paired)(:(list|paired))*|sample_sheet)$/;
 
 export function isValidCollectionTypeStr(collectionType: string | undefined) {
     if (collectionType) {
diff --git a/client/src/stores/workflowStepStore.ts b/client/src/stores/workflowStepStore.ts
index dcb0547c9d7b..f0ff7109352f 100644
--- a/client/src/stores/workflowStepStore.ts
+++ b/client/src/stores/workflowStepStore.ts
@@ -1,5 +1,6 @@
 import { computed, del, ref, set } from "vue";
 
+import { type SampleSheetColumnDefinitions } from "@/api";
 import { type CollectionTypeDescriptor } from "@/components/Workflow/Editor/modules/collectionTypeDescription";
 import { type Connection, getConnectionId, useConnectionStore } from "@/stores/workflowConnectionStore";
 import { assertDefined } from "@/utils/assertions";
@@ -71,6 +72,7 @@ export interface DataStepInput extends BaseStepInput {
 export interface DataCollectionStepInput extends BaseStepInput {
     input_type: "dataset_collection";
     collection_types: string[];
+    column_definitions: SampleSheetColumnDefinitions;
 }
 
 export interface ParameterStepInput extends Omit<BaseStepInput, "input_type"> {
diff --git a/lib/galaxy/managers/collections.py b/lib/galaxy/managers/collections.py
index e9042e3aac55..dfe6863d9b38 100644
--- a/lib/galaxy/managers/collections.py
+++ b/lib/galaxy/managers/collections.py
@@ -176,6 +176,8 @@ def create(
         completed_job=None,
         output_name=None,
         fields=None,
+        column_definitions=None,
+        rows=None,
     ):
         """
         PRECONDITION: security checks on ability to add to parent
@@ -201,6 +203,8 @@ def create(
                 copy_elements=copy_elements,
                 history=history,
                 fields=fields,
+                column_definitions=column_definitions,
+                rows=rows,
             )
 
         implicit_inputs = []
@@ -288,6 +292,8 @@ def create_dataset_collection(
         copy_elements=False,
         history=None,
         fields=None,
+        column_definitions=None,
+        rows=None,
     ):
         # Make sure at least one of these is None.
         assert element_identifiers is None or elements is None
@@ -324,9 +330,12 @@ def create_dataset_collection(
 
         if elements is not self.ELEMENTS_UNINITIALIZED:
             type_plugin = collection_type_description.rank_type_plugin()
-            dataset_collection = builder.build_collection(type_plugin, elements, fields=fields)
+            dataset_collection = builder.build_collection(
+                type_plugin, elements, fields=fields, column_definitions=column_definitions, rows=rows
+            )
         else:
             # TODO: Pass fields here - need test case first.
+            # TODO: same with column definitions I think.
             dataset_collection = model.DatasetCollection(populated=False)
         dataset_collection.collection_type = collection_type
         return dataset_collection
@@ -783,10 +792,16 @@ def __init_rule_data(self, elements, collection_type_description, parent_identif
             identifiers = parent_identifiers + [element.element_identifier]
             if not element.is_collection:
                 data.append([])
+                columns = None
+                collection_type_str = collection_type_description.collection_type
+                if collection_type_str == "sample_sheet":
+                    columns = element.columns
+                    assert isinstance(columns, list)
                 source = {
                     "identifiers": identifiers,
                     "dataset": element_object,
                     "tags": element_object.make_tag_string_list(),
+                    "columns": columns,
                 }
                 sources.append(source)
             else:
diff --git a/lib/galaxy/managers/collections_util.py b/lib/galaxy/managers/collections_util.py
index 7f129992c754..8fbef8ed3a20 100644
--- a/lib/galaxy/managers/collections_util.py
+++ b/lib/galaxy/managers/collections_util.py
@@ -9,6 +9,7 @@
     exceptions,
     model,
 )
+from galaxy.model.dataset_collections.types.sample_sheet_util import validate_column_definitions
 from galaxy.util import string_as_bool
 
 log = logging.getLogger(__name__)
@@ -33,6 +34,9 @@ def api_payload_to_create_params(payload):
         message = f"Missing required parameters {missing_parameters}"
         raise exceptions.ObjectAttributeMissingException(message)
 
+    column_definitions = payload.get("column_definitions", None)
+    validate_column_definitions(column_definitions)
+
     params = dict(
         collection_type=payload.get("collection_type"),
         element_identifiers=payload.get("element_identifiers"),
@@ -40,6 +44,8 @@ def api_payload_to_create_params(payload):
         hide_source_items=string_as_bool(payload.get("hide_source_items", False)),
         copy_elements=string_as_bool(payload.get("copy_elements", False)),
         fields=payload.get("fields", None),
+        column_definitions=column_definitions,
+        rows=payload.get("rows", None),
     )
     return params
 
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index fb65c01516fb..329415db0d24 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -181,6 +181,8 @@
     DatasetValidatedState,
     InvocationsStateCounts,
     JobState,
+    SampleSheetColumnDefinitions,
+    SampleSheetRow,
     ToolRequestState,
 )
 from galaxy.schema.workflow.comments import WorkflowCommentModel
@@ -260,6 +262,7 @@ class ConfigurationTemplateEnvironmentVariable(TypedDict):
 CONFIGURATION_TEMPLATE_CONFIGURATION_VARIABLES_TYPE = Dict[str, CONFIGURATION_TEMPLATE_CONFIGURATION_VALUE_TYPE]
 CONFIGURATION_TEMPLATE_CONFIGURATION_SECRET_NAMES_TYPE = List[str]
 CONFIGURATION_TEMPLATE_DEFINITION_TYPE = Dict[str, Any]
+DATA_COLLECTION_FIELDS = List[Dict[str, Any]]
 
 
 class TransformAction(TypedDict):
@@ -6533,6 +6536,10 @@ class DatasetCollection(Base, Dictifiable, UsesAnnotations, Serializable):
     element_count: Mapped[Optional[int]]
     create_time: Mapped[datetime] = mapped_column(default=now, nullable=True)
     update_time: Mapped[datetime] = mapped_column(default=now, onupdate=now, nullable=True)
+    # if collection_type is 'record' (heterogenous collection)
+    fields: Mapped[Optional[DATA_COLLECTION_FIELDS]] = mapped_column(JSONType)
+    # if collection_type is 'sample_sheet' (collection of rows that datasets with extra column metadata)
+    column_definitions: Mapped[Optional[SampleSheetColumnDefinitions]] = mapped_column(JSONType)
 
     elements: Mapped[List["DatasetCollectionElement"]] = relationship(
         primaryjoin=(lambda: DatasetCollection.id == DatasetCollectionElement.dataset_collection_id),
@@ -6552,14 +6559,15 @@ def __init__(
         populated=True,
         element_count=None,
         fields=None,
+        column_definitions=None,
     ):
         self.id = id
         self.collection_type = collection_type
         if not populated:
             self.populated_state = DatasetCollection.populated_states.NEW
         self.element_count = element_count
-        # TODO: persist fields...
         self.fields = fields
+        self.column_definitions = column_definitions
 
     def _build_nested_collection_attributes_stmt(
         self,
@@ -6968,6 +6976,7 @@ def _base_to_dict(self, view):
             name=self.name,
             collection_id=self.collection_id,
             collection_type=self.collection.collection_type,
+            column_definitions=self.collection.column_definitions,
             populated=self.populated,
             populated_state=self.collection.populated_state,
             populated_state_message=self.collection.populated_state_message,
@@ -7450,6 +7459,7 @@ class DatasetCollectionElement(Base, Dictifiable, Serializable):
     # Element index and identifier to define this parent-child relationship.
     element_index: Mapped[Optional[int]]
     element_identifier: Mapped[Optional[str]] = mapped_column(Unicode(255))
+    columns: Mapped[Optional[SampleSheetRow]] = mapped_column(JSONType)
 
     hda = relationship(
         "HistoryDatasetAssociation",
@@ -7470,7 +7480,7 @@ class DatasetCollectionElement(Base, Dictifiable, Serializable):
 
     # actionable dataset id needs to be available via API...
     dict_collection_visible_keys = ["id", "element_type", "element_index", "element_identifier"]
-    dict_element_visible_keys = ["id", "element_type", "element_index", "element_identifier"]
+    dict_element_visible_keys = ["id", "element_type", "element_index", "element_identifier", "columns"]
 
     UNINITIALIZED_ELEMENT = object()
 
@@ -7481,6 +7491,7 @@ def __init__(
         element=None,
         element_index=None,
         element_identifier=None,
+        columns: Optional[SampleSheetRow] = None,
     ):
         if isinstance(element, HistoryDatasetAssociation):
             self.hda = element
@@ -7496,6 +7507,7 @@ def __init__(
         self.collection = collection
         self.element_index = element_index
         self.element_identifier = element_identifier or str(element_index)
+        self.columns = columns
 
     def __strict_check_before_flush__(self):
         if self.collection.populated_optimized:
diff --git a/lib/galaxy/model/dataset_collections/builder.py b/lib/galaxy/model/dataset_collections/builder.py
index 7c640a028d3d..7e74da44a8c1 100644
--- a/lib/galaxy/model/dataset_collections/builder.py
+++ b/lib/galaxy/model/dataset_collections/builder.py
@@ -11,19 +11,31 @@
 from .type_description import COLLECTION_TYPE_DESCRIPTION_FACTORY
 
 
-def build_collection(type, dataset_instances, collection=None, associated_identifiers=None, fields=None):
+def build_collection(
+    type,
+    dataset_instances,
+    collection=None,
+    associated_identifiers=None,
+    fields=None,
+    column_definitions=None,
+    rows=None,
+):
     """
     Build DatasetCollection with populated DatasetcollectionElement objects
     corresponding to the supplied dataset instances or throw exception if
     this is not a valid collection of the specified type.
     """
-    dataset_collection = collection or model.DatasetCollection(fields=fields)
+    dataset_collection = collection or model.DatasetCollection(fields=fields, column_definitions=column_definitions)
     associated_identifiers = associated_identifiers or set()
-    set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers, fields=fields)
+    set_collection_elements(
+        dataset_collection, type, dataset_instances, associated_identifiers, fields=fields, rows=rows
+    )
     return dataset_collection
 
 
-def set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers, fields=None):
+def set_collection_elements(
+    dataset_collection, type, dataset_instances, associated_identifiers, fields=None, rows=None
+):
     new_element_keys = OrderedSet(dataset_instances.keys()) - associated_identifiers
     new_dataset_instances = {k: dataset_instances[k] for k in new_element_keys}
     dataset_collection.element_count = dataset_collection.element_count or 0
@@ -31,7 +43,10 @@ def set_collection_elements(dataset_collection, type, dataset_instances, associa
     elements = []
     if fields == "auto":
         fields = guess_fields(dataset_instances)
-    for element in type.generate_elements(new_dataset_instances, fields=fields):
+    column_definitions = dataset_collection.column_definitions
+    for element in type.generate_elements(
+        new_dataset_instances, fields=fields, rows=rows, column_definitions=column_definitions
+    ):
         element.element_index = element_index
         add_object_to_object_session(element, dataset_collection)
         element.collection = dataset_collection
diff --git a/lib/galaxy/model/dataset_collections/registry.py b/lib/galaxy/model/dataset_collections/registry.py
index ed75294f68e7..1a3b2ff74c06 100644
--- a/lib/galaxy/model/dataset_collections/registry.py
+++ b/lib/galaxy/model/dataset_collections/registry.py
@@ -4,6 +4,7 @@
     paired,
     paired_or_unpaired,
     record,
+    sample_sheet,
 )
 
 PLUGIN_CLASSES = [
@@ -11,6 +12,7 @@
     paired.PairedDatasetCollectionType,
     record.RecordDatasetCollectionType,
     paired_or_unpaired.PairedOrUnpairedDatasetCollectionType,
+    sample_sheet.SampleSheetDatasetCollectionType,
 ]
 
 
diff --git a/lib/galaxy/model/dataset_collections/types/sample_sheet.py b/lib/galaxy/model/dataset_collections/types/sample_sheet.py
new file mode 100644
index 000000000000..f47d79861cf5
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/sample_sheet.py
@@ -0,0 +1,30 @@
+from galaxy.exceptions import RequestParameterMissingException
+from galaxy.model import DatasetCollectionElement
+from . import BaseDatasetCollectionType
+from .sample_sheet_util import validate_row
+
+
+class SampleSheetDatasetCollectionType(BaseDatasetCollectionType):
+    """A flat list of named elements starting rows with column metadata."""
+
+    collection_type = "sample_sheet"
+
+    def generate_elements(self, dataset_instances, **kwds):
+        rows = kwds.get("rows", None)
+        column_definitions = kwds.get("column_definitions", None)
+        if rows is None:
+            raise RequestParameterMissingException(
+                "Missing or null parameter 'rows' required for 'sample_sheet' collection types."
+            )
+        if len(dataset_instances) != len(rows):
+            self._validation_failed("Supplied element do not match 'rows'.")
+
+        for identifier, element in dataset_instances.items():
+            columns = rows[identifier]
+            validate_row(columns, column_definitions)
+            association = DatasetCollectionElement(
+                element=element,
+                element_identifier=identifier,
+                columns=columns,
+            )
+            yield association
diff --git a/lib/galaxy/model/dataset_collections/types/sample_sheet_util.py b/lib/galaxy/model/dataset_collections/types/sample_sheet_util.py
new file mode 100644
index 000000000000..4f8a3f7576ce
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/sample_sheet_util.py
@@ -0,0 +1,127 @@
+from typing import (
+    List,
+    Optional,
+    Union,
+)
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    model_validator,
+    RootModel,
+    ValidationError,
+)
+from typing_extensions import Self
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.schema.schema import (
+    SampleSheetColumnDefinition,
+    SampleSheetColumnDefinitions,
+    SampleSheetColumnType,
+    SampleSheetColumnValueT,
+    SampleSheetRow,
+)
+from galaxy.tool_util.parser.parameter_validators import AnySafeValidatorModel
+
+
+class SampleSheetColumnDefinitionModel(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+    name: str
+    type: SampleSheetColumnType
+    description: Optional[str] = None
+    validators: Optional[List[AnySafeValidatorModel]] = None
+    restrictions: Optional[List[SampleSheetColumnValueT]] = None
+    suggestions: Optional[List[SampleSheetColumnValueT]] = None
+    default_value: Optional[SampleSheetColumnValueT] = None
+
+    @model_validator(mode="after")
+    def check_nature_of_default(self) -> Self:
+        default_val = self.default_value
+        # string types default to "", no null values allowed.
+        if self.type == "string" and default_val is None:
+            raise ValueError("string types must specify a default value, perhaps specify the empty string as a default")
+        elif default_val is None:
+            return self
+        # otherwise just check the types line up between type and default_value
+        elif self.type == "string" and not isinstance(default_val, str):
+            raise ValueError("Mismatch between column type and default value type")
+        elif self.type == "int" and not isinstance(default_val, int):
+            raise ValueError("Mismatch between column type and default value type")
+        elif self.type == "float" and not isinstance(default_val, (int, float)):
+            raise ValueError("Mismatch between column type and default value type")
+        elif self.type == "boolean" and not isinstance(default_val, bool):
+            raise ValueError("Mismatch between column type and default value type")
+        return self
+
+
+SampleSheetColumnDefinitionsModel = RootModel[List[SampleSheetColumnDefinitionModel]]
+SampleSheetColumnDefinitionDictOrModel = Union[SampleSheetColumnDefinition, SampleSheetColumnDefinitionModel]
+
+
+def sample_sheet_column_definition_to_model(
+    column_definition: SampleSheetColumnDefinitionDictOrModel,
+) -> SampleSheetColumnDefinitionModel:
+    if isinstance(column_definition, SampleSheetColumnDefinitionModel):
+        return column_definition
+    else:
+        return SampleSheetColumnDefinitionModel.model_validate(column_definition)
+
+
+def validate_column_definitions(column_definitions: Optional[SampleSheetColumnDefinitions]):
+    for column_definition in column_definitions or []:
+        _validate_column_definition(column_definition)
+
+
+def _validate_column_definition(column_definition: SampleSheetColumnDefinition):
+    # we should do most of this with pydantic but I just wanted to especially make sure
+    # we were only using safe validators
+    try:
+        return SampleSheetColumnDefinitionModel(**column_definition)
+    except ValueError as e:
+        raise RequestParameterInvalidException(str(e))
+    except ValidationError as e:
+        # reuse code to convert this until we have ported the API endpoint to expect this
+        # and then just pass through the ValidationError as-is
+        raise RequestParameterInvalidException(str(e))
+
+
+def validate_row(row: SampleSheetRow, column_definitions: Optional[SampleSheetColumnDefinitions]):
+    if column_definitions is None:
+        return
+    if len(row) != len(column_definitions):
+        raise RequestParameterInvalidException(
+            "Sample sheet row validation failed, incorrect number of columns specified."
+        )
+    for column_value, column_definition in zip(row, column_definitions):
+        validate_column_value(column_value, column_definition)
+
+
+def validate_column_value(
+    column_value: SampleSheetColumnValueT, column_definition: SampleSheetColumnDefinitionDictOrModel
+):
+    column_definition_model = sample_sheet_column_definition_to_model(column_definition)
+    column_type = column_definition_model.type
+    if column_type == "int":
+        if not isinstance(column_value, int):
+            raise RequestParameterInvalidException(f"{column_value} was not an integer as expected")
+    elif column_type == "float":
+        if not isinstance(column_value, (float, int)):
+            raise RequestParameterInvalidException(f"{column_value} was not a number as expected")
+    elif column_type == "string":
+        if not isinstance(column_value, (str,)):
+            raise RequestParameterInvalidException(f"{column_value} was not a string as expected")
+    elif column_type == "boolean":
+        if not isinstance(column_value, (bool,)):
+            raise RequestParameterInvalidException(f"{column_value} was not a boolean as expected")
+    restrictions = column_definition_model.restrictions
+    if restrictions is not None:
+        if column_value not in restrictions:
+            raise RequestParameterInvalidException(
+                f"{column_value} was not in specified list of valid values as expected"
+            )
+    validators = column_definition_model.validators or []
+    for validator in validators:
+        try:
+            validator.statically_validate(column_value)
+        except ValueError as e:
+            raise RequestParameterInvalidException(str(e))
diff --git a/lib/galaxy/model/dataset_collections/types/sample_sheet_workbook.py b/lib/galaxy/model/dataset_collections/types/sample_sheet_workbook.py
new file mode 100644
index 000000000000..34218687a1d2
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/sample_sheet_workbook.py
@@ -0,0 +1,257 @@
+import base64
+from io import BytesIO
+from typing import (
+    Dict,
+    List,
+    Optional,
+)
+
+from openpyxl import (
+    load_workbook,
+    Workbook,
+)
+from openpyxl.styles import Font
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.worksheet.worksheet import Worksheet
+from pydantic import (
+    BaseModel,
+    Field,
+)
+from typing_extensions import Literal
+
+from galaxy.schema.schema import SampleSheetColumnValueT
+from .sample_sheet_util import (
+    SampleSheetColumnDefinitionModel,
+    SampleSheetColumnDefinitionsModel,
+)
+
+DEFAULT_TITLE = "Sample Sheet for Galaxy"
+
+PrefixRowValuesT = List[List[SampleSheetColumnValueT]]
+CreateTitleField = Field(
+    DEFAULT_TITLE,
+    title="Title of the workbook to generate",
+    description="A short title to give the workbook.",
+)
+
+ColumnDefinitionsField: SampleSheetColumnDefinitionsModel = Field(
+    ...,
+    title="Column Descriptions",
+    description="A description of the columns expected in the workbook after the first columns described by 'prefix_columns_type'",
+)
+
+WorkbookContentField: str = Field(
+    ...,
+    title="Workbook Content (Base 64 encoded)",
+    description="The workbook content (the contents of the xlsx file) that have been base64 encoded.",
+)
+PrefixRowsField: Optional[PrefixRowValuesT] = Field(
+    None,
+    title="Prefix sample sheet values",
+    description="An area to pre-populate URIs, etc...",
+)
+
+
+class ParsedWorkbook(BaseModel):
+    rows: List[Dict[str, SampleSheetColumnValueT]]
+
+
+class CreateWorkbookFromBase64(BaseModel):
+    title: str = CreateTitleField
+    prefix_columns_type: Literal["URI"] = "URI"
+    column_definitions: str
+    prefix_values: Optional[PrefixRowValuesT] = None
+
+
+class CreateWorkbook(BaseModel):
+    title: str = CreateTitleField
+    prefix_columns_type: Literal["URI"] = "URI"
+    column_definitions: SampleSheetColumnDefinitionsModel = ColumnDefinitionsField
+    prefix_values: Optional[PrefixRowValuesT] = None
+
+
+class ParseWorkbook(BaseModel):
+    column_definitions: SampleSheetColumnDefinitionsModel = ColumnDefinitionsField
+    content: str = WorkbookContentField
+
+
+INSTRUCTIONS = [
+    "Use this spreadsheet to describe your samples. For each sample (i.e. each file), ensure all the labeled columns are specified and correct.",
+    "If you're using Google Sheets, data validation will be applied automatically - just make sure no cell values have a red mark indicating they are invalid.",
+    "If you're using Microsft Excel, it is best to run data validation after you've completed filling out this sheet. This can be done by clicking on 'Data' > 'Data Validation' > 'Circle Invalid Data'.",
+    "Once data entry is complete, drop this file back into Galaxy to finish creating a sample sheet collection for your inputs.",
+]
+
+
+def parse_workbook(payload: ParseWorkbook) -> ParsedWorkbook:
+    decoded_content = base64.b64decode(payload.content)
+    file_like = BytesIO(decoded_content)
+
+    workbook = load_workbook(file_like, data_only=True)
+    sheet = workbook.active  # Get the first sheet
+    rows = []
+
+    column_names = ["URI"] + [c.name for c in payload.column_definitions.root]
+    columns_to_read = len(column_names) + 1  # skip the prefix columns...
+    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 = {}
+        for value, column_name in zip(row, column_names):
+            parsed_row[column_name] = value
+        rows.append(parsed_row)
+
+    return ParsedWorkbook(
+        rows=rows,
+    )
+
+
+# a base64 version of this so we can do short get URLs with real links in the API.
+def generate_workbook_from_base64(payload: CreateWorkbookFromBase64) -> Workbook:
+    decoded_bytes = base64.b64decode(payload.column_definitions)
+    column_definitions = SampleSheetColumnDefinitionsModel.model_validate_json(decoded_bytes)
+    create_object = CreateWorkbook(
+        title=payload.title,
+        prefix_columns_type=payload.prefix_columns_type,
+        column_definitions=column_definitions.root,
+    )
+    return generate_workbook(create_object)
+
+
+def generate_workbook(payload: CreateWorkbook) -> Workbook:
+    # Create a workbook and select the active worksheet
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.title = payload.title
+
+    column_definitions = payload.column_definitions.root
+    num_initial_columns = 1
+    headers = [_first_column_header(payload)] + [cd.name for cd in column_definitions]
+    worksheet.append(headers)
+    _make_bold(worksheet, 1, 0)
+    for index in range(len(headers)):
+        _make_bold(worksheet, 1, index + 1)
+
+    for index, _ in enumerate(headers):
+        if index == 0:
+            width = 80
+        else:
+            width = 20
+        _set_width(worksheet, index, width)
+
+    _add_first_column_validation(payload, worksheet)
+    worksheet.freeze_panes = "B2"
+
+    for index, column_definition in enumerate(column_definitions):
+        validation: Optional[DataValidation] = None
+        if column_definition.type == "int":
+            validation = DataValidation(type="whole", allow_blank=True)
+            # TODO: operator="between", formula1="1", formula2="1000"
+        elif column_definition.type == "float":
+            validation = DataValidation(type="decimal", allow_blank=True)
+            # TODO: operator="between", formula1="1", formula2="1000"
+        elif column_definition.type == "boolean":
+            column_str = _index_to_excel_column(index + num_initial_columns)
+            validation = DataValidation(
+                type="custom",
+                formula1=f"OR({column_str}2=TRUE, {column_str}2=FALSE)",
+                showDropDown=False,
+                allow_blank=True,
+            )
+
+            dropdown_validation = DataValidation(
+                type="list", formula1='"TRUE,FALSE"', showDropDown=False, allow_blank=True
+            )
+            _add_validation(_index_to_excel_column(index + num_initial_columns), dropdown_validation, worksheet)
+        elif column_definition.restrictions:
+            list_as_formula = ",".join([str(r) for r in column_definition.restrictions])
+            validation = DataValidation(
+                type="list", formula1=f'"{list_as_formula}"', showDropDown=False, allow_blank=True
+            )
+            validation.prompt = "Please select from the list"
+
+        if validation:
+            validation.error = "Invalid input"
+            validation.errorTitle = "Error"
+            validation.promptTitle = column_definition.name
+            _add_validation(_index_to_excel_column(index + num_initial_columns), validation, worksheet)
+
+    help_label_index = num_initial_columns + len(column_definitions) + 1
+    _set_width(worksheet, help_label_index, 10)
+
+    help_start_row = 3
+
+    worksheet.cell(row=help_start_row, column=help_label_index + 1, value="Instructions")
+    bold_font = Font(bold=True)
+    worksheet[f"{_index_to_excel_column(help_label_index)}3"].font = bold_font
+
+    for instruction_index, instruction in enumerate(INSTRUCTIONS):
+        worksheet.cell(
+            row=help_start_row + instruction_index + 1, column=help_label_index + 2, value=f"> {instruction_index + 1}."
+        )
+        worksheet.cell(row=help_start_row + instruction_index + 1, column=help_label_index + 3, value=instruction)
+
+    column_help_start_row = help_start_row + len(INSTRUCTIONS) + 2
+
+    worksheet.cell(row=column_help_start_row, column=help_label_index + 1, value="Columns")
+    _make_bold(worksheet, column_help_start_row, help_label_index)
+    # bold_font = Font(bold=True)
+    # worksheet[f"{_index_to_excel_column(help_label_index)}{column_help_start_row}"].font = bold_font
+    _set_width(worksheet, help_label_index + 1, 15)
+    _set_width(worksheet, help_label_index + 2, 150)
+
+    for column_index, column in enumerate(column_definitions):
+        worksheet.cell(row=column_help_start_row + column_index + 1, column=help_label_index + 2, value=column.name)
+        worksheet.cell(
+            row=column_help_start_row + column_index + 1, column=help_label_index + 3, value=column.description
+        )
+
+    prefix_rows = payload.prefix_values or []
+    prefix_rows_offset = 2  # header + 1-index-ed datastructue
+    for row_index, row in enumerate(prefix_rows):
+        for column_index, col_value in enumerate(row):
+            worksheet.cell(row=row_index + prefix_rows_offset, column=column_index + 1, value=col_value)
+
+    return workbook
+
+
+def _first_column_header(payload: CreateWorkbook):
+    assert payload.prefix_columns_type == "URI"
+    return "URI"
+
+
+def _set_width(worksheet: Worksheet, index: int, width: int):
+    worksheet.column_dimensions[_index_to_excel_column(index)].width = width
+
+
+def _make_bold(worksheet: Worksheet, row: int, column: int):
+    bold_font = Font(bold=True)
+    worksheet[f"{_index_to_excel_column(column)}{row}"].font = bold_font
+
+
+def _add_first_column_validation(payload: CreateWorkbook, worksheet: Worksheet):
+    assert payload.prefix_columns_type == "URI"
+    # Add data validation for "URI" column
+    # We cannot assume http/https since drs, gxfiles, etc... are all fine
+    uri_validation = DataValidation(type="custom", formula1='=ISNUMBER(FIND("://", E2))', allow_blank=True)
+    _add_validation("A", uri_validation, worksheet)
+
+
+def _add_validation(column: str, data_validation: DataValidation, worksheet: Worksheet):
+    worksheet.add_data_validation(data_validation)
+    data_validation.add(f"{column}2:{column}1048576")
+
+
+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
diff --git a/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_sample_sheets.py b/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_sample_sheets.py
index 558a485020cc..435bdce0ab6e 100644
--- a/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_sample_sheets.py
+++ b/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_sample_sheets.py
@@ -28,10 +28,12 @@
 def upgrade():
     with transaction():
         add_column(dataset_collection_table, Column("column_definitions", JSONType(), default=None))
+        add_column(dataset_collection_table, Column("fields", JSONType(), default=None))
         add_column(dataset_collection_element_table, Column("columns", JSONType(), default=None))
 
 
 def downgrade():
     with transaction():
         drop_column(dataset_collection_table, "column_definitions")
+        drop_column(dataset_collection_table, "fields")
         drop_column(dataset_collection_element_table, "columns")
diff --git a/lib/galaxy/model/unittest_utils/filled_in_workbook_1.xlsx b/lib/galaxy/model/unittest_utils/filled_in_workbook_1.xlsx
new file mode 100644
index 000000000000..175ebd141ca9
Binary files /dev/null and b/lib/galaxy/model/unittest_utils/filled_in_workbook_1.xlsx differ
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 010e7a78c278..6c9c01d6d19c 100644
--- a/lib/galaxy/schema/schema.py
+++ b/lib/galaxy/schema/schema.py
@@ -348,6 +348,29 @@ class LimitedUserModel(Model):
 
 MaybeLimitedUserModel = Union[UserModel, LimitedUserModel]
 
+# named in compatiblity with CWL - trying to keep CWL fields in mind with
+# this implementation. https://www.commonwl.org/user_guide/topics/inputs.html#inputs
+SampleSheetColumnType = Literal[
+    "string", "int", "float", "boolean"
+]  # excluding "long" and "double" and composite types from CWL for now - we don't think at this level of abstraction in Galaxy generally
+SampleSheetColumnValueT = Union[str, int, float, bool]
+
+
+class SampleSheetColumnDefinition(TypedDict):
+    name: str
+    description: NotRequired[Optional[str]] = None
+    type: SampleSheetColumnType
+    # Optional semantic - this column is optional iff default value is None
+    default_value: Optional[SampleSheetColumnValueT] = None
+    validators: NotRequired[Optional[List[Dict[str, Any]]]] = None
+    restrictions: NotRequired[Optional[List[str]]] = None
+    suggestions: NotRequired[Optional[List[str]]] = None
+
+
+SampleSheetColumnDefinitions = List[SampleSheetColumnDefinition]
+SampleSheetRow = List[SampleSheetColumnValueT]
+SampleSheetRows = Dict[str, SampleSheetRow]
+
 
 class DiskUsageUserModel(Model):
     total_disk_usage: float = TotalDiskUsageField
@@ -999,6 +1022,11 @@ class DCESummary(Model, WithModelClass):
         title="Object",
         description="The element's specific data depending on the value of `element_type`.",
     )
+    columns: Optional[SampleSheetRow] = Field(
+        None,
+        title="Columns",
+        description="A row (or list of columns) of data associated with this element",
+    )
 
 
 DCObject.model_rebuild()
@@ -1143,6 +1171,10 @@ class HDCADetailed(HDCASummary):
         None,
         description="Encoded ID for the ICJ object describing the collection of jobs corresponding to this collection",
     )
+    column_definitions: Optional[SampleSheetColumnDefinitions] = Field(
+        None,
+        description="Column data associated with each element of this collection.",
+    )
 
 
 class HistoryContentItemBase(Model):
@@ -1668,6 +1700,16 @@ class CreateNewCollectionPayload(Model):
         title="Element Identifiers",
         description="List of elements that should be in the new collection.",
     )
+    column_definitions: Optional[SampleSheetColumnDefinitions] = Field(
+        default=None,
+        title="Column Definitions",
+        description="Specify definitions for row data if collection_type if sample_sheet",
+    )
+    rows: Optional[SampleSheetRows] = Field(
+        default=None,
+        title="Row data",
+        description="Specify rows of metadata data corresponding to an indentifier if collection_type is sample_sheet",
+    )
     name: Optional[str] = Field(
         default=None,
         title="Name",
diff --git a/lib/galaxy/tool_util/client/staging.py b/lib/galaxy/tool_util/client/staging.py
index 3d4d6ca73080..136b2498f6b8 100644
--- a/lib/galaxy/tool_util/client/staging.py
+++ b/lib/galaxy/tool_util/client/staging.py
@@ -233,7 +233,9 @@ def _attach_file(upload_payload: Dict[str, Any], uri: str, index: int = 0) -> No
             else:
                 raise ValueError(f"Unsupported type for upload_target: {type(upload_target)}")
 
-        def create_collection_func(element_identifiers: List[Dict[str, Any]], collection_type: str) -> Dict[str, Any]:
+        def create_collection_func(
+            element_identifiers: List[Dict[str, Any]], collection_type: str, rows: Optional[Dict[str, Any]] = None
+        ) -> Dict[str, Any]:
             payload = {
                 "name": "dataset collection",
                 "instance_type": "history",
@@ -241,6 +243,7 @@ def create_collection_func(element_identifiers: List[Dict[str, Any]], collection
                 "element_identifiers": element_identifiers,
                 "collection_type": collection_type,
                 "fields": None if collection_type != "record" else "auto",
+                "rows": rows,
             }
             return self._post("dataset_collections", payload)
 
diff --git a/lib/galaxy/tool_util/cwl/util.py b/lib/galaxy/tool_util/cwl/util.py
index 2f3edde16dba..c36fe364049a 100644
--- a/lib/galaxy/tool_util/cwl/util.py
+++ b/lib/galaxy/tool_util/cwl/util.py
@@ -25,6 +25,7 @@
 import yaml
 from typing_extensions import (
     Literal,
+    Protocol,
     TypedDict,
 )
 
@@ -130,11 +131,19 @@ def path_or_uri_to_uri(path_or_uri: str) -> str:
         return path_or_uri
 
 
+class CollectionCreateFunc(Protocol):
+
+    def __call__(
+        self, element_identifiers: List[Dict[str, Any]], collection_type: str, rows: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Create a collection from these identifiers."""
+
+
 def galactic_job_json(
     job: Dict[str, Any],
     test_data_directory: str,
     upload_func: Callable[["UploadTarget"], Dict[str, Any]],
-    collection_create_func: Callable[[List[Dict[str, Any]], str], Dict[str, Any]],
+    collection_create_func: CollectionCreateFunc,
     tool_or_workflow: Literal["tool", "workflow"] = "workflow",
 ) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
     """Adapt a CWL job object to the Galaxy API.
@@ -340,8 +349,10 @@ def replacement_collection(value: Dict[str, Any]) -> Dict[str, str]:
         assert "collection_type" in value
         collection_type = value["collection_type"]
         elements = to_elements(value, collection_type)
-
-        collection = collection_create_func(elements, collection_type)
+        kwds = {}
+        if collection_type == "sample_sheet":
+            kwds["rows"] = value["rows"]
+        collection = collection_create_func(elements, collection_type, **kwds)
         dataset_collections.append(collection)
         hdca_id = collection["id"]
         return {"src": "hdca", "id": hdca_id}
diff --git a/lib/galaxy/tool_util/parser/parameter_validators.py b/lib/galaxy/tool_util/parser/parameter_validators.py
index 29af9494b0bd..f52d36f93545 100644
--- a/lib/galaxy/tool_util/parser/parameter_validators.py
+++ b/lib/galaxy/tool_util/parser/parameter_validators.py
@@ -467,8 +467,22 @@ def default_message(self) -> str:
     Field(discriminator="type"),
 ]
 
+AnySafeValidatorModel = Annotated[
+    Union[
+        RegexParameterValidatorModel,
+        InRangeParameterValidatorModel,
+        LengthParameterValidatorModel,
+    ],
+    Field(discriminator="type"),
+]
+
 
 DiscriminatedAnyValidatorModel = TypeAdapter(AnyValidatorModel)  # type:ignore[var-annotated]
+DiscriminatedAnySafeValidatorModel = TypeAdapter(AnySafeValidatorModel)  # type:ignore[var-annotated]
+
+
+class UnsafeValidatorConfiguredInUntrustedContext(AssertionError):
+    pass
 
 
 def parse_dict_validators(validator_dicts: List[Dict[str, Any]], trusted: bool) -> List[AnyValidatorModel]:
@@ -477,7 +491,8 @@ def parse_dict_validators(validator_dicts: List[Dict[str, Any]], trusted: bool)
         validator = DiscriminatedAnyValidatorModel.validate_python(validator_dict)
         if not trusted:
             # Don't risk instantiating unsafe validators for user-defined code
-            assert validator._safe
+            if not validator._safe:
+                raise UnsafeValidatorConfiguredInUntrustedContext()
         validator_models.append(validator)
     return validator_models
 
diff --git a/lib/galaxy/util/rules_dsl.py b/lib/galaxy/util/rules_dsl.py
index 83aca4560ec2..e1d1cd4440a9 100644
--- a/lib/galaxy/util/rules_dsl.py
+++ b/lib/galaxy/util/rules_dsl.py
@@ -250,6 +250,29 @@ def new_row(row):
         return list(map(new_row, data)), sources
 
 
+class AddColumnFromSampleSheetByIndex(BaseRuleDefinition):
+    rule_type = "add_sample_sheet_column_by_index"
+
+    def validate_rule(self, rule):
+        _ensure_rule_contains_keys(
+            rule,
+            {
+                "value": int,
+            },
+        )
+
+    def apply(self, rule, data, sources):
+        sample_sheet_column_index = rule["value"]
+
+        new_rows = []
+        for index, row in enumerate(data):
+            source = sources[index]
+            columns = source["columns"]
+            new_rows.append(row + [columns[sample_sheet_column_index]])
+
+        return new_rows, sources
+
+
 class RemoveColumnsRuleDefinition(BaseRuleDefinition):
     rule_type = "remove_columns"
 
@@ -604,6 +627,7 @@ def display(self):
     AddColumnRownumRuleDefinition,
     AddColumnValueRuleDefinition,
     AddColumnSubstrRuleDefinition,
+    AddColumnFromSampleSheetByIndex,
     RemoveColumnsRuleDefinition,
     AddFilterRegexRuleDefinition,
     AddFilterCountRuleDefinition,
diff --git a/lib/galaxy/util/rules_dsl_spec.yml b/lib/galaxy/util/rules_dsl_spec.yml
index 1514d05c8020..6b708c5280b0 100644
--- a/lib/galaxy/util/rules_dsl_spec.yml
+++ b/lib/galaxy/util/rules_dsl_spec.yml
@@ -451,6 +451,28 @@
   final:
     data: [["moo", "barn"], ["meow", "house"], ["bark", "firestation"]]
 
+- doc: add column from a sample sheet by index
+  rules:
+    - type: add_sample_sheet_column_by_index
+      value: 0
+  initial:
+    data: [["moo"], ["cow"]]
+    sources: [{"columns": [0, 1]}, {"columns": [2, 3]}]
+  final:
+    data: [["moo", 0], ["cow", 2]]
+
+- doc: add multiple columns from a sample sheet by index
+  rules:
+    - type: add_sample_sheet_column_by_index
+      value: 0
+    - type: add_sample_sheet_column_by_index
+      value: 1
+  initial:
+    data: [["moo"], ["cow"]]
+    sources: [{"columns": [0, 1]}, {"columns": [2, 3]}]
+  final:
+    data: [["moo", 0, 1], ["cow", 2, 3]]
+
 - rules:
     - type: invalid_rule_type
   error: true
diff --git a/lib/galaxy/webapps/galaxy/api/dataset_collections.py b/lib/galaxy/webapps/galaxy/api/dataset_collections.py
index cecabb6e3c17..e1c1e7680b29 100644
--- a/lib/galaxy/webapps/galaxy/api/dataset_collections.py
+++ b/lib/galaxy/webapps/galaxy/api/dataset_collections.py
@@ -1,3 +1,5 @@
+import base64
+from io import BytesIO
 from logging import getLogger
 from typing import Optional
 
@@ -8,9 +10,18 @@
     Response,
     status,
 )
+from starlette.responses import StreamingResponse
 from typing_extensions import Annotated
 
 from galaxy.managers.context import ProvidesHistoryContext
+from galaxy.model.dataset_collections.types.sample_sheet_util import SampleSheetColumnDefinitionsModel
+from galaxy.model.dataset_collections.types.sample_sheet_workbook import (
+    CreateWorkbookFromBase64,
+    generate_workbook_from_base64,
+    parse_workbook,
+    ParsedWorkbook,
+    ParseWorkbook,
+)
 from galaxy.schema.fields import DecodedDatabaseIdField
 from galaxy.schema.schema import (
     AnyHDCA,
@@ -51,6 +62,15 @@
     description="The view of collection instance to return.",
 )
 
+Base64ColumnDefinitionsQueryParam: str = Query(
+    ...,
+    description="Base64 encoding of column definitions.",
+)
+WorkbookFilenameQueryParam: Optional[str] = Query(
+    None,
+    description="Filename of the workbook download to generate",
+)
+
 
 @router.cbv
 class FastAPIDatasetCollections:
@@ -67,6 +87,42 @@ def create(
     ) -> HDCADetailed:
         return self.service.create(trans, payload)
 
+    @router.get(
+        "/api/sample_sheet_workbook/generate",
+        summary="Create an XLSX workbook for a sample sheet definition.",
+        response_class=StreamingResponse,
+        operation_id="dataset_collections__workbook_download",
+    )
+    def create_workbook(
+        self,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+        column_definitions: str = Base64ColumnDefinitionsQueryParam,
+        filename: Optional[str] = WorkbookFilenameQueryParam,
+    ):
+        create_object = CreateWorkbookFromBase64(column_definitions=column_definitions)
+        workbook = generate_workbook_from_base64(create_object)
+        output = BytesIO()
+        workbook.save(output)
+        output.seek(0)
+        filename = filename or "galaxy_sample_sheet_workbook.xlsx"
+        return StreamingResponse(
+            output,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            headers={"Content-Disposition": f"attachment; filename={filename}"},
+        )
+
+    @router.post(
+        "/api/sample_sheet_workbook/parse",
+        summary="Parse an XLSX workbook for a sample sheet definition and supplied file contents.",
+        operation_id="dataset_collections__workbook_parse",
+    )
+    def parse_workbook(
+        self,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+        payload: ParseWorkbook = Body(...),
+    ) -> ParsedWorkbook:
+        return parse_workbook(payload)
+
     @router.post(
         "/api/dataset_collections/{id}/copy",
         summary="Copy the given collection datasets to a new collection using a new `dbkey` attribute.",
diff --git a/lib/galaxy/workflow/modules.py b/lib/galaxy/workflow/modules.py
index ae5f8e31e920..59d369171390 100644
--- a/lib/galaxy/workflow/modules.py
+++ b/lib/galaxy/workflow/modules.py
@@ -1159,7 +1159,12 @@ def _parse_state_into_dict(self):
             collection_type = inputs["collection_type"]
         else:
             collection_type = self.default_collection_type
+        if "column_definitions" in inputs:
+            column_definitions = inputs["column_definitions"]
+        else:
+            column_definitions = None
         state_as_dict["collection_type"] = collection_type
+        state_as_dict["column_definitions"] = column_definitions
         return state_as_dict
 
 
diff --git a/lib/galaxy_test/api/test_dataset_collections.py b/lib/galaxy_test/api/test_dataset_collections.py
index d2b3e416f5a2..a370ecbf125c 100644
--- a/lib/galaxy_test/api/test_dataset_collections.py
+++ b/lib/galaxy_test/api/test_dataset_collections.py
@@ -5,7 +5,10 @@
 from urllib.parse import quote
 
 from galaxy.util.unittest_utils import skip_if_github_down
-from galaxy_test.base.api_asserts import assert_object_id_error
+from galaxy_test.base.api_asserts import (
+    assert_object_id_error,
+    assert_status_code_is,
+)
 from galaxy_test.base.decorators import requires_new_user
 from galaxy_test.base.populators import (
     DatasetCollectionPopulator,
@@ -220,6 +223,161 @@ def test_record_field_validation(self, history_id):
             create_response = self._post("dataset_collections", payload)
             self._assert_status_code_is(create_response, 400)
 
+    def test_sample_sheet_column_definition_problems(self, history_id):
+        contents = [
+            ("sample1", "1\t2\t3"),
+            ("sample2", "4\t5\t6"),
+        ]
+        sample_sheet_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="my cool sample sheet",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=sample_sheet_identifiers,
+            collection_type="sample_sheet",
+            column_definitions=[{"type": "int", "name": "replicate"}],
+            rows={"sample1": [42], "sample2": [45]},
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        self._check_create_response(create_response)
+        payload["column_definitions"] = [{"type": "intx"}]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+        payload["column_definitions"] = [{"typex": "int"}]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+        payload["column_definitions"] = [{"type": "int", "restrictions": "wrongtype", "name": "replicate"}]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+        payload["column_definitions"] = [
+            {"type": "int", "name": "replicate", "validators": [{"type": "expression", "expression": "False"}]}
+        ]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+
+    def test_sample_sheet_validating_against_column_definition(self, history_id):
+        contents = [
+            ("sample1", "1\t2\t3"),
+            ("sample2", "4\t5\t6"),
+        ]
+        sample_sheet_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="my cool sample sheet",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=sample_sheet_identifiers,
+            collection_type="sample_sheet",
+            column_definitions=[{"type": "int", "name": "replicate"}],
+            rows={"sample1": [42], "sample2": [45]},
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        self._check_create_response(create_response)
+        # now the datatype of the row data is wrong....
+        payload["column_definitions"] = [{"type": "string", "name": "replicate"}]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+
+        # now the row values are too small for the supplied validator
+        payload["column_definitions"] = [
+            {"type": "int", "name": "replicate", "validators": [{"type": "in_range", "min": 60}]}
+        ]
+        create_response = self._post("dataset_collections", payload, json=True)
+        assert_status_code_is(create_response, 400)
+
+    def test_sample_sheet_requires_columns(self, history_id):
+        contents = [
+            ("sample1", "1\t2\t3"),
+            ("sample2", "4\t5\t6"),
+        ]
+        sample_sheet_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="my cool sample sheet",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=sample_sheet_identifiers,
+            collection_type="sample_sheet",
+            column_definitions=[{"type": "int", "name": "replicate"}],
+            rows={"sample1": [42], "sample2": [45]},
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        dataset_collection = self._check_create_response(create_response)
+
+        self._assert_has_keys(dataset_collection, "collection_type", "column_definitions")
+        column_definitions = dataset_collection["column_definitions"]
+        assert len(column_definitions) == 1
+        self._assert_has_keys(column_definitions[0], "type")
+        assert column_definitions[0]["type"] == "int"
+
+        # TODO: restore assertion and test before merging...
+        # assert something about column definition here....
+        assert dataset_collection["collection_type"] == "sample_sheet"
+        assert dataset_collection["name"] == "my cool sample sheet"
+        returned_collections = dataset_collection["elements"]
+        assert len(returned_collections) == 2, dataset_collection
+        sheet_row_0_element = returned_collections[0]
+        self._assert_has_keys(sheet_row_0_element, "element_index", "columns")
+        record_pos_0_object = sheet_row_0_element["object"]
+        self._assert_has_keys(record_pos_0_object, "name", "history_content_type")
+        row_0 = sheet_row_0_element["columns"]
+        assert row_0[0] == 42
+
+        sheet_row_1_element = returned_collections[1]
+        self._assert_has_keys(sheet_row_1_element, "element_index", "columns")
+        row_1 = sheet_row_1_element["columns"]
+        assert row_1[0] == 45
+        # TODO: test case where column definition does not match supplied data
+        # TODO: test case without column definition, implement definition inference based on supplied datatypes
+
+    def test_sample_sheet_column_definition_inference(self, history_id):
+        contents = [
+            ("sample1", "1\t2\t3"),
+            ("sample2", "4\t5\t6"),
+        ]
+        sample_sheet_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="my cool sample sheet",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=sample_sheet_identifiers,
+            collection_type="sample_sheet",
+            rows={"sample1": [42], "sample2": [45]},
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        dataset_collection = self._check_create_response(create_response)
+
+        self._assert_has_keys(dataset_collection, "collection_type", "column_definitions")
+        column_definitions = dataset_collection["column_definitions"]
+        # TODO: restore assertion and test before merging...
+        assert column_definitions, column_definitions
+        assert dataset_collection["collection_type"] == "sample_sheet"
+        assert dataset_collection["name"] == "my cool sample sheet"
+        returned_collections = dataset_collection["elements"]
+        assert len(returned_collections) == 2, dataset_collection
+        sheet_row_0_element = returned_collections[0]
+        self._assert_has_keys(sheet_row_0_element, "element_index", "columns")
+        record_pos_0_object = sheet_row_0_element["object"]
+        self._assert_has_keys(record_pos_0_object, "name", "history_content_type")
+        row_0 = sheet_row_0_element["columns"]
+        assert row_0[0] == 42
+
+        sheet_row_1_element = returned_collections[1]
+        self._assert_has_keys(sheet_row_1_element, "element_index", "columns")
+        row_1 = sheet_row_1_element["columns"]
+        assert row_1[0] == 45
+
+    def test_workbook_download(self):
+        xlsx_file = self.dataset_collection_populator.download_workbook(
+            [
+                {"name": "condition", "type": "string"},
+                {"name": "replicate", "type": "int"},
+            ]
+        )
+        # 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"
+
     def test_list_download(self):
         with self.dataset_populator.test_history(require_new=False) as history_id:
             fetch_response = self.dataset_collection_populator.create_list_in_history(
diff --git a/lib/galaxy_test/api/test_tools.py b/lib/galaxy_test/api/test_tools.py
index 41d982d246c9..fcf29f928a99 100644
--- a/lib/galaxy_test/api/test_tools.py
+++ b/lib/galaxy_test/api/test_tools.py
@@ -848,6 +848,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_nested_list_from_sample_sheet(self):
+        self._apply_rules_and_check(rules_test_data.EXAMPLE_SAMPLE_SHEET_SIMPLE_TO_NESTED_LIST)
+
     @skip_without_tool("galaxy_json_sleep")
     def test_dataset_hidden_after_job_finish(self):
         with self.dataset_populator.test_history() as history_id:
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index 528156ca244e..b078ffd09149 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -90,6 +90,7 @@
 from galaxy.schema.schema import (
     CreateToolLandingRequestPayload,
     CreateWorkflowLandingRequestPayload,
+    SampleSheetColumnDefinitions,
     ToolLandingRequest,
     WorkflowLandingRequest,
 )
@@ -418,8 +419,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
 
@@ -2972,6 +2976,17 @@ def create_list_from_pairs(self, history_id, pairs, name="Dataset Collection fro
             history_id=history_id, collection=pairs, collection_type="list:paired", name=name
         )
 
+    def download_workbook(self, column_definitions: SampleSheetColumnDefinitions) -> str:
+        url = f"sample_sheet_workbook/generate"
+        column_definitions_bytes = json.dumps(column_definitions).encode("utf-8")
+        column_definitions_b64 = base64.b64encode(column_definitions_bytes).decode("utf-8")
+        query_params = {
+            "column_definitions": column_definitions_b64,
+            "filename": "workbook.xlsx",
+        }
+        download_response = self.dataset_populator._get(url, query_params)
+        return self.dataset_populator._get_response_to_tempfile(download_response)
+
     def nested_collection_identifiers(self, history_id: str, collection_type):
         rank_types = list(reversed(collection_type.split(":")))
         assert len(rank_types) > 0
diff --git a/lib/galaxy_test/base/rules_test_data.py b/lib/galaxy_test/base/rules_test_data.py
index 1530c0a05984..6009125b58d2 100644
--- a/lib/galaxy_test/base/rules_test_data.py
+++ b/lib/galaxy_test/base/rules_test_data.py
@@ -287,3 +287,54 @@ def check_example_6(hdca, dataset_populator):
     "check": check_example_6,
     "output_hid": 8,
 }
+
+
+def check_example_sample_sheet_simple_to_nested_list(hdca, dataset_populator):
+    assert hdca["collection_type"] == "list:list"
+    assert hdca["element_count"] == 2
+    treat1_el = hdca["elements"][0]
+    assert "object" in treat1_el, hdca
+    assert "element_identifier" in treat1_el
+    assert treat1_el["element_identifier"] == "treat1", hdca
+
+    treat2_el = hdca["elements"][1]
+    assert "object" in treat2_el, hdca
+    assert "element_identifier" in treat2_el
+    assert treat2_el["element_identifier"] == "treat2", hdca
+
+
+EXAMPLE_SAMPLE_SHEET_SIMPLE_TO_NESTED_LIST = {
+    "rules": {
+        "rules": [
+            {
+                "type": "add_sample_sheet_column_by_index",
+                "value": 0,
+            },
+            {
+                "type": "add_column_metadata",
+                "value": "identifier0",
+            },
+        ],
+        "mapping": [
+            {
+                "type": "list_identifiers",
+                "columns": [0, 1],
+            },
+        ],
+    },
+    "test_data": {
+        "type": "sample_sheet",
+        "elements": [
+            {"identifier": "i1", "contents": "0", "class": "File"},
+            {"identifier": "i2", "contents": "1", "class": "File"},
+            {"identifier": "i3", "contents": "2", "class": "File"},
+        ],
+        "rows": {
+            "i1": ["treat1"],
+            "i2": ["treat2"],
+            "i3": ["treat1"],
+        },
+    },
+    "check": check_example_sample_sheet_simple_to_nested_list,
+    "output_hid": 8,
+}
diff --git a/packages/data/setup.cfg b/packages/data/setup.cfg
index 2dd4e7e16b07..cb3d0dd99e8e 100644
--- a/packages/data/setup.cfg
+++ b/packages/data/setup.cfg
@@ -51,6 +51,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 08ba68afcd48..5d98b8e81d29 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -66,6 +66,7 @@ dependencies = [
     "numpy",
     "numpy>=1.26.0 ; python_version=='3.9'",  # 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/data/dataset_collections/test_sample_sheet_util.py b/test/unit/data/dataset_collections/test_sample_sheet_util.py
new file mode 100644
index 000000000000..69bf6ab83314
--- /dev/null
+++ b/test/unit/data/dataset_collections/test_sample_sheet_util.py
@@ -0,0 +1,93 @@
+import pytest
+from pydantic import ValidationError
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.model.dataset_collections.types.sample_sheet_util import (
+    validate_column_definitions,
+    validate_row,
+)
+
+
+def test_sample_sheet_validation_skipped_on_empty_definitions():
+    validate_row([0, 1], None)  # just ensure no execption is thrown
+
+
+def test_sample_sheet_validation_number_columns():
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row([0, 1], [{"type": "int", "name": "replicate number"}])
+
+
+def test_sample_sheet_validation_int_type():
+    validate_row([1], [{"type": "int", "name": "replicate number"}])
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row(["sample1"], [{"type": "int", "name": "replicate number"}])
+
+
+def test_sample_sheet_validation_float_type():
+    validate_row([1.0], [{"type": "float", "name": "seconds"}])
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row(["sample1"], [{"type": "float", "name": "seconds"}])
+
+
+def test_sample_sheet_validation_string_type():
+    validate_row(["sample1"], [{"type": "string", "name": "condition"}])
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row([1], [{"type": "string", "name": "condition"}])
+
+
+def test_sample_sheet_validation_boolean_type():
+    validate_row([True], [{"type": "boolean", "name": "control?"}])
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row([1], [{"type": "boolean", "name": "control?"}])
+
+
+def test_sample_sheet_validation_restrictions():
+    validate_row(["control"], [{"type": "string", "restrictions": ["treatment", "control"], "name": "condition"}])
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row(["controlx"], [{"type": "string", "restrictions": ["treatment", "control"], "name": "condition"}])
+
+
+def test_sample_sheet_validation_length():
+    column_definitions = [{"type": "string", "validators": [{"type": "length", "min": 6}], "name": "condition"}]
+    validate_row(["treatment"], column_definitions)
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row(["treat"], column_definitions)
+
+
+def test_sample_sheet_validation_min_max():
+    column_definitions = [{"type": "int", "validators": [{"type": "in_range", "min": 6}], "name": "replicate number"}]
+    validate_row([7], column_definitions)
+
+    with pytest.raises(RequestParameterInvalidException):
+        validate_row([5], column_definitions)
+
+
+def test_column_definitions_validators_on_valid_defs():
+    column_definitions = [{"type": "string", "restrictions": ["treatment", "control"], "name": "condition"}]
+    validate_column_definitions(column_definitions)
+
+
+def test_column_definitions_validators_invalid_length():
+    column_definitions = [{"type": "string", "validators": [{"type": "length", "min": 6}], "name": "condition"}]
+    validate_column_definitions(column_definitions)
+
+
+def test_column_definitions_do_not_allow_unsafe_validators():
+    column_definitions = [
+        {
+            "type": "string",
+            "name": "condition",
+            "validators": [
+                {"type": "expression", "expression": "False"},
+            ],
+        }
+    ]
+
+    with pytest.raises(ValidationError):
+        validate_column_definitions(column_definitions)
diff --git a/test/unit/data/dataset_collections/test_sample_sheet_workbook.py b/test/unit/data/dataset_collections/test_sample_sheet_workbook.py
new file mode 100644
index 000000000000..9cbdaefdb98a
--- /dev/null
+++ b/test/unit/data/dataset_collections/test_sample_sheet_workbook.py
@@ -0,0 +1,119 @@
+import base64
+import json
+import os
+
+from galaxy.model.dataset_collections.types.sample_sheet_workbook import (
+    _index_to_excel_column,
+    CreateWorkbook,
+    CreateWorkbookFromBase64,
+    generate_workbook,
+    generate_workbook_from_base64,
+    parse_workbook,
+    ParseWorkbook,
+    SampleSheetColumnDefinitionsModel,
+)
+from galaxy.util.resources import (
+    as_file,
+    resource_path,
+)
+
+WRITE_TEST_WORKBOOKS = False
+TEST_DATA = [
+    ["https://zenodo.org/records/3263975/files/DRR000770.fastqsanger.gz", 1, "treatment1", False],
+    ["https://zenodo.org/records/3263975/files/DRR000771.fastqsanger.gz", 2, "treatment1", False],
+    ["https://zenodo.org/records/3263975/files/DRR000772.fastqsanger.gz", 1, "none", True],
+    ["https://zenodo.org/records/3263975/files/DRR000773.fastqsanger.gz", 1, "treatment2", False],
+    ["https://zenodo.org/records/3263975/files/DRR000774.fastqsanger.gz", 2, "treatment3", False],
+    ["https://zenodo.org/records/3263975/files/DRR000775.fastqsanger.gz", "badnumber", "treatment2", False],
+    ["https://zenodo.org/records/3263975/files/DRR000776.fastqsanger.gz", 2, "wrongtreament", False],
+    ["https://zenodo.org/records/3263975/files/DRR000777.fastqsanger.gz", 3, "treatment2", "badbool"],
+]
+TEST_COLUMN_DEFINITIONS_1 = [
+    {"name": "replicate number", "type": "int", "description": "The replicate number of this sample."},
+    {
+        "name": "treatment",
+        "type": "string",
+        "restrictions": ["treatment1", "treatment2", "none"],
+        "description": "The treatment code for this sample.",
+    },
+    {
+        "name": "is control?",
+        "type": "boolean",
+        "description": "Was this sample a control? If TRUE, please ensure treatment is set to none.",
+    },
+]
+
+
+def test_generate_without_seed_data():
+    create = CreateWorkbook.model_validate({"column_definitions": TEST_COLUMN_DEFINITIONS_1})
+    workbook = generate_workbook(create)
+    if WRITE_TEST_WORKBOOKS:
+        for index, row in enumerate(TEST_DATA):
+            for col, column in enumerate(row):
+                workbook.active.cell(row=index + 2, column=col + 1, value=column)
+
+        path = "~/test_workbook.xlsx"
+        expanded_path = os.path.expanduser(path)
+        workbook.save(expanded_path)
+
+
+def test_generate_base64_without_seed_data():
+    json_string = json.dumps(TEST_COLUMN_DEFINITIONS_1)
+    column_definition_base64 = base64.b64encode(json_string.encode("utf-8")).decode("utf-8")
+    create = CreateWorkbookFromBase64(column_definitions=column_definition_base64)
+    workbook = generate_workbook_from_base64(create)
+    if WRITE_TEST_WORKBOOKS:
+        for index, row in enumerate(TEST_DATA):
+            for col, column in enumerate(row):
+                workbook.active.cell(row=index + 2, column=col + 1, value=column)
+
+        path = "~/test_workbook_from_base64.xlsx"
+        expanded_path = os.path.expanduser(path)
+        workbook.save(expanded_path)
+
+
+def test_generate_with_seed_data():
+    create = CreateWorkbook.model_validate(
+        {
+            "column_definitions": TEST_COLUMN_DEFINITIONS_1,
+            "prefix_values": [
+                ["https://zenodo.org/records/3263975/files/DRR000770.fastqsanger.gz"],
+                ["https://zenodo.org/records/3263975/files/DRR000771.fastqsanger.gz"],
+            ],
+        }
+    )
+    workbook = generate_workbook(create)
+    if WRITE_TEST_WORKBOOKS:
+        path = "~/test_workbook_seeded.xlsx"
+        expanded_path = os.path.expanduser(path)
+        workbook.save(expanded_path)
+
+
+def test_parse_base64_workbook():
+    path = resource_path("galaxy.model.unittest_utils", "filled_in_workbook_1.xlsx")
+    example_as_bytes = path.read_bytes()
+    content_base64 = base64.b64encode(example_as_bytes).decode("utf-8")
+    # column_definitions = SampleSheetColumnDefinitionsModel.parse_obj(TEST_COLUMN_DEFINITIONS_1)
+    parse_payload = ParseWorkbook(
+        column_definitions=TEST_COLUMN_DEFINITIONS_1,
+        content=content_base64,
+    )
+    result = parse_workbook(parse_payload)
+    rows = result.rows
+    assert rows
+    print(result.rows[0])
+    assert result.rows[0]["URI"] == "https://zenodo.org/records/3263975/files/DRR000770.fastqsanger.gz"
+    assert result.rows[0]["replicate number"] == 1
+    assert result.rows[0]["treatment"] == "treatment1"
+    assert result.rows[0]["is control?"] == False
+    assert result.rows[1]["replicate number"] == 2
+    assert result.rows[1]["treatment"] == "treatment1"
+
+
+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"