diff --git a/package-lock.json b/package-lock.json
index e4e0f060f..e6c9b4eed 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -26,7 +26,7 @@
                 "@codemirror/state": "~6.5.2",
                 "@codemirror/view": "~6.38.1",
                 "@egjs/hammerjs": "^2.0.17",
-                "@geoengine/openapi-client": "github:geo-engine/openapi-client#ogc_apis_fix",
+                "@geoengine/openapi-client": "github:geo-engine/openapi-client#tile_management",
                 "d3": "~7.9.0",
                 "dagre": "~0.8.5",
                 "dagre-d3": "~0.6.4",
@@ -3436,7 +3436,7 @@
         },
         "node_modules/@geoengine/openapi-client": {
             "name": "@geoengine/openapi-client-dev",
-            "resolved": "git+ssh://git@github.com/geo-engine/openapi-client.git#5de34f95c356e91d45f9855a5a4508c1789b70d8",
+            "resolved": "git+ssh://git@github.com/geo-engine/openapi-client.git#59146f76e6cee57556f3a6a3befe555ee0052e08",
             "workspaces": [
                 "typescript"
             ]
diff --git a/package.json b/package.json
index e2de834bb..4278110f1 100644
--- a/package.json
+++ b/package.json
@@ -66,7 +66,7 @@
         "@codemirror/state": "~6.5.2",
         "@codemirror/view": "~6.38.1",
         "@egjs/hammerjs": "^2.0.17",
-        "@geoengine/openapi-client": "github:geo-engine/openapi-client#ogc_apis_fix",
+        "@geoengine/openapi-client": "github:geo-engine/openapi-client#tile_management",
         "d3": "~7.9.0",
         "dagre": "~0.8.5",
         "dagre-d3": "~0.6.4",
diff --git a/projects/common/src/lib/datasets/datasets.service.ts b/projects/common/src/lib/datasets/datasets.service.ts
index e918c63c2..d41476d2f 100644
--- a/projects/common/src/lib/datasets/datasets.service.ts
+++ b/projects/common/src/lib/datasets/datasets.service.ts
@@ -1,10 +1,12 @@
 import {Injectable, inject} from '@angular/core';
 import {
+    AddDatasetTile,
     DataPath,
     Dataset,
     DatasetDefinition,
     DatasetListing,
     DatasetsApi,
+    DatasetTile,
     MetaDataDefinition,
     MetaDataSuggestion,
     OrderBy,
@@ -12,6 +14,7 @@ import {
     SuggestMetaDataHandlerRequest,
     Symbology,
     UpdateDataset,
+    UpdateDatasetTile,
     Volume,
     VolumeFileLayersResponse,
 } from '@geoengine/openapi-client';
@@ -132,4 +135,44 @@ export class DatasetsService {
 
         return uploadsApi.listVolumeFileLayersHandler({volumeName, fileName});
     }
+
+    async getDatasetTiles(datasetName: string, offset = 0, limit = 100): Promise<DatasetTile[]> {
+        const datasetApi = await firstValueFrom(this.datasetApi);
+
+        return datasetApi.getDatasetTilesHandler({
+            dataset: datasetName,
+            offset,
+            limit,
+        });
+    }
+
+    async updateDatasetTile(datasetName: string, tileId: string, update: UpdateDatasetTile): Promise<void> {
+        const datasetApi = await firstValueFrom(this.datasetApi);
+
+        return datasetApi.updateDatasetTileHandler({
+            dataset: datasetName,
+            tile: tileId,
+            updateDatasetTile: update,
+        });
+    }
+
+    async addDatasetTiles(datasetName: string, tiles: Array<AddDatasetTile>): Promise<string[]> {
+        const datasetApi = await firstValueFrom(this.datasetApi);
+
+        return datasetApi.addDatasetTilesHandler({
+            dataset: datasetName,
+            addDatasetTile: tiles,
+        });
+    }
+
+    async deleteDatasetTile(datasetName: string, tileIds: Array<string>): Promise<void> {
+        const datasetApi = await firstValueFrom(this.datasetApi);
+
+        return datasetApi.deleteDatasetTilesHandler({
+            dataset: datasetName,
+            deleteDatasetTiles: {
+                tileIds,
+            },
+        });
+    }
 }
diff --git a/projects/common/src/lib/measurement/measurement.component.html b/projects/common/src/lib/measurement/measurement.component.html
index cbd003c97..918537faf 100644
--- a/projects/common/src/lib/measurement/measurement.component.html
+++ b/projects/common/src/lib/measurement/measurement.component.html
@@ -1,5 +1,7 @@
 <div>
-    Output Measurement:
+    @if (showOutputMeasurementLabel()) {
+        Output Measurement:
+    }
     <mat-button-toggle-group
         id="measurement-type"
         [multiple]="false"
@@ -15,6 +17,7 @@
         <div>
             <mat-form-field appearance="fill">
                 <mat-label>Measurement</mat-label>
+
                 <input matInput type="text" required="true" [(ngModel)]="classificationMeasurement.measurement" />
             </mat-form-field>
         </div>
diff --git a/projects/common/src/lib/measurement/measurement.component.ts b/projects/common/src/lib/measurement/measurement.component.ts
index 63e4f6306..08e760262 100644
--- a/projects/common/src/lib/measurement/measurement.component.ts
+++ b/projects/common/src/lib/measurement/measurement.component.ts
@@ -1,4 +1,4 @@
-import {Component, Input, output} from '@angular/core';
+import {Component, input, Input, output} from '@angular/core';
 import {FormControl, FormGroup, Validators, FormsModule, ReactiveFormsModule} from '@angular/forms';
 import {ClassificationMeasurement, ContinuousMeasurement, Measurement, UnitlessMeasurement} from '@geoengine/openapi-client';
 import {MatButtonToggleGroup, MatButtonToggle} from '@angular/material/button-toggle';
@@ -40,6 +40,8 @@ export class MeasurementComponent {
 
     readonly measurementChange = output<Measurement>();
 
+    showOutputMeasurementLabel = input(true);
+
     MeasurementType = MeasurementType;
 
     classificationMeasurement?: ClassificationMeasurement;
diff --git a/projects/common/src/lib/time/time-interval-input/time-interval-input.component.ts b/projects/common/src/lib/time/time-interval-input/time-interval-input.component.ts
index 2026aafdb..a40630c0a 100644
--- a/projects/common/src/lib/time/time-interval-input/time-interval-input.component.ts
+++ b/projects/common/src/lib/time/time-interval-input/time-interval-input.component.ts
@@ -20,6 +20,7 @@ import {Time, TimeStepDuration} from '../time.model';
 import {TimeInputComponent} from '../time-input/time-input.component';
 import {FxLayoutDirective, FxLayoutAlignDirective} from '../../util/directives/flexbox-legacy.directive';
 import {MatSlideToggle} from '@angular/material/slide-toggle';
+import {TimeInterval as TimeIntervalDict} from '@geoengine/openapi-client';
 
 const startBeforeEndValidator = (control: AbstractControl): ValidationErrors | null => {
     if (!(control instanceof UntypedFormGroup)) {
@@ -49,6 +50,21 @@ export interface TimeInterval {
     end: Moment;
 }
 
+export function time_interval_from_dict(dict: TimeIntervalDict): TimeInterval {
+    return {
+        start: moment.utc(dict.start),
+        timeAsPoint: dict.start == dict.end,
+        end: moment.utc(dict.end),
+    };
+}
+
+export function time_interval_to_dict(interval: TimeInterval): TimeIntervalDict {
+    return {
+        start: interval.start.valueOf(),
+        end: interval.timeAsPoint ? interval.start.valueOf() : interval.end.valueOf(),
+    };
+}
+
 @Component({
     selector: 'geoengine-time-interval-input',
     templateUrl: './time-interval-input.component.html',
diff --git a/projects/common/src/lib/util/conversions.ts b/projects/common/src/lib/util/conversions.ts
index 1d75ab8ae..84e75041d 100644
--- a/projects/common/src/lib/util/conversions.ts
+++ b/projects/common/src/lib/util/conversions.ts
@@ -4,7 +4,14 @@ import OlFormatGeoJson from 'ol/format/GeoJSON';
 import OlGeometry from 'ol/geom/Geometry';
 import {Extent as OlExtent} from 'ol/extent';
 import {Observable, ReplaySubject} from 'rxjs';
-import {BoundingBox2D as BBoxDict, ResponseError} from '@geoengine/openapi-client';
+import {
+    BoundingBox2D as BBoxDict,
+    GdalDatasetParameters,
+    GeoTransform,
+    ResponseError,
+    SpatialGridDefinition,
+    SpatialPartition2D,
+} from '@geoengine/openapi-client';
 import {Time} from '../time/time.model';
 
 /**
@@ -144,3 +151,59 @@ export function estimateTimeFormat(timeSteps: Array<Time>): string {
 export function isDefined<T>(arg: T | null | undefined): arg is T {
     return arg !== null && arg !== undefined;
 }
+
+export function extractSpatialPartition(gdalParams: GdalDatasetParameters): SpatialPartition2D {
+    const geoTransform = gdalParams.geoTransform;
+
+    const x1 = geoTransform.originCoordinate.x;
+    const x2 = x1 + geoTransform.xPixelSize * gdalParams.width;
+    const y1 = geoTransform.originCoordinate.y;
+    const y2 = y1 + geoTransform.yPixelSize * gdalParams.height;
+
+    const minX = Math.min(x1, x2);
+    const maxX = Math.max(x1, x2);
+    const minY = Math.min(y1, y2);
+    const maxY = Math.max(y1, y2);
+
+    return {
+        lowerRightCoordinate: {x: maxX, y: minY},
+        upperLeftCoordinate: {x: minX, y: maxY},
+    };
+}
+
+export function spatialPartitionFromSpatialGridDefinition(grid: SpatialGridDefinition): SpatialPartition2D {
+    const geoTransform = grid.geoTransform;
+    const bounds = grid.gridBounds;
+
+    const minX = geoTransform.originCoordinate.x - geoTransform.xPixelSize * bounds.topLeftIdx.xIdx;
+    const maxX = geoTransform.originCoordinate.x + geoTransform.xPixelSize * bounds.bottomRightIdx.xIdx;
+
+    const minY = geoTransform.originCoordinate.y + geoTransform.yPixelSize * bounds.bottomRightIdx.yIdx;
+    const maxY = geoTransform.originCoordinate.y - geoTransform.yPixelSize * bounds.topLeftIdx.yIdx;
+
+    return {
+        lowerRightCoordinate: {x: maxX, y: minY},
+        upperLeftCoordinate: {x: minX, y: maxY},
+    };
+}
+
+export function spatialGridDefinitionFromSpatialPartitionAndGeoTransform(
+    spatialPartition: SpatialPartition2D,
+    geoTransform: GeoTransform,
+): SpatialGridDefinition {
+    const {originCoordinate, xPixelSize, yPixelSize} = geoTransform;
+
+    const topLeftXIdx = Math.round((spatialPartition.upperLeftCoordinate.x - originCoordinate.x) / xPixelSize);
+    const topLeftYIdx = Math.round((spatialPartition.upperLeftCoordinate.y - originCoordinate.y) / yPixelSize);
+
+    const bottomRightXIdx = Math.round((spatialPartition.lowerRightCoordinate.x - originCoordinate.x) / xPixelSize);
+    const bottomRightYIdx = Math.round((spatialPartition.lowerRightCoordinate.y - originCoordinate.y) / yPixelSize);
+
+    return {
+        geoTransform,
+        gridBounds: {
+            topLeftIdx: {xIdx: topLeftXIdx, yIdx: topLeftYIdx},
+            bottomRightIdx: {xIdx: bottomRightXIdx, yIdx: bottomRightYIdx},
+        },
+    };
+}
diff --git a/projects/manager/src/app/datasets/add-dataset/add-dataset.component.html b/projects/manager/src/app/datasets/add-dataset/add-dataset.component.html
index ccf19211a..27f6013fd 100644
--- a/projects/manager/src/app/datasets/add-dataset/add-dataset.component.html
+++ b/projects/manager/src/app/datasets/add-dataset/add-dataset.component.html
@@ -65,15 +65,19 @@ <h2 mat-dialog-title>Create new dataset</h2>
             </mat-card-header>
 
             <mat-card-content>
-                <mat-button-toggle-group id="data-type" [multiple]="false" formControlName="dataType" (change)="updateDataType()">
-                    <mat-button-toggle [value]="DataTypes.Raster">Raster</mat-button-toggle>
+                <mat-button-toggle-group id="data-type" [multiple]="false" formControlName="datasetType" (change)="updateDataType()">
+                    <mat-button-toggle [value]="DataTypes.SingleBandRaster">Single-BandRaster</mat-button-toggle>
+                    <mat-button-toggle [value]="DataTypes.MultiBandRaster">Multi-Band Raster</mat-button-toggle>
                     <mat-button-toggle [value]="DataTypes.Vector">Vector</mat-button-toggle>
                 </mat-button-toggle-group>
 
-                @switch (form.controls.dataType.value) {
-                    @case (DataTypes.Raster) {
+                @switch (form.controls.datasetType.value) {
+                    @case (DataTypes.SingleBandRaster) {
                         <geoengine-manager-gdal-metadata-list [dataPath]="dataPath()"></geoengine-manager-gdal-metadata-list>
                     }
+                    @case (DataTypes.MultiBandRaster) {
+                        <geoengine-manager-gdal-multiband [dataPath]="dataPath()"></geoengine-manager-gdal-multiband>
+                    }
                     @case (DataTypes.Vector) {
                         <geoengine-ogr-dataset
                             [uploadId]="form.controls.uploadId.value"
diff --git a/projects/manager/src/app/datasets/add-dataset/add-dataset.component.ts b/projects/manager/src/app/datasets/add-dataset/add-dataset.component.ts
index 26732d984..8c6babac0 100644
--- a/projects/manager/src/app/datasets/add-dataset/add-dataset.component.ts
+++ b/projects/manager/src/app/datasets/add-dataset/add-dataset.component.ts
@@ -13,14 +13,16 @@ import {MatSelect} from '@angular/material/select';
 import {MatOption} from '@angular/material/autocomplete';
 import {MatButton} from '@angular/material/button';
 import {AsyncPipe} from '@angular/common';
+import {GdalMultiBandComponent} from '../loading-info/gdal-multiband/gdal-multiband.component';
 
 enum DataPaths {
     Upload,
     Volume,
 }
 
-enum DataTypes {
-    Raster,
+enum DatasetTypes {
+    SingleBandRaster,
+    MultiBandRaster,
     Vector,
 }
 
@@ -30,7 +32,7 @@ export interface AddDatasetForm {
     dataPathType: FormControl<DataPaths>;
     uploadId: FormControl<string>;
     volumeName: FormControl<string>;
-    dataType: FormControl<DataTypes>;
+    datasetType: FormControl<DatasetTypes>;
     rawLoadingInfo: FormControl<string>;
 }
 
@@ -55,6 +57,7 @@ export interface AddDatasetForm {
         MatOption,
         GdalMetadataListComponent,
         OgrDatasetComponent,
+        GdalMultiBandComponent,
         MatButton,
         AsyncPipe,
     ],
@@ -66,10 +69,11 @@ export class AddDatasetComponent {
     private readonly dialog = inject(MatDialog);
 
     DataPaths = DataPaths;
-    DataTypes = DataTypes;
+    DataTypes = DatasetTypes;
 
     readonly gdalMetaDataList = viewChild(GdalMetadataListComponent);
     readonly ogrDatasetComponent = viewChild(OgrDatasetComponent);
+    readonly gdalMultiBandComponent = viewChild(GdalMultiBandComponent);
 
     volumes$ = new BehaviorSubject<VolumeDict[]>([]);
 
@@ -94,7 +98,7 @@ export class AddDatasetComponent {
             nonNullable: true,
             validators: [Validators.required],
         }),
-        dataType: new FormControl(DataTypes.Raster, {
+        datasetType: new FormControl(DatasetTypes.SingleBandRaster, {
             nonNullable: true,
             validators: [Validators.required],
         }),
@@ -126,7 +130,7 @@ export class AddDatasetComponent {
             },
         );
 
-        this.datasetsService.getVolumes().then((volumes) => {
+        void this.datasetsService.getVolumes().then((volumes) => {
             this.volumes$.next(volumes);
         });
     }
@@ -158,7 +162,7 @@ export class AddDatasetComponent {
     }
 
     updateDataType(): void {
-        if (this.form.controls.dataType.value === DataTypes.Raster) {
+        if (this.form.controls.datasetType.value === DatasetTypes.SingleBandRaster) {
             this.form.controls.rawLoadingInfo.clearValidators();
         } else {
             this.form.controls.rawLoadingInfo.setValidators([Validators.required]);
@@ -168,10 +172,11 @@ export class AddDatasetComponent {
     isCreateDisabled(): boolean {
         const general = this.form.pristine || this.form.invalid;
 
-        const raster = this.form.controls.dataType.value === DataTypes.Raster && (this.gdalMetaDataList()?.form?.invalid ?? false);
+        const raster =
+            this.form.controls.datasetType.value === DatasetTypes.SingleBandRaster && (this.gdalMetaDataList()?.form?.invalid ?? false);
 
         const vector =
-            this.form.controls.dataType.value === DataTypes.Vector && (this.ogrDatasetComponent()?.formMetaData?.invalid ?? false);
+            this.form.controls.datasetType.value === DatasetTypes.Vector && (this.ogrDatasetComponent()?.formMetaData?.invalid ?? false);
 
         return general || raster || vector;
     }
@@ -184,7 +189,7 @@ export class AddDatasetComponent {
         let sourceOperator = undefined;
         let metaData: MetaDataDefinition | undefined = undefined;
 
-        if (this.form.controls.dataType.value === DataTypes.Raster) {
+        if (this.form.controls.datasetType.value === DatasetTypes.SingleBandRaster) {
             const gdalMetaDataList = this.gdalMetaDataList();
             if (!gdalMetaDataList) {
                 return;
@@ -193,7 +198,16 @@ export class AddDatasetComponent {
             metaData = gdalMetaDataList.getMetaData();
 
             sourceOperator = 'GdalSource';
-        } else if (this.form.controls.dataType.value === DataTypes.Vector) {
+        } else if (this.form.controls.datasetType.value === DatasetTypes.MultiBandRaster) {
+            const gdalMultiBandComponent = this.gdalMultiBandComponent();
+            if (!gdalMultiBandComponent) {
+                return;
+            }
+
+            metaData = gdalMultiBandComponent.getMetaData();
+
+            sourceOperator = 'MultiBandGdalSource';
+        } else if (this.form.controls.datasetType.value === DatasetTypes.Vector) {
             const ogrDatasetComponent = this.ogrDatasetComponent();
             if (!ogrDatasetComponent) {
                 return;
diff --git a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.html b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.html
index aedbe6bf3..7f574eece 100644
--- a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.html
+++ b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.html
@@ -55,6 +55,37 @@
                             }
                         </mat-chip-grid>
                     </mat-form-field>
+                    @if (dataset.dataPath) {
+                        <div>
+                            <mat-button-toggle-group
+                                id="path-type"
+                                [multiple]="false"
+                                formControlName="dataPathType"
+                                (ngModelChange)="updateDataPathType()"
+                            >
+                                <mat-button-toggle [value]="DataPaths.Upload">Upload</mat-button-toggle>
+                                <mat-button-toggle [value]="DataPaths.Volume">Volume</mat-button-toggle>
+                            </mat-button-toggle-group>
+
+                            @if (form.controls.dataPathType.value === DataPaths.Upload) {
+                                <mat-form-field appearance="fill">
+                                    <mat-label>Upload Id</mat-label>
+                                    <input matInput type="text" formControlName="uploadId" />
+                                </mat-form-field>
+                            } @else {
+                                <mat-form-field appearance="fill">
+                                    <mat-label>Volume</mat-label>
+                                    <mat-select formControlName="volumeName">
+                                        @for (volume of volumes$ | async; track volume) {
+                                            <mat-option [value]="volume.name">
+                                                {{ volume.name }}
+                                            </mat-option>
+                                        }
+                                    </mat-select>
+                                </mat-form-field>
+                            }
+                        </div>
+                    }
                 </form>
 
                 <div class="actions">
@@ -114,8 +145,26 @@
             <mat-card-content>
                 @if (gdalMetaDataList) {
                     <geoengine-manager-gdal-metadata-list [metaData]="gdalMetaDataList"></geoengine-manager-gdal-metadata-list>
+                    <div class="actions">
+                        <button mat-raised-button color="primary" [disabled]="isSaveLoadingInfoDisabled()" (click)="saveLoadingInfo()">
+                            Apply
+                        </button>
+                    </div>
+                } @else if (gdalMultiBand) {
+                    @if (dataset && dataset.dataPath) {
+                        <geoengine-manager-gdal-multiband-editor
+                            [metaData]="gdalMultiBand"
+                            [dataPath]="dataset.dataPath"
+                            [datasetName]="dataset.name"
+                        ></geoengine-manager-gdal-multiband-editor>
+                    }
                 } @else if (ogrMetaData) {
                     <geoengine-ogr-dataset [metaData]="ogrMetaData"></geoengine-ogr-dataset>
+                    <div class="actions">
+                        <button mat-raised-button color="primary" [disabled]="isSaveLoadingInfoDisabled()" (click)="saveLoadingInfo()">
+                            Apply
+                        </button>
+                    </div>
                 } @else {
                     <geoengine-code-editor
                         [ngModel]="rawLoadingInfo"
@@ -123,12 +172,12 @@
                         [ngModelOptions]="{standalone: true}"
                         language="JSON"
                     ></geoengine-code-editor>
+                    <div class="actions">
+                        <button mat-raised-button color="primary" [disabled]="isSaveLoadingInfoDisabled()" (click)="saveLoadingInfo()">
+                            Apply
+                        </button>
+                    </div>
                 }
-                <div class="actions">
-                    <button mat-raised-button color="primary" [disabled]="isSaveLoadingInfoDisabled()" (click)="saveLoadingInfo()">
-                        Apply
-                    </button>
-                </div>
             </mat-card-content>
         </mat-card>
 
diff --git a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.scss b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.scss
index d2f0e6fe1..cf92f0ce9 100644
--- a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.scss
+++ b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.scss
@@ -48,3 +48,7 @@ textarea {
     overflow: auto;
     resize: none;
 }
+
+#path-type {
+    margin-bottom: 0.5rem;
+}
diff --git a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.ts b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.ts
index edd79ef36..cf1cfe468 100644
--- a/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.ts
+++ b/projects/manager/src/app/datasets/dataset-editor/dataset-editor.component.ts
@@ -32,11 +32,15 @@ import {
     Dataset,
     DatasetListing,
     GdalMetaDataList,
+    GdalMultiBand,
+    instanceOfDataPathOneOf,
+    instanceOfDataPathOneOf1,
     MetaDataDefinition,
     OgrMetaData,
     TypedRasterResultDescriptor,
     TypedResultDescriptor,
     TypedVectorResultDescriptor,
+    Volume as VolumeDict,
 } from '@geoengine/openapi-client';
 import {BehaviorSubject, firstValueFrom} from 'rxjs';
 import {ProvenanceComponent} from '../../provenance/provenance.component';
@@ -51,6 +55,10 @@ import {RasterResultDescriptorComponent} from '../../result-descriptors/raster-r
 import {VectorResultDescriptorComponent} from '../../result-descriptors/vector-result-descriptor/vector-result-descriptor.component';
 import {PermissionsComponent} from '../../permissions/permissions.component';
 import {AsyncPipe} from '@angular/common';
+import {GdalMultiBandEditorComponent} from '../loading-info/gdal-multiband-editor/gdal-multiband-editor.component';
+import {MatButtonToggle, MatButtonToggleGroup} from '@angular/material/button-toggle';
+import {MatOption} from '@angular/material/autocomplete';
+import {MatSelect} from '@angular/material/select';
 
 export interface DatasetForm {
     layerType: FormControl<'plot' | 'raster' | 'vector'>;
@@ -60,6 +68,14 @@ export interface DatasetForm {
     description: FormControl<string>;
     tags: FormControl<string[]>;
     newTag: FormControl<string>;
+    dataPathType: FormControl<DataPaths>;
+    uploadId: FormControl<string>;
+    volumeName: FormControl<string>;
+}
+
+enum DataPaths {
+    Upload,
+    Volume,
 }
 
 @Component({
@@ -73,6 +89,8 @@ export interface DatasetForm {
         MatCardContent,
         FormsModule,
         ReactiveFormsModule,
+        MatButtonToggle,
+        MatButtonToggleGroup,
         MatFormField,
         MatLabel,
         MatInput,
@@ -81,11 +99,14 @@ export interface DatasetForm {
         MatIcon,
         MatChipRemove,
         MatChipInput,
+        MatSelect,
+        MatOption,
         MatError,
         MatButton,
         ProvenanceComponent,
         SymbologyEditorComponent,
         GdalMetadataListComponent,
+        GdalMultiBandEditorComponent,
         OgrDatasetComponent,
         RasterResultDescriptorComponent,
         VectorResultDescriptorComponent,
@@ -115,8 +136,12 @@ export class DatasetEditorComponent {
     readonly tagInput = viewChild.required(MatChipInput);
     readonly provenanceComponent = viewChild.required(ProvenanceComponent);
     readonly gdalMetadataListComponent = viewChild(GdalMetadataListComponent);
+    readonly gdalMultiBandComponent = viewChild.required(GdalMultiBandEditorComponent);
     readonly ogrDatasetComponent = viewChild(OgrDatasetComponent);
 
+    DataPaths = DataPaths;
+    volumes$ = new BehaviorSubject<VolumeDict[]>([]);
+
     dataset?: Dataset;
     form: FormGroup<DatasetForm> = this.placeholderForm();
 
@@ -128,12 +153,17 @@ export class DatasetEditorComponent {
     rawLoadingInfo = '';
     rawLoadingInfoPristine = true;
     gdalMetaDataList?: GdalMetaDataList;
+    gdalMultiBand?: GdalMultiBand;
     ogrMetaData?: OgrMetaData;
 
     constructor() {
         effect(() => {
             void this.loadDataset(this._datasetListing());
         });
+
+        void this.datasetsService.getVolumes().then((volumes) => {
+            this.volumes$.next(volumes);
+        });
     }
 
     private async loadDataset(datasetListing: DatasetListing): Promise<void> {
@@ -146,18 +176,27 @@ export class DatasetEditorComponent {
         const loadingInfo = await this.datasetsService.getLoadingInfo(this.dataset.name);
         if (loadingInfo.type === 'GdalMetaDataList') {
             this.gdalMetaDataList = loadingInfo;
+            this.gdalMultiBand = undefined;
+            this.ogrMetaData = undefined;
+            this.rawLoadingInfo = '';
+        } else if (loadingInfo.type === 'GdalMultiBand') {
+            this.gdalMultiBand = loadingInfo;
+            this.gdalMetaDataList = undefined;
             this.ogrMetaData = undefined;
             this.rawLoadingInfo = '';
         } else if (loadingInfo.type === 'OgrMetaData') {
             this.ogrMetaData = loadingInfo;
             this.gdalMetaDataList = undefined;
+            this.gdalMultiBand = undefined;
             this.rawLoadingInfo = '';
         } else {
             this.gdalMetaDataList = undefined;
+            this.gdalMultiBand = undefined;
             this.ogrMetaData = undefined;
             this.rawLoadingInfo = JSON.stringify(loadingInfo, null, 2);
             this.rawLoadingInfoPristine = true;
         }
+        this.updateDataPathType();
         this.changeDetectorRef.detectChanges();
     }
 
@@ -170,10 +209,22 @@ export class DatasetEditorComponent {
         const displayName = this.form.controls.displayName.value;
         const description = this.form.controls.description.value;
         const tags = this.form.controls.tags.value;
+        let dataPath = null;
+        if (this.dataset?.dataPath) {
+            if (this.form.controls.dataPathType.value === DataPaths.Upload) {
+                dataPath = {
+                    upload: this.form.controls.uploadId.value,
+                };
+            } else {
+                dataPath = {
+                    volume: this.form.controls.volumeName.value,
+                };
+            }
+        }
 
         try {
             const datasetListing = this.datasetListing();
-            await this.datasetsService.updateDataset(datasetListing.name, {name, displayName, description, tags});
+            await this.datasetsService.updateDataset(datasetListing.name, {name, displayName, description, tags, dataPath});
             datasetListing.name = name;
             datasetListing.displayName = displayName;
             datasetListing.description = description;
@@ -213,6 +264,31 @@ export class DatasetEditorComponent {
         this.form.markAsDirty();
     }
 
+    updateDataPathType(): void {
+        if (!this.dataset?.dataPath) {
+            this.form.controls.uploadId.clearValidators();
+            this.form.controls.uploadId.updateValueAndValidity();
+            this.form.controls.volumeName.clearValidators();
+            this.form.controls.volumeName.updateValueAndValidity();
+            return;
+        }
+
+        switch (this.form.controls.dataPathType.value) {
+            case DataPaths.Upload:
+                this.form.controls.uploadId.setValidators([Validators.required]);
+                this.form.controls.uploadId.updateValueAndValidity();
+                this.form.controls.volumeName.clearValidators();
+                this.form.controls.volumeName.updateValueAndValidity();
+                break;
+            case DataPaths.Volume:
+                this.form.controls.volumeName.setValidators([Validators.required]);
+                this.form.controls.volumeName.updateValueAndValidity();
+                this.form.controls.uploadId.clearValidators();
+                this.form.controls.uploadId.updateValueAndValidity();
+                break;
+        }
+    }
+
     async saveProvenance(): Promise<void> {
         const provenanceComponent = this.provenanceComponent();
         if (!provenanceComponent.form.valid) {
@@ -253,7 +329,7 @@ export class DatasetEditorComponent {
             data: {message: 'Confirm the deletion of the dataset. This cannot be undone.'},
         });
 
-        const confirm = await firstValueFrom(dialogRef.afterClosed());
+        const confirm = (await firstValueFrom(dialogRef.afterClosed())) as boolean;
 
         if (!confirm) {
             return;
@@ -356,7 +432,7 @@ export class DatasetEditorComponent {
             return this.workflowsService.registerWorkflow({
                 type: 'Raster',
                 operator: {
-                    type: 'GdalSource',
+                    type: dataset.sourceOperator,
                     params: {
                         data: dataset.name,
                     },
@@ -447,6 +523,24 @@ export class DatasetEditorComponent {
                 validators: [geoengineValidators.duplicateValidator()],
             }),
             newTag: new FormControl('', {nonNullable: true, validators: [tagValidator()]}),
+            dataPathType: new FormControl(
+                dataset.dataPath ? (instanceOfDataPathOneOf(dataset.dataPath) ? DataPaths.Volume : DataPaths.Upload) : DataPaths.Volume,
+                {
+                    nonNullable: true,
+                    validators: [],
+                },
+            ),
+            uploadId: new FormControl(dataset.dataPath ? (instanceOfDataPathOneOf1(dataset.dataPath) ? dataset.dataPath.upload : '') : '', {
+                nonNullable: true,
+                validators: [],
+            }),
+            volumeName: new FormControl(
+                dataset.dataPath ? (instanceOfDataPathOneOf(dataset.dataPath) ? dataset.dataPath.volume : '') : '',
+                {
+                    nonNullable: true,
+                    validators: [],
+                },
+            ),
         });
     }
 
@@ -473,6 +567,18 @@ export class DatasetEditorComponent {
             }),
             tags: new FormControl<string[]>([], {nonNullable: true, validators: [geoengineValidators.duplicateValidator()]}),
             newTag: new FormControl('', {nonNullable: true, validators: [tagValidator()]}),
+            dataPathType: new FormControl(DataPaths.Volume, {
+                nonNullable: true,
+                validators: [],
+            }),
+            uploadId: new FormControl('', {
+                nonNullable: true,
+                validators: [],
+            }),
+            volumeName: new FormControl('', {
+                nonNullable: true,
+                validators: [],
+            }),
         });
     }
 }
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.html b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.html
new file mode 100644
index 000000000..dfe4978fe
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.html
@@ -0,0 +1,13 @@
+<geoengine-manager-gdal-multiband
+    [resultDescriptor]="metaData().resultDescriptor"
+    [dataPath]="dataPath()"
+    [datasetName]="datasetName()"
+></geoengine-manager-gdal-multiband>
+
+<mat-divider></mat-divider>
+
+<geoengine-manager-gdal-multiband-tiles
+    [dataPath]="dataPath()"
+    [datasetName]="datasetName()"
+    [bands]="metaData().resultDescriptor.bands"
+></geoengine-manager-gdal-multiband-tiles>
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.scss b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.scss
new file mode 100644
index 000000000..f5fff1462
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.scss
@@ -0,0 +1,8 @@
+:host {
+    width: 100%;
+    display: block;
+}
+
+mat-divider {
+    margin: 2rem 0;
+}
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.ts b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.ts
new file mode 100644
index 000000000..c02b9b976
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-editor/gdal-multiband-editor.component.ts
@@ -0,0 +1,18 @@
+import {ChangeDetectionStrategy, Component, input} from '@angular/core';
+import {DataPath, GdalMultiBand} from '@geoengine/openapi-client';
+import {GdalMultiBandComponent} from '../gdal-multiband/gdal-multiband.component';
+import {GdalMultiBandTilesComponent} from '../gdal-multiband-tiles/gdal-multiband-tiles.component';
+import {MatDivider} from '@angular/material/list';
+
+@Component({
+    selector: 'geoengine-manager-gdal-multiband-editor',
+    templateUrl: './gdal-multiband-editor.component.html',
+    styleUrl: './gdal-multiband-editor.component.scss',
+    changeDetection: ChangeDetectionStrategy.OnPush,
+    imports: [GdalMultiBandComponent, GdalMultiBandTilesComponent, MatDivider],
+})
+export class GdalMultiBandEditorComponent {
+    readonly dataPath = input<DataPath>();
+    readonly metaData = input.required<GdalMultiBand>();
+    readonly datasetName = input.required<string>();
+}
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.html b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.html
new file mode 100644
index 000000000..5a00678a0
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.html
@@ -0,0 +1,123 @@
+<div class="container">
+    <div class="left">
+        @if (editMode === EditMode.Created) {
+            <button mat-stroked-button class="browseButton" (click)="backToAllTiles()">
+                <mat-icon>chevron_left</mat-icon>Back to all datasets
+            </button>
+            <mat-nav-list>
+                <mat-list-item class="selected">
+                    <h4 matListItemTitle>{{ createdTileName }}</h4>
+                    <p matListItemLine>{{ createdTileId }}</p>
+                </mat-list-item></mat-nav-list
+            >
+        }
+        @if (editMode === EditMode.Update || editMode === EditMode.Create) {
+            <button mat-raised-button color="primary" class="add-dataset" (click)="addTile()"><mat-icon>add</mat-icon></button>
+            <cdk-virtual-scroll-viewport [itemSize]="itemSizePx" (scrolledIndexChange)="onScrolledIndexChange($event)">
+                <mat-nav-list>
+                    <ng-container *cdkVirtualFor="let item of source; trackBy: trackById">
+                        <mat-list-item [class.selected]="(selectedTileId$ | async) === item.id" (click)="select(item)">
+                            <h4 matListItemTitle>{{ tileTitle(item.params.filePath) }}</h4>
+                            <p matListItemLine>{{ item.id }}</p>
+                        </mat-list-item>
+                    </ng-container>
+                </mat-nav-list>
+
+                @if (source?.loading$ | async) {
+                    <mat-spinner [diameter]="loadingSpinnerDiameterPx"></mat-spinner>
+                }
+            </cdk-virtual-scroll-viewport>
+        }
+    </div>
+
+    <div class="tile-editor">
+        <form [formGroup]="tileForm">
+            @switch (editMode) {
+                @case (EditMode.Create) {
+                    <h2>Create New Tile</h2>
+                }
+                @case (EditMode.Update) {
+                    <h2>Edit Tile {{ selectedTileId$ | async }}</h2>
+                }
+            }
+            <div class="flex-container">
+                <mat-form-field appearance="fill">
+                    <mat-label>Path to probe file, relative to upload or volume (optional)</mat-label>
+                    <input matInput type="text" [(ngModel)]="probeFileTileProperties" [ngModelOptions]="{standalone: true}" />
+                </mat-form-field>
+                <button mat-raised-button class="analyze" (click)="suggestTileProperties()">Analyze file and suggest properties</button>
+            </div>
+
+            <mat-divider></mat-divider>
+
+            <h2>Tile Metadata</h2>
+
+            <h3 class="mat-subtitle-1">Bounding Box</h3>
+            <div formGroupName="bbox" class="bbox-fields">
+                <mat-form-field appearance="fill">
+                    <mat-label>min X</mat-label>
+                    <input matInput type="number" formControlName="bboxMinX" />
+                </mat-form-field>
+                <mat-form-field appearance="fill">
+                    <mat-label>min Y</mat-label>
+                    <input matInput type="number" formControlName="bboxMinY" />
+                </mat-form-field>
+                <mat-form-field appearance="fill">
+                    <mat-label>max X</mat-label>
+                    <input matInput type="number" formControlName="bboxMaxX" />
+                </mat-form-field>
+                <mat-form-field appearance="fill">
+                    <mat-label>max Y</mat-label>
+                    <input matInput type="number" formControlName="bboxMaxY" />
+                </mat-form-field>
+            </div>
+
+            <mat-divider></mat-divider>
+
+            <geoengine-time-interval-input [formControl]="tileForm.controls.time"></geoengine-time-interval-input>
+
+            <mat-divider></mat-divider>
+
+            <mat-form-field appearance="fill">
+                <mat-label>Raster Band</mat-label>
+                <mat-select formControlName="band">
+                    @for (i of bandIndices; track i) {
+                        <mat-option [value]="i">
+                            {{ bands()[i].name || 'Band ' + i }}
+                        </mat-option>
+                    }
+                </mat-select>
+            </mat-form-field>
+
+            <mat-divider></mat-divider>
+
+            <mat-form-field appearance="fill">
+                <mat-label>Z-Index (higher value means more priority when overlapping with other tiles)</mat-label>
+                <input matInput type="number" formControlName="zIndex" />
+            </mat-form-field>
+
+            <mat-divider></mat-divider>
+
+            <h2>File Loading Parameters</h2>
+
+            <geoengine-manager-gdal-dataset-parameters
+                [form]="tileForm.controls.gdalParameters"
+                [dataPath]="dataPath()"
+            ></geoengine-manager-gdal-dataset-parameters>
+
+            <div class="actions">
+                @switch (editMode) {
+                    @case (EditMode.Update) {
+                        <button mat-raised-button color="primary" [disabled]="tileForm.pristine || tileForm.invalid" (click)="saveTile()">
+                            Apply
+                        </button>
+                        <button mat-raised-button color="warn" (click)="deleteTile()">Delete</button>
+                    }
+                    @case (EditMode.Create) {
+                        <button mat-raised-button color="primary" [disabled]="tileForm.invalid" (click)="createTile()">Create</button>
+                    }
+                }
+            </div>
+        </form>
+    </div>
+</div>
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.scss b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.scss
new file mode 100644
index 000000000..5b7375e2a
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.scss
@@ -0,0 +1,96 @@
+:host {
+    width: 100%;
+    display: block;
+}
+
+.container {
+    display: flex;
+    height: 100%;
+    width: 100%;
+}
+
+.left {
+    flex: 0 0 25%;
+    overflow: hidden;
+}
+
+.tile-editor {
+    width: calc(75% - 1rem);
+    margin: 1rem;
+}
+
+.selected {
+    background-color: var(--geoengine-primary-color);
+}
+
+mat-form-field {
+    width: 100%;
+}
+
+mat-divider {
+    margin-bottom: 1rem;
+}
+
+geoengine-time-interval-input {
+    padding: 0;
+}
+
+.flex-container {
+    display: flex;
+    justify-content: space-between;
+    gap: 1rem;
+}
+
+.analyze {
+    height: 3rem;
+}
+
+.bbox-fields {
+    display: grid;
+    grid-template-columns: 1fr 1fr 1fr 1fr;
+    gap: 1rem;
+
+    mat-form-field {
+        width: 100%;
+    }
+}
+
+mat-nav-list {
+    height: 100%;
+    width: 100%;
+}
+
+mat-list-item {
+    width: 100%;
+
+    h4,
+    p {
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+}
+
+cdk-virtual-scroll-viewport {
+    height: 100%;
+}
+
+.actions {
+    text-align: right;
+    height: 3rem;
+    padding: 1rem;
+
+    button {
+        margin: 0.5rem;
+    }
+}
+
+.add-dataset {
+    width: 100%;
+    margin-bottom: 0.5rem;
+}
+
+.browseButton {
+    width: 100%;
+    margin-bottom: 0.5rem;
+}
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.ts b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.ts
new file mode 100644
index 000000000..d301ddfc6
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband-tiles/gdal-multiband-tiles.component.ts
@@ -0,0 +1,579 @@
+import {ChangeDetectionStrategy, ChangeDetectorRef, Component, OnChanges, SimpleChanges, inject, input, viewChild} from '@angular/core';
+import {FormControl, FormGroup, Validators, FormsModule, ReactiveFormsModule} from '@angular/forms';
+import {GdalDatasetParametersComponent, GdalDatasetParametersForm} from '../gdal-dataset-parameters/gdal-dataset-parameters.component';
+import {
+    CommonModule,
+    DatasetsService,
+    TimeInterval,
+    TimeIntervalInputComponent,
+    errorToText,
+    time_interval_from_dict,
+    time_interval_to_dict,
+    extractSpatialPartition,
+    ConfirmationComponent,
+    geoengineValidators,
+} from '@geoengine/common';
+import moment from 'moment';
+import {DataPath, DatasetTile, GdalDatasetParameters, MetaDataSuggestion, RasterBandDescriptor} from '@geoengine/openapi-client';
+import {MatSnackBar} from '@angular/material/snack-bar';
+import {MatFormField, MatLabel, MatInput} from '@angular/material/input';
+import {MatButton} from '@angular/material/button';
+import {MatDivider, MatNavList, MatListItem, MatListItemTitle, MatListItemLine} from '@angular/material/list';
+import {MatSelect, MatOption} from '@angular/material/select';
+import {MatIcon} from '@angular/material/icon';
+import {MatProgressSpinner} from '@angular/material/progress-spinner';
+import {DataSource} from '@angular/cdk/collections';
+import {BehaviorSubject, concatMap, Observable, range, scan, startWith, Subject, Subscription, firstValueFrom} from 'rxjs';
+import {CdkVirtualScrollViewport, CdkFixedSizeVirtualScroll, CdkVirtualForOf} from '@angular/cdk/scrolling';
+import {AppConfig} from '../../../app-config.service';
+import {MatDialog} from '@angular/material/dialog';
+
+export interface TileForm {
+    time: FormControl<TimeInterval>;
+    bbox: FormGroup<BboxForm>;
+    band: FormControl<number>;
+    zIndex: FormControl<number>;
+    gdalParameters: FormGroup<GdalDatasetParametersForm>;
+}
+
+export interface BboxForm {
+    bboxMinX: FormControl<number>;
+    bboxMinY: FormControl<number>;
+    bboxMaxX: FormControl<number>;
+    bboxMaxY: FormControl<number>;
+}
+
+enum EditMode {
+    Create,
+    Created,
+    Update,
+}
+
+@Component({
+    selector: 'geoengine-manager-gdal-multiband-tiles',
+    templateUrl: './gdal-multiband-tiles.component.html',
+    styleUrl: './gdal-multiband-tiles.component.scss',
+    changeDetection: ChangeDetectionStrategy.OnPush,
+    imports: [
+        FormsModule,
+        ReactiveFormsModule,
+        MatFormField,
+        MatLabel,
+        MatInput,
+        MatButton,
+        MatDivider,
+        MatSelect,
+        MatOption,
+        MatIcon,
+        MatNavList,
+        MatListItem,
+        MatListItemTitle,
+        MatListItemLine,
+        CommonModule,
+        GdalDatasetParametersComponent,
+        TimeIntervalInputComponent,
+        CdkVirtualScrollViewport,
+        CdkFixedSizeVirtualScroll,
+        CdkVirtualForOf,
+        MatProgressSpinner,
+    ],
+})
+export class GdalMultiBandTilesComponent implements OnChanges {
+    private readonly datasetsService = inject(DatasetsService);
+    private readonly snackBar = inject(MatSnackBar);
+    private readonly dialog = inject(MatDialog);
+    private readonly config = inject(AppConfig);
+    private readonly changeDetectorRef = inject(ChangeDetectorRef);
+
+    readonly itemSizePx = 72;
+    readonly loadingSpinnerDiameterPx: number = 3 * parseFloat(getComputedStyle(document.documentElement).fontSize);
+
+    readonly viewport = viewChild.required(CdkVirtualScrollViewport);
+
+    readonly dataPath = input<DataPath>();
+    readonly datasetName = input.required<string>();
+    readonly bands = input.required<Array<RasterBandDescriptor>>();
+
+    EditMode = EditMode;
+    editMode = EditMode.Update;
+
+    source?: TileDataSource;
+    private sourceSubscription?: Subscription;
+
+    tileForm: FormGroup<TileForm> = this.setUpPlaceHolderTileForm();
+
+    probeFileTileProperties = '';
+
+    selectedTile?: DatasetTile;
+    // hold only the selected tile id for stable identity comparison in the virtual scroll
+    selectedTileId$ = new BehaviorSubject<string | undefined>(undefined);
+
+    createdTileName?: string;
+    createdTileId?: string;
+
+    setUpSource(): void {
+        this.source = new TileDataSource(this.datasetsService, this.datasetName());
+        // calculate initial number of elements to display in `setTimeout` because the viewport is not yet initialized
+        setTimeout(() => {
+            this.source?.init(this.calculateInitialNumberOfElements());
+        });
+
+        // select the first tile in list
+        this.sourceSubscription?.unsubscribe();
+        if (this.source) {
+            this.sourceSubscription = this.source.connect().subscribe((items) => {
+                if (items.length > 0) {
+                    setTimeout(() => {
+                        this.editMode = EditMode.Update;
+                        this.selectedTileId$.next(items[0].id);
+                        this.tileForm = this.setUpTileForm(items[0]);
+                        this.changeDetectorRef.markForCheck();
+                    }, 0);
+                } else {
+                    setTimeout(() => {
+                        this.editMode = EditMode.Create;
+                        this.selectedTileId$.next(undefined);
+                        this.tileForm = this.setUpPlaceHolderTileForm();
+                        this.changeDetectorRef.markForCheck();
+                    }, 0);
+                }
+            });
+        }
+    }
+
+    /**
+     * Fetch new data when scrolled to the end of the list.
+     */
+    onScrolledIndexChange(_scrolledIndex: number): void {
+        const end = this.viewport().getRenderedRange().end;
+        const total = this.viewport().getDataLength();
+
+        // only fetch when scrolled to the end
+        if (end >= total) {
+            this.source?.fetchMoreData(1);
+        }
+    }
+
+    trackById(_index: number, item: DatasetTile): string {
+        return item.id;
+    }
+
+    // return an array of indices for the raster bands to iterate over in the template
+    get bandIndices(): number[] {
+        const bands = this.bands() ?? [];
+        return Array.from({length: bands.length}, (_, i) => i);
+    }
+
+    async select(item: DatasetTile): Promise<void> {
+        if (!item) {
+            return;
+        }
+
+        if (this.tileForm.dirty) {
+            const confirmDialogRef = this.dialog.open(ConfirmationComponent, {
+                data: {message: 'Do you really want to stop editing the tile? All changes will be lost.'},
+            });
+
+            const confirm = (await firstValueFrom(confirmDialogRef.afterClosed())) as boolean;
+
+            if (!confirm) {
+                return;
+            }
+        }
+
+        this.editMode = EditMode.Update;
+
+        this.selectedTileId$.next(item.id);
+        this.selectedTile = item;
+        this.tileForm = this.setUpTileForm(item);
+    }
+
+    addTile(): void {
+        this.editMode = EditMode.Create;
+        this.tileForm = this.setUpPlaceHolderTileForm();
+        this.selectedTileId$.next(undefined);
+    }
+
+    tileTitle(filePath: string): string {
+        const lastSlash = filePath.lastIndexOf('/');
+        const lastDot = filePath.lastIndexOf('.');
+        const start = lastSlash === -1 ? 0 : lastSlash + 1;
+        const end = lastDot === -1 || lastDot < start ? filePath.length : lastDot;
+        return filePath.substring(start, end);
+    }
+
+    ngOnChanges(_changes: SimpleChanges): void {
+        this.setUpSource();
+        this.tileForm = this.setUpPlaceHolderTileForm();
+    }
+
+    async saveTile(): Promise<void> {
+        if (this.tileForm.invalid || !this.selectedTileId$.value) {
+            return;
+        }
+
+        const tileId = this.selectedTileId$.value;
+        const time = this.tileForm.controls.time.value;
+        const bboxControls = this.tileForm.controls.bbox.controls;
+        const spatialPartition = {
+            lowerRightCoordinate: {
+                x: bboxControls.bboxMaxX.value,
+                y: bboxControls.bboxMinY.value,
+            },
+            upperLeftCoordinate: {
+                x: bboxControls.bboxMinX.value,
+                y: bboxControls.bboxMaxY.value,
+            },
+        };
+
+        const params = this.getGdalParameters(this.tileForm.controls.gdalParameters);
+
+        const update = {
+            band: this.tileForm.controls.band.value,
+            params,
+            spatialPartition,
+            time: {
+                start: time.start.valueOf(),
+                end: time.end.valueOf(),
+            },
+            zIndex: this.tileForm.controls.zIndex.value,
+        };
+
+        try {
+            await this.datasetsService.updateDatasetTile(this.datasetName(), tileId, update);
+            this.snackBar.open('Tile successfully saved.', 'Close', {duration: this.config.DEFAULTS.SNACKBAR_DURATION});
+            this.tileForm.markAsPristine();
+
+            // update in source, s.t. selecting the tile again shows updated data
+            if (this.selectedTile) {
+                this.selectedTile.band = update.band;
+                this.selectedTile.params = update.params;
+                this.selectedTile.spatialPartition = spatialPartition;
+                this.selectedTile.time = {
+                    start: update.time.start,
+                    end: update.time.end,
+                };
+                this.selectedTile.zIndex = update.zIndex;
+            }
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Saving tile failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    async deleteTile(): Promise<void> {
+        if (!this.selectedTileId$.value) {
+            return;
+        }
+
+        const dialogRef = this.dialog.open(ConfirmationComponent, {
+            data: {message: 'Confirm the deletion of the tile. This cannot be undone.'},
+        });
+
+        const confirm = (await firstValueFrom(dialogRef.afterClosed())) as boolean;
+
+        if (!confirm) {
+            return;
+        }
+
+        try {
+            const tileId = this.selectedTileId$.value;
+            await this.datasetsService.deleteDatasetTile(this.datasetName(), [tileId]);
+            this.snackBar.open('Tile successfully deleted.', 'Close', {duration: this.config.DEFAULTS.SNACKBAR_DURATION});
+
+            this.setUpSource();
+            this.changeDetectorRef.markForCheck();
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Deleting tile failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    async createTile(): Promise<void> {
+        if (this.tileForm.invalid) {
+            return;
+        }
+
+        const time = this.tileForm.controls.time.value;
+        const bboxControls = this.tileForm.controls.bbox.controls;
+        const spatialPartition = {
+            lowerRightCoordinate: {
+                x: bboxControls.bboxMaxX.value,
+                y: bboxControls.bboxMinY.value,
+            },
+            upperLeftCoordinate: {
+                x: bboxControls.bboxMinX.value,
+                y: bboxControls.bboxMaxY.value,
+            },
+        };
+
+        const params = this.getGdalParameters(this.tileForm.controls.gdalParameters);
+
+        const add = {
+            band: this.tileForm.controls.band.value,
+            params,
+            spatialPartition,
+            time: {
+                start: time.start.valueOf(),
+                end: time.end.valueOf(),
+            },
+            zIndex: this.tileForm.controls.zIndex.value,
+        };
+
+        try {
+            const tilesIds = await this.datasetsService.addDatasetTiles(this.datasetName(), [add]);
+            this.createdTileId = tilesIds[0];
+            this.createdTileName = this.tileTitle(params.filePath);
+            this.editMode = EditMode.Created;
+
+            this.snackBar.open('Tile successfully created.', 'Close', {duration: this.config.DEFAULTS.SNACKBAR_DURATION});
+            this.changeDetectorRef.markForCheck();
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Creating tile failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    backToAllTiles(): void {
+        this.setUpSource();
+        this.editMode = EditMode.Update;
+    }
+
+    getGdalParameters(form: FormGroup<GdalDatasetParametersForm>): GdalDatasetParameters {
+        return {
+            allowAlphabandAsMask: form.controls.allowAlphabandAsMask.value,
+            fileNotFoundHandling: form.controls.fileNotFoundHandling.value,
+            filePath: form.controls.filePath.value,
+            gdalConfigOptions: form.controls.gdalConfigOptions.value,
+            gdalOpenOptions: form.controls.gdalOpenOptions.value,
+            geoTransform: {
+                originCoordinate: {
+                    x: form.controls.geoTransform.controls.originCoordinate.controls.x.value,
+                    y: form.controls.geoTransform.controls.originCoordinate.controls.y.value,
+                },
+                xPixelSize: form.controls.geoTransform.controls.xPixelSize.value,
+                yPixelSize: form.controls.geoTransform.controls.yPixelSize.value,
+            },
+            height: form.controls.height.value,
+            width: form.controls.width.value,
+            noDataValue: form.controls.noDataValue.value,
+            propertiesMapping: form.controls.propertiesMapping.controls.map((control) => {
+                return {
+                    sourceKey: {
+                        domain: control.controls.sourceKey.controls.domain.value,
+                        key: control.controls.sourceKey.controls.key.value,
+                    },
+                    targetKey: {
+                        domain: control.controls.targetKey.controls.domain.value,
+                        key: control.controls.targetKey.controls.key.value,
+                    },
+                    targetType: control.controls.targetType.value,
+                };
+            }),
+            rasterbandChannel: form.controls.rasterbandChannel.value,
+        };
+    }
+
+    async suggestTileProperties(): Promise<void> {
+        const path = this.dataPath();
+        if (!path) {
+            this.snackBar.open('No data path selected.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        try {
+            const suggestion = await this.datasetsService.suggestMetaData({
+                suggestMetaData: {
+                    dataPath: path,
+                    mainFile: this.probeFileTileProperties,
+                },
+            });
+
+            const gdalParams = this.extractGdalParamsFromSuggestion(suggestion);
+            if (!gdalParams) {
+                return;
+            }
+
+            this.tileForm = this.setUpTileForm({
+                band: this.tileForm.controls.gdalParameters.controls.rasterbandChannel.value,
+                id: 'placeholder',
+                spatialPartition: extractSpatialPartition(gdalParams),
+                zIndex: 0,
+                time: time_interval_to_dict(this.tileForm.controls.time.value),
+                params: gdalParams,
+            });
+            this.changeDetectorRef.markForCheck();
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Metadata suggestion failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    protected calculateInitialNumberOfElements(): number {
+        const element = this.viewport().elementRef.nativeElement;
+        const numberOfElements = Math.ceil(element.clientHeight / this.itemSizePx);
+        // add one such that scrolling happens
+        return numberOfElements + 1;
+    }
+
+    private extractGdalParamsFromSuggestion(suggestion: MetaDataSuggestion): GdalDatasetParameters | undefined {
+        // TODO: replace with a proper API for suggestion once old GdalSource is removed form the backend
+        if (suggestion.metaData.type !== 'GdalMetaDataList') {
+            this.snackBar.open(`Metadata suggestion is not of type "GdalMetaDataList" but ${suggestion.metaData.type}`, 'Close', {
+                panelClass: ['error-snackbar'],
+            });
+            return;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+        const gdalMetaDataList = suggestion.metaData as any;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const slices = gdalMetaDataList.params;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (slices.length === 0) {
+            this.snackBar.open('No time slices found in metadata suggestion.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const firstSlice = slices[0];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const gdalParams = firstSlice.params;
+
+        if (!gdalParams) {
+            this.snackBar.open('No gdal parameters found in metadata suggestion.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return gdalParams;
+    }
+
+    private setUpPlaceHolderTileForm(): FormGroup<TileForm> {
+        return this.setUpTileForm({
+            band: 0,
+            id: 'placeholder',
+            spatialPartition: {
+                lowerRightCoordinate: {x: 0, y: 0},
+                upperLeftCoordinate: {x: 0, y: 0},
+            },
+            zIndex: 0,
+            time: time_interval_to_dict({
+                start: moment.utc().startOf('day'),
+                timeAsPoint: false,
+                end: moment.utc().startOf('day').add(1, 'days'),
+            }),
+            params: GdalDatasetParametersComponent.placeHolderGdalParams(),
+        });
+    }
+
+    private setUpTileForm(tile: DatasetTile): FormGroup<TileForm> {
+        const form = new FormGroup<TileForm>({
+            time: new FormControl(time_interval_from_dict(tile.time), {
+                nonNullable: true,
+                validators: [Validators.required],
+            }),
+            bbox: new FormGroup<BboxForm>({
+                bboxMinX: new FormControl(tile.spatialPartition.upperLeftCoordinate.x, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                bboxMinY: new FormControl(tile.spatialPartition.lowerRightCoordinate.y, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                bboxMaxX: new FormControl(tile.spatialPartition.lowerRightCoordinate.x, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                bboxMaxY: new FormControl(tile.spatialPartition.upperLeftCoordinate.y, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+            }),
+            band: new FormControl(tile.band ?? 0, {
+                nonNullable: true,
+                validators: [Validators.required],
+            }),
+            zIndex: new FormControl(tile.zIndex ?? 0, {
+                nonNullable: true,
+                validators: [Validators.required, geoengineValidators.largerThan(-1)],
+            }),
+            gdalParameters: GdalDatasetParametersComponent.setUpForm(tile.params),
+        });
+
+        return form;
+    }
+}
+
+/**
+ * A custom data source that allows fetching tiles for a virtual scroll source.
+ */
+class TileDataSource extends DataSource<DatasetTile> {
+    // cannot increase this, since it is limited by the server
+    readonly scrollFetchSize = 20;
+
+    readonly loading$ = new BehaviorSubject(false);
+
+    protected nextBatch$ = new Subject<number>();
+    protected noMoreData = false;
+    protected offset = 0;
+
+    constructor(
+        private datasetsService: DatasetsService,
+        private datasetName: string,
+    ) {
+        super();
+    }
+
+    init(numberOfElements: number): void {
+        this.fetchMoreData(Math.ceil(numberOfElements / this.scrollFetchSize)); // initially populate source
+    }
+
+    connect(): Observable<Array<DatasetTile>> {
+        return this.nextBatch$.pipe(
+            concatMap((numberOfTimes) => range(0, numberOfTimes)),
+            concatMap(() => this.getMoreDataFromServer()),
+            scan((acc, newValues) => [...acc, ...newValues]),
+            startWith([]), // emit empty array initially to trigger loading animation properly
+        );
+    }
+
+    /**
+     * Clean up resources
+     */
+    disconnect(): void {
+        // do nothing
+    }
+
+    fetchMoreData(numberOfTimes: number): void {
+        if (this.noMoreData) {
+            return;
+        }
+        this.nextBatch$.next(numberOfTimes);
+    }
+
+    protected async getMoreDataFromServer(): Promise<Array<DatasetTile>> {
+        if (this.noMoreData) {
+            return [];
+        }
+
+        this.loading$.next(true);
+
+        const offset = this.offset;
+        const limit = this.scrollFetchSize;
+
+        return this.datasetsService.getDatasetTiles(this.datasetName, offset, limit).then((items) => {
+            this.offset += items.length;
+
+            if (items.length < limit) {
+                this.noMoreData = true;
+            }
+
+            this.loading$.next(false);
+
+            return items;
+        });
+    }
+}
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.html b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.html
new file mode 100644
index 000000000..104a5aee8
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.html
@@ -0,0 +1,92 @@
+<form [formGroup]="form">
+    @if (dataPath()) {
+        <div>
+            <div class="flex-container">
+                <mat-form-field appearance="fill">
+                    <mat-label>Path to probe file, relative to upload or volume (optional)</mat-label>
+                    <input matInput type="text" [(ngModel)]="probeFileDatasetProperties" [ngModelOptions]="{standalone: true}" />
+                </mat-form-field>
+                <button mat-raised-button class="analyze" (click)="suggestDatasetProperties()">Analyze file and suggest properties</button>
+            </div>
+            <mat-divider></mat-divider>
+        </div>
+    }
+
+    <div formGroupName="rasterResultDescriptor">
+        <mat-form-field appearance="fill">
+            <mat-label>Output Data Type</mat-label>
+            <mat-select formControlName="dataType">
+                @for (dataType of RasterDataTypes; track dataType) {
+                    <mat-option [value]="dataType">
+                        {{ dataType }}
+                    </mat-option>
+                }
+            </mat-select>
+        </mat-form-field>
+
+        <mat-form-field appearance="fill">
+            <mat-label>Spatial Reference</mat-label>
+            <input matInput type="text" formControlName="spatialReference" />
+        </mat-form-field>
+
+        <div formGroupName="spatialGrid">
+            <div class="flex-container" formGroupName="geoTransform">
+                <mat-form-field>
+                    <mat-label>Origin X</mat-label>
+                    <input matInput type="number" formControlName="originX" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Origin Y</mat-label>
+                    <input matInput type="number" formControlName="originY" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Pixel Size X</mat-label>
+                    <input matInput type="number" formControlName="xPixelSize" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Pixel Size Y</mat-label>
+                    <input matInput type="number" formControlName="yPixelSize" />
+                </mat-form-field>
+            </div>
+
+            <div class="flex-container" formGroupName="gridBounds">
+                <mat-form-field>
+                    <mat-label>Min X Coordinate</mat-label>
+                    <input matInput type="number" formControlName="minX" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Min Y Coordinate</mat-label>
+                    <input matInput type="number" formControlName="minY" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Max X Coordinate</mat-label>
+                    <input matInput type="number" formControlName="maxX" />
+                </mat-form-field>
+                <mat-form-field>
+                    <mat-label>Max Y Coordinate</mat-label>
+                    <input matInput type="number" formControlName="maxY" />
+                </mat-form-field>
+            </div>
+        </div>
+
+        <mat-divider></mat-divider>
+
+        <geoengine-manager-timedescriptor
+            [timeDescriptor]="form.controls.rasterResultDescriptor.controls.time.value"
+            (timeDescriptorChange)="form.controls.rasterResultDescriptor.controls.time.setValue($event); form.markAsDirty()"
+        ></geoengine-manager-timedescriptor>
+
+        <mat-divider></mat-divider>
+
+        <geoengine-manager-rasterbands
+            [rasterbands]="form.controls.rasterResultDescriptor.controls.bands.value"
+            (rasterbandsChange)="form.controls.rasterResultDescriptor.controls.bands.setValue($event); form.markAsDirty()"
+        ></geoengine-manager-rasterbands>
+
+        @if (datasetName()) {
+            <div class="actions">
+                <button mat-raised-button color="primary" [disabled]="form.pristine || form.invalid" (click)="saveMetadata()">Apply</button>
+            </div>
+        }
+    </div>
+</form>
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.scss b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.scss
new file mode 100644
index 000000000..5e120dd79
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.scss
@@ -0,0 +1,32 @@
+:host {
+    width: 100%;
+    display: block;
+}
+
+mat-form-field {
+    width: 100%;
+}
+
+mat-divider {
+    margin-bottom: 1rem;
+}
+
+.flex-container {
+    display: flex;
+    justify-content: space-between;
+    gap: 1rem;
+}
+
+.analyze {
+    height: 3rem;
+}
+
+.actions {
+    text-align: right;
+    height: 3rem;
+    padding: 1rem;
+
+    button {
+        margin: 0.5rem;
+    }
+}
diff --git a/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.ts b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.ts
new file mode 100644
index 000000000..9c5033e54
--- /dev/null
+++ b/projects/manager/src/app/datasets/loading-info/gdal-multiband/gdal-multiband.component.ts
@@ -0,0 +1,374 @@
+import {ChangeDetectionStrategy, ChangeDetectorRef, Component, OnChanges, SimpleChanges, inject, input, output} from '@angular/core';
+import {FormControl, FormGroup, Validators, FormsModule, ReactiveFormsModule} from '@angular/forms';
+import {
+    CommonModule,
+    DatasetsService,
+    errorToText,
+    spatialPartitionFromSpatialGridDefinition,
+    spatialGridDefinitionFromSpatialPartitionAndGeoTransform,
+} from '@geoengine/common';
+import {
+    DataPath,
+    GdalMetaDataList,
+    MetaDataDefinition,
+    MetaDataSuggestion,
+    RasterBandDescriptor,
+    RasterDataType,
+    RasterResultDescriptor,
+    SpatialPartition2D,
+    GeoTransform as GeoTransformDict,
+    TimeDescriptor,
+} from '@geoengine/openapi-client';
+import {MatSnackBar} from '@angular/material/snack-bar';
+import {MatFormField, MatLabel, MatInput} from '@angular/material/input';
+import {MatButton} from '@angular/material/button';
+import {MatDivider} from '@angular/material/list';
+import {MatSelect, MatOption} from '@angular/material/select';
+import {RasterbandsComponent} from '../../../rasterbands/rasterbands.component';
+import {AppConfig} from '../../../app-config.service';
+import {TimedescriptorComponent} from '../../../timedescriptor/timedescriptor.component';
+
+export interface GdalMultiBandForm {
+    rasterResultDescriptor: FormGroup<RasterResultDescriptorForm>;
+}
+
+export interface RasterResultDescriptorForm {
+    bands: FormControl<Array<RasterBandDescriptor>>;
+    time: FormControl<TimeDescriptor>;
+    dataType: FormControl<RasterDataType>;
+    spatialReference: FormControl<string>;
+    spatialGrid: FormGroup<SpatialGridDescriptorForm>;
+}
+
+export interface SpatialGridDescriptorForm {
+    geoTransform: FormGroup<GeoTransformForm>;
+    gridBounds: FormGroup<GridBoundingBox2DForm>;
+}
+
+export interface GeoTransformForm {
+    originX: FormControl<number>;
+    originY: FormControl<number>;
+    xPixelSize: FormControl<number>;
+    yPixelSize: FormControl<number>;
+}
+
+export interface GridBoundingBox2DForm {
+    minX: FormControl<number>;
+    minY: FormControl<number>;
+    maxX: FormControl<number>;
+    maxY: FormControl<number>;
+}
+
+@Component({
+    selector: 'geoengine-manager-gdal-multiband',
+    templateUrl: './gdal-multiband.component.html',
+    styleUrl: './gdal-multiband.component.scss',
+    changeDetection: ChangeDetectionStrategy.OnPush,
+    imports: [
+        FormsModule,
+        ReactiveFormsModule,
+        MatFormField,
+        MatLabel,
+        MatInput,
+        MatButton,
+        MatDivider,
+        MatSelect,
+        MatOption,
+        CommonModule,
+        RasterbandsComponent,
+        TimedescriptorComponent,
+    ],
+})
+export class GdalMultiBandComponent implements OnChanges {
+    private readonly datasetsService = inject(DatasetsService);
+    private readonly snackBar = inject(MatSnackBar);
+    private readonly config = inject(AppConfig);
+    private readonly changeDetectorRef = inject(ChangeDetectorRef);
+
+    readonly dataPath = input<DataPath>();
+    readonly resultDescriptor = input<RasterResultDescriptor>();
+    readonly datasetName = input<string>();
+
+    readonly resultDescriptorChange = output<RasterResultDescriptor>();
+
+    RasterDataTypes = Object.values(RasterDataType);
+
+    form: FormGroup<GdalMultiBandForm> = this.setUpForm();
+
+    probeFileDatasetProperties = '';
+
+    ngOnChanges(changes: SimpleChanges): void {
+        if (changes.resultDescriptor) {
+            const resultDescriptor = this.resultDescriptor();
+            if (resultDescriptor) {
+                this.setUpFormFromResultDescriptor(resultDescriptor);
+            }
+        }
+    }
+
+    async saveMetadata(): Promise<void> {
+        if (this.form.invalid) {
+            return;
+        }
+
+        const datasetName = this.datasetName();
+        if (!datasetName) {
+            this.snackBar.open('No dataset name provided.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        const metaData = this.getMetaData();
+
+        try {
+            await this.datasetsService.updateLoadingInfo(datasetName, metaData);
+            this.snackBar.open('Dataset loading information successfully updated.', 'Close', {
+                duration: this.config.DEFAULTS.SNACKBAR_DURATION,
+            });
+            this.form.markAsPristine();
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Updating dataset loading information failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    getResultDescriptor(): RasterResultDescriptor {
+        const resultDescriptorControl = this.form.controls.rasterResultDescriptor.controls;
+
+        const geoTransformControl = resultDescriptorControl.spatialGrid.controls.geoTransform.controls;
+        const geoTransform: GeoTransformDict = {
+            originCoordinate: {
+                x: geoTransformControl.originX.value,
+                y: geoTransformControl.originY.value,
+            },
+            xPixelSize: geoTransformControl.xPixelSize.value,
+            yPixelSize: geoTransformControl.yPixelSize.value,
+        };
+
+        const spatialGridControl = resultDescriptorControl.spatialGrid.controls.gridBounds.controls;
+        const spatialPartition: SpatialPartition2D = {
+            upperLeftCoordinate: {
+                x: spatialGridControl.minX.value,
+                y: spatialGridControl.maxY.value,
+            },
+            lowerRightCoordinate: {
+                x: spatialGridControl.maxX.value,
+                y: spatialGridControl.minY.value,
+            },
+        };
+
+        return {
+            bands: resultDescriptorControl.bands.value,
+            spatialReference: resultDescriptorControl.spatialReference.value,
+            dataType: resultDescriptorControl.dataType.value,
+            spatialGrid: {
+                descriptor: 'source',
+                spatialGrid: spatialGridDefinitionFromSpatialPartitionAndGeoTransform(spatialPartition, geoTransform),
+            },
+            time: resultDescriptorControl.time.value,
+        };
+    }
+
+    getMetaData(): MetaDataDefinition {
+        return {
+            type: 'GdalMultiBand',
+            resultDescriptor: this.getResultDescriptor(),
+        };
+    }
+
+    async suggestDatasetProperties(): Promise<void> {
+        const path = this.dataPath();
+        if (!path) {
+            this.snackBar.open('No data path selected.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        try {
+            const suggestion = await this.datasetsService.suggestMetaData({
+                suggestMetaData: {
+                    dataPath: path,
+                    mainFile: this.probeFileDatasetProperties,
+                },
+            });
+
+            const extractedSuggestion = this.extractSuggestion(suggestion);
+            if (!extractedSuggestion) {
+                return;
+            }
+            const [resultDescriptor, _gdalParams] = extractedSuggestion;
+
+            this.setUpFormFromResultDescriptor(resultDescriptor);
+            this.changeDetectorRef.markForCheck();
+        } catch (error) {
+            const errorMessage = await errorToText(error, 'Metadata suggestion failed.');
+            this.snackBar.open(errorMessage, 'Close', {panelClass: ['error-snackbar']});
+        }
+    }
+
+    private extractSuggestion(suggestion: MetaDataSuggestion): [RasterResultDescriptor, unknown] | undefined {
+        // TODO: replace with a proper API for suggestion once old GdalSource is removed form the backend
+        if (suggestion.metaData.type !== 'GdalMetaDataList') {
+            this.snackBar.open(`Metadata suggestion is not of type "GdalMetaDataList" but ${suggestion.metaData.type}`, 'Close', {
+                panelClass: ['error-snackbar'],
+            });
+            return;
+        }
+
+        const gdalMetaDataList = suggestion.metaData as GdalMetaDataList;
+        const slices = gdalMetaDataList.params;
+
+        if (slices.length === 0) {
+            this.snackBar.open('No time slices found in metadata suggestion.', 'Close', {panelClass: ['error-snackbar']});
+            return;
+        }
+
+        const firstSlice = slices[0];
+        const gdalParams = firstSlice.params;
+        return [gdalMetaDataList.resultDescriptor, gdalParams];
+    }
+
+    private setUpFormFromResultDescriptor(resultDescriptor: RasterResultDescriptor): void {
+        const spatialPartition = spatialPartitionFromSpatialGridDefinition(resultDescriptor.spatialGrid.spatialGrid);
+
+        this.form = new FormGroup<GdalMultiBandForm>({
+            rasterResultDescriptor: new FormGroup<RasterResultDescriptorForm>({
+                bands: new FormControl(resultDescriptor.bands, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                dataType: new FormControl(resultDescriptor.dataType, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                spatialReference: new FormControl(resultDescriptor.spatialReference, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                spatialGrid: new FormGroup<SpatialGridDescriptorForm>({
+                    geoTransform: new FormGroup<GeoTransformForm>({
+                        originX: new FormControl(resultDescriptor.spatialGrid.spatialGrid.geoTransform.originCoordinate.x, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        originY: new FormControl(resultDescriptor.spatialGrid.spatialGrid.geoTransform.originCoordinate.y, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        xPixelSize: new FormControl(resultDescriptor.spatialGrid.spatialGrid.geoTransform.xPixelSize, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        yPixelSize: new FormControl(resultDescriptor.spatialGrid.spatialGrid.geoTransform.yPixelSize, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                    }),
+                    gridBounds: new FormGroup<GridBoundingBox2DForm>({
+                        minX: new FormControl(spatialPartition.upperLeftCoordinate.x, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        minY: new FormControl(spatialPartition.lowerRightCoordinate.y, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        maxX: new FormControl(spatialPartition.lowerRightCoordinate.x, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        maxY: new FormControl(spatialPartition.upperLeftCoordinate.y, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                    }),
+                }),
+                time: new FormControl(resultDescriptor.time, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+            }),
+        });
+
+        this.form.markAsPristine();
+
+        // Emit changes when form is updated
+        this.form.valueChanges.subscribe(() => {
+            if (this.form.valid) {
+                this.resultDescriptorChange.emit(this.getResultDescriptor());
+            }
+        });
+    }
+
+    private setUpForm(): FormGroup<GdalMultiBandForm> {
+        const form = new FormGroup<GdalMultiBandForm>({
+            rasterResultDescriptor: new FormGroup<RasterResultDescriptorForm>({
+                bands: new FormControl(
+                    [
+                        {
+                            name: 'band',
+                            measurement: {type: 'unitless'},
+                        },
+                    ],
+                    {
+                        nonNullable: true,
+                        validators: [Validators.required],
+                    },
+                ),
+                dataType: new FormControl(RasterDataType.U8, {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                spatialReference: new FormControl('', {
+                    nonNullable: true,
+                    validators: [Validators.required],
+                }),
+                spatialGrid: new FormGroup<SpatialGridDescriptorForm>({
+                    geoTransform: new FormGroup<GeoTransformForm>({
+                        originX: new FormControl(0, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        originY: new FormControl(0, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        xPixelSize: new FormControl(1, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        yPixelSize: new FormControl(-1, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                    }),
+                    gridBounds: new FormGroup<GridBoundingBox2DForm>({
+                        minX: new FormControl(0, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        minY: new FormControl(0, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        maxX: new FormControl(1, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                        maxY: new FormControl(1, {
+                            nonNullable: true,
+                            validators: [Validators.required],
+                        }),
+                    }),
+                }),
+                time: new FormControl(
+                    {dimension: {type: 'irregular'}, bounds: null},
+                    {
+                        nonNullable: true,
+                        validators: [Validators.required],
+                    },
+                ),
+            }),
+        });
+
+        return form;
+    }
+}
diff --git a/projects/manager/src/app/rasterbands/rasterbands.component.html b/projects/manager/src/app/rasterbands/rasterbands.component.html
new file mode 100644
index 000000000..96f183707
--- /dev/null
+++ b/projects/manager/src/app/rasterbands/rasterbands.component.html
@@ -0,0 +1,30 @@
+<form [formGroup]="form">
+    @for (control of form.controls.rasterbands.controls; track control; let i = $index) {
+        <div formArrayName="rasterbands">
+            <div class="container" [formGroupName]="i">
+                <mat-form-field appearance="fill" class="name-field">
+                    <mat-label>Name</mat-label>
+                    <input matInput formControlName="name" />
+                </mat-form-field>
+                <div class="measurement-wrapper">
+                    <geoengine-measurement
+                        [showOutputMeasurementLabel]="false"
+                        [measurement]="control.controls.measurement.value"
+                        (measurementChange)="control.controls.measurement.setValue($event)"
+                    ></geoengine-measurement>
+                </div>
+                <button
+                    mat-icon-button
+                    class="delete-button"
+                    [disabled]="form.controls.rasterbands.controls.length === 1"
+                    (click)="removeEntry(i)"
+                >
+                    <mat-icon>delete</mat-icon>
+                </button>
+            </div>
+        </div>
+    }
+    <div class="actions">
+        <button mat-raised-button (click)="addEntry()">Add Band</button>
+    </div>
+</form>
diff --git a/projects/manager/src/app/rasterbands/rasterbands.component.scss b/projects/manager/src/app/rasterbands/rasterbands.component.scss
new file mode 100644
index 000000000..c86448b87
--- /dev/null
+++ b/projects/manager/src/app/rasterbands/rasterbands.component.scss
@@ -0,0 +1,36 @@
+mat-form-field {
+    width: 100%;
+}
+
+.actions {
+    text-align: left;
+    height: 3rem;
+    padding-bottom: 2rem;
+
+    button {
+        margin: 0.5rem;
+    }
+}
+
+.container {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    width: 100%;
+}
+
+.name-field {
+    flex: 1 1 50%;
+}
+
+.measurement-wrapper {
+    flex: 1 1 50%;
+}
+
+.delete-button {
+    flex: 0 0 auto;
+}
+
+mat-divider {
+    margin-bottom: 1rem;
+}
diff --git a/projects/manager/src/app/rasterbands/rasterbands.component.ts b/projects/manager/src/app/rasterbands/rasterbands.component.ts
new file mode 100644
index 000000000..28a8645e2
--- /dev/null
+++ b/projects/manager/src/app/rasterbands/rasterbands.component.ts
@@ -0,0 +1,94 @@
+import {Component, OnChanges, SimpleChanges, input, output} from '@angular/core';
+import {FormArray, FormControl, FormGroup, Validators, FormsModule, ReactiveFormsModule} from '@angular/forms';
+import {geoengineValidators, MeasurementComponent} from '@geoengine/common';
+import {Measurement, Provenance, RasterBandDescriptor} from '@geoengine/openapi-client';
+import {MatDivider} from '@angular/material/list';
+import {MatFormField, MatLabel, MatInput} from '@angular/material/input';
+import {MatIconButton, MatButton} from '@angular/material/button';
+import {MatIcon} from '@angular/material/icon';
+import {Subscription} from 'rxjs';
+
+interface RasterbandsForm {
+    rasterbands: FormArray<FormGroup<RasterbandForm>>;
+}
+
+interface RasterbandForm {
+    name: FormControl<string>;
+    measurement: FormControl<Measurement>; // TODO: Measurement type
+}
+
+@Component({
+    selector: 'geoengine-manager-rasterbands',
+    templateUrl: './rasterbands.component.html',
+    styleUrl: './rasterbands.component.scss',
+    imports: [FormsModule, ReactiveFormsModule, MatFormField, MatLabel, MatInput, MatIconButton, MatIcon, MatButton, MeasurementComponent],
+})
+export class RasterbandsComponent implements OnChanges {
+    readonly rasterbands = input<Array<RasterBandDescriptor>>();
+
+    readonly rasterbandsChange = output<Array<RasterBandDescriptor>>();
+
+    form: FormGroup<RasterbandsForm> = this.setUpForm();
+
+    sub?: Subscription;
+
+    ngOnChanges(changes: SimpleChanges): void {
+        if (changes.rasterbands) {
+            this.form = this.setUpForm();
+        }
+    }
+
+    addEntry(): void {
+        this.form.controls.rasterbands.push(this.createRasterbandForm());
+        this.rasterbandsChange.emit(this.getRasterbands());
+    }
+
+    removeEntry(i: number): void {
+        if (this.form.controls.rasterbands.length == 1) {
+            return;
+        }
+        this.form.controls.rasterbands.removeAt(i);
+
+        this.form.markAsDirty();
+        this.rasterbandsChange.emit(this.getRasterbands());
+    }
+
+    getRasterbands(): Array<RasterBandDescriptor> {
+        return this.form.controls.rasterbands.value.map((p) => ({
+            name: p?.name ?? 'unnamed measurement',
+            measurement: p?.measurement ?? {type: 'unitless'},
+        }));
+    }
+
+    private setUpForm(): FormGroup<RasterbandsForm> {
+        const rasterbands = this.rasterbands();
+
+        const form = new FormGroup<RasterbandsForm>({
+            rasterbands: new FormArray<FormGroup<RasterbandForm>>(rasterbands?.map((p) => this.createRasterbandForm(p)) ?? []),
+        });
+
+        if (this.sub) {
+            this.sub.unsubscribe();
+        }
+
+        this.sub = form.valueChanges.subscribe(() => {
+            this.rasterbandsChange.emit(this.getRasterbands());
+        });
+
+        return form;
+    }
+
+    private createRasterbandForm(p?: RasterBandDescriptor): FormGroup<RasterbandForm> {
+        return new FormGroup<RasterbandForm>({
+            name: new FormControl(p?.name ?? '', {
+                nonNullable: true,
+                validators: [Validators.required, geoengineValidators.notOnlyWhitespace],
+                updateOn: 'blur',
+            }),
+            measurement: new FormControl(p?.measurement ?? {type: 'unitless'}, {
+                nonNullable: true,
+                validators: [Validators.required],
+            }),
+        });
+    }
+}
diff --git a/projects/manager/src/app/timedescriptor/timedescriptor.component.html b/projects/manager/src/app/timedescriptor/timedescriptor.component.html
new file mode 100644
index 000000000..2e27c8cdb
--- /dev/null
+++ b/projects/manager/src/app/timedescriptor/timedescriptor.component.html
@@ -0,0 +1,46 @@
+<form [formGroup]="form">
+    <mat-checkbox formControlName="hasBounds">Set Time Bounds</mat-checkbox>
+
+    @if (form.controls.hasBounds.value) {
+        <geoengine-time-interval-input [formControl]="form.controls.bounds"></geoengine-time-interval-input>
+    }
+
+    <mat-form-field appearance="fill">
+        <mat-label>Time Dimension</mat-label>
+        <mat-select formControlName="dimension">
+            @for (r of Regularity; track r) {
+                <mat-option [value]="r">
+                    {{ r }}
+                </mat-option>
+            }
+        </mat-select>
+    </mat-form-field>
+
+    @if (form.controls.dimension.value === 'regular') {
+        <div formGroupName="regularTimeDimension">
+            Origin
+            <geoengine-time-interval-input
+                [allowRanges]="false"
+                [formControl]="form.controls.regularTimeDimension.controls.origin"
+            ></geoengine-time-interval-input>
+
+            <div formGroupName="step" class="flex-container">
+                <mat-form-field appearance="fill">
+                    <mat-label>Time Step</mat-label>
+                    <input matInput type="number" formControlName="step" />
+                </mat-form-field>
+
+                <mat-form-field appearance="fill">
+                    <mat-label>Time Granularity</mat-label>
+                    <mat-select formControlName="granularity">
+                        @for (g of TimeGranularities; track g) {
+                            <mat-option [value]="g">
+                                {{ g }}
+                            </mat-option>
+                        }
+                    </mat-select>
+                </mat-form-field>
+            </div>
+        </div>
+    }
+</form>
diff --git a/projects/manager/src/app/timedescriptor/timedescriptor.component.scss b/projects/manager/src/app/timedescriptor/timedescriptor.component.scss
new file mode 100644
index 000000000..f563b06d1
--- /dev/null
+++ b/projects/manager/src/app/timedescriptor/timedescriptor.component.scss
@@ -0,0 +1,42 @@
+mat-form-field {
+    width: 100%;
+}
+
+.actions {
+    text-align: left;
+    height: 3rem;
+    padding-bottom: 2rem;
+
+    button {
+        margin: 0.5rem;
+    }
+}
+
+.container {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    width: 100%;
+}
+
+.name-field {
+    flex: 1 1 50%;
+}
+
+.measurement-wrapper {
+    flex: 1 1 50%;
+}
+
+.delete-button {
+    flex: 0 0 auto;
+}
+
+mat-divider {
+    margin-bottom: 1rem;
+}
+
+.flex-container {
+    display: flex;
+    justify-content: space-between;
+    gap: 1rem;
+}
diff --git a/projects/manager/src/app/timedescriptor/timedescriptor.component.ts b/projects/manager/src/app/timedescriptor/timedescriptor.component.ts
new file mode 100644
index 000000000..576a6682f
--- /dev/null
+++ b/projects/manager/src/app/timedescriptor/timedescriptor.component.ts
@@ -0,0 +1,183 @@
+import {Component, OnChanges, SimpleChanges, input, output} from '@angular/core';
+import {FormControl, FormGroup, FormsModule, ReactiveFormsModule} from '@angular/forms';
+import {time_interval_from_dict, time_interval_to_dict, TimeInterval, CommonModule, timeStepGranularityOptions} from '@geoengine/common';
+import {TimeDescriptor, TimeDimensionOneOf1TypeEnum, TimeDimensionOneOfTypeEnum, TimeGranularity} from '@geoengine/openapi-client';
+import {MatFormField, MatLabel, MatInput} from '@angular/material/input';
+import {Subscription} from 'rxjs';
+import {MatSelect, MatOption} from '@angular/material/select';
+import moment from 'moment';
+import {MatCheckbox} from '@angular/material/checkbox';
+
+interface TimeDescriptorForm {
+    hasBounds: FormControl<boolean>;
+    bounds: FormControl<TimeInterval | null>;
+    dimension: FormControl<Regularity>;
+    regularTimeDimension: FormGroup<RegularTimeDimensionForm>;
+}
+
+interface RegularTimeDimensionForm {
+    origin: FormControl<TimeInterval>;
+    step: FormGroup<TimeStepForm>;
+}
+
+interface TimeStepForm {
+    granularity: FormControl<TimeGranularity>;
+    step: FormControl<number>;
+}
+
+enum Regularity {
+    Regular = 'regular',
+    Irregular = 'irregular',
+}
+
+@Component({
+    selector: 'geoengine-manager-timedescriptor',
+    templateUrl: './timedescriptor.component.html',
+    styleUrl: './timedescriptor.component.scss',
+    imports: [FormsModule, ReactiveFormsModule, MatFormField, MatLabel, MatInput, MatSelect, MatOption, CommonModule, MatCheckbox],
+})
+export class TimedescriptorComponent implements OnChanges {
+    Regularity = [TimeDimensionOneOf1TypeEnum.Irregular, TimeDimensionOneOfTypeEnum.Regular] as const;
+    TimeGranularities = timeStepGranularityOptions;
+
+    readonly timeDescriptor = input<TimeDescriptor>();
+
+    readonly timeDescriptorChange = output<TimeDescriptor>();
+
+    form: FormGroup<TimeDescriptorForm> = this.setUpForm();
+
+    sub?: Subscription;
+
+    ngOnChanges(changes: SimpleChanges): void {
+        if (changes.timeDescriptor) {
+            this.form = this.setUpForm();
+        }
+    }
+
+    private setUpForm(): FormGroup<TimeDescriptorForm> {
+        const timeDescriptor = this.timeDescriptor();
+
+        let form;
+
+        if (!timeDescriptor) {
+            form = new FormGroup<TimeDescriptorForm>({
+                hasBounds: new FormControl<boolean>(false, {nonNullable: true}),
+                bounds: new FormControl<TimeInterval>(this.placeholderTimeInterval(false), {nonNullable: true}),
+                dimension: new FormControl<Regularity>(Regularity.Irregular, {nonNullable: true}),
+                regularTimeDimension: new FormGroup<RegularTimeDimensionForm>({
+                    origin: new FormControl<TimeInterval>(this.placeholderTimeInterval(true), {nonNullable: true}),
+                    step: new FormGroup<TimeStepForm>({
+                        granularity: new FormControl<TimeGranularity>('days', {nonNullable: true}),
+                        step: new FormControl<number>(1, {nonNullable: true}),
+                    }),
+                }),
+            });
+        } else {
+            const bounds = timeDescriptor.bounds;
+            let formBounds = null;
+            if (bounds) {
+                formBounds = time_interval_from_dict(bounds);
+            } else {
+                formBounds = this.placeholderTimeInterval(false);
+            }
+
+            form = new FormGroup<TimeDescriptorForm>({
+                hasBounds: new FormControl<boolean>(!!bounds, {nonNullable: true}),
+                bounds: new FormControl<TimeInterval>(formBounds ? formBounds : this.placeholderTimeInterval(false), {nonNullable: true}),
+                dimension: new FormControl<Regularity>(
+                    timeDescriptor.dimension.type == 'irregular' ? Regularity.Irregular : Regularity.Regular,
+                    {nonNullable: true},
+                ),
+                regularTimeDimension: new FormGroup<RegularTimeDimensionForm>({
+                    origin: new FormControl<TimeInterval>(
+                        timeDescriptor.dimension.type == 'regular'
+                            ? this.timeOriginFromTimestamp(timeDescriptor.dimension.origin)
+                            : this.placeholderTimeInterval(false),
+                        {nonNullable: true},
+                    ),
+                    step: new FormGroup<TimeStepForm>({
+                        granularity: new FormControl<TimeGranularity>(
+                            timeDescriptor.dimension.type == 'regular' ? timeDescriptor.dimension.step.granularity : 'days',
+                            {nonNullable: true},
+                        ),
+                        step: new FormControl<number>(timeDescriptor.dimension.type == 'regular' ? timeDescriptor.dimension.step.step : 1, {
+                            nonNullable: true,
+                        }),
+                    }),
+                }),
+            });
+        }
+
+        if (this.sub) {
+            this.sub.unsubscribe();
+        }
+
+        this.sub = form.valueChanges.subscribe(() => {
+            this.timeDescriptorChange.emit(this.getTimeDescriptor());
+        });
+
+        return form;
+    }
+
+    private timeOriginFromTimestamp(timestamp: number): TimeInterval {
+        const time = moment.utc(timestamp);
+        return {
+            start: time.hour(0).minute(0).second(0).millisecond(0),
+            end: time.hour(0).minute(0).second(0).millisecond(0),
+            timeAsPoint: true,
+        };
+    }
+
+    private placeholderTimeInterval(timeAsPoint: boolean): TimeInterval {
+        if (timeAsPoint) {
+            return {
+                start: moment.utc().hour(0).minute(0).second(0).millisecond(0),
+                end: moment.utc().hour(0).minute(0).second(0).millisecond(0),
+                timeAsPoint: true,
+            };
+        }
+
+        return {
+            start: moment.utc().hour(0).minute(0).second(0).millisecond(0),
+            end: moment.utc().add(1, 'days').hour(0).minute(0).second(0).millisecond(0),
+            timeAsPoint: false,
+        };
+    }
+
+    private getTimeDescriptor(): TimeDescriptor {
+        const formBounds = this.form.controls.bounds.value;
+        const hasBounds = this.form.controls.hasBounds.value;
+
+        let bounds = null;
+
+        if (hasBounds && formBounds) {
+            bounds = time_interval_to_dict(formBounds);
+        }
+
+        const dimension = this.form.controls.dimension.value;
+
+        switch (dimension) {
+            case Regularity.Regular: {
+                const regular = this.form.controls.regularTimeDimension.controls;
+                return {
+                    bounds: bounds,
+                    dimension: {
+                        type: TimeDimensionOneOfTypeEnum.Regular,
+                        origin: regular.origin.value.start.valueOf(),
+                        step: {
+                            granularity: regular.step.controls.granularity.value,
+                            step: regular.step.controls.step.value,
+                        },
+                    },
+                };
+            }
+            case Regularity.Irregular:
+                return {
+                    bounds: bounds,
+                    dimension: {
+                        type: TimeDimensionOneOf1TypeEnum.Irregular,
+                    },
+                };
+        }
+    }
+}