diff --git a/.github/workflows/_job_quality_check.yaml b/.github/workflows/_job_quality_check.yaml
index 3fbf789e4..32eda90cf 100644
--- a/.github/workflows/_job_quality_check.yaml
+++ b/.github/workflows/_job_quality_check.yaml
@@ -58,6 +58,9 @@ jobs:
       - name: doctests
         if: ${{ ! inputs._SKIP_QUALITY && always() }}
         run: poe doctests
+      - name: notebooks-check
+        if: ${{ ! inputs._SKIP_QUALITY && always() }}
+        run: poe notebooks-check
 
       - name: Stop if any quality step failed
         # All tests are run with always() not to stop on the first error. This step makes the workflow fail if any quality step failed.
diff --git a/.gitignore b/.gitignore
index 9b59a91ec..62a814bde 100644
--- a/.gitignore
+++ b/.gitignore
@@ -129,3 +129,5 @@ benchmark_results*/
 # Mlflow
 /mlflow
 /mlflow_artifacts_local
+
+.github/instructions
\ No newline at end of file
diff --git a/examples/pyproject.toml b/examples/pyproject.toml
index a347a8b7d..a150eed56 100644
--- a/examples/pyproject.toml
+++ b/examples/pyproject.toml
@@ -16,9 +16,9 @@ dependencies = [
 ]
 
 optional-dependencies.tutorials = [
-  "huggingface-hub>=1.2.2",
   "jupyter>=1.1.1",
-  "kaleido"
+  "kaleido",
+  "openstef-core[benchmark]",
 ]
 
 [tool.uv.sources]
diff --git a/examples/tutorials/forecasting_with_workflow_presets.ipynb b/examples/tutorials/forecasting_with_workflow_presets.ipynb
index f5e972239..01a3a6881 100644
--- a/examples/tutorials/forecasting_with_workflow_presets.ipynb
+++ b/examples/tutorials/forecasting_with_workflow_presets.ipynb
@@ -1,13 +1,28 @@
 {
  "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8eae4f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>\n",
+    "#\n",
+    "# SPDX-License-Identifier: MPL-2.0\n",
+    "\n",
+    "# pyright: basic"
+   ]
+  },
   {
    "cell_type": "markdown",
-   "id": "65fbd6d9",
+   "id": "20e1bef8",
    "metadata": {},
    "source": [
     "# 🔮 Forecasting with OpenSTEF 4.0 Workflow Presets\n",
     "\n",
-    "This tutorial demonstrates how to use **OpenSTEF 4.0** to create energy load forecasts using the **Workflow Presets** pattern. You'll learn how to:\n",
+    "This tutorial demonstrates how to use **OpenSTEF 4.0** to create energy load forecasts\n",
+    "using the **Workflow Presets** pattern. You'll learn how to:\n",
     "\n",
     "1. **Load real-world energy data** from the Liander 2024 benchmark dataset\n",
     "2. **Configure a forecasting workflow** with weather features and prediction quantiles\n",
@@ -15,36 +30,29 @@
     "4. **Generate probabilistic forecasts** with confidence intervals\n",
     "5. **Visualize results** and explain feature importance\n",
     "\n",
-    "> **OpenSTEF** (Short-Term Energy Forecasting) is a modular library for creating accurate energy forecasts in the power grid domain."
+    "> **OpenSTEF** (Short-Term Energy Forecasting) is a modular library for creating\n",
+    "> accurate energy forecasts in the power grid domain."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "c8a83428",
+   "execution_count": null,
+   "id": "a6b72dc5",
    "metadata": {},
    "outputs": [],
    "source": [
     "# --- Setup: Logging and Display Configuration ---\n",
-    "# Configure logging to see training progress and plotly to render as PNG for VS Code compatibility\n",
-    "import logging\n",
-    "import pandas as pd\n",
-    "import plotly.io as pio\n",
-    "\n",
-    "pd.options.plotting.backend = \"plotly\"\n",
-    "pio.renderers.default = \"png\"  # Use PNG for VS Code notebook compatibility\n",
-    "\n",
-    "logging.basicConfig(level=logging.INFO, format=\"[%(asctime)s][%(levelname)s] %(message)s\")\n",
-    "logger = logging.getLogger(__name__)\n",
-    "logging.getLogger(\"choreographer\").setLevel(logging.ERROR)\n",
-    "logging.getLogger(\"kaleido\").setLevel(logging.ERROR)\n",
-    "logging.getLogger(\"choreographer\").disabled = True\n",
-    "logging.getLogger(\"kaleido\").disabled = True"
+    "from typing import Any, cast\n",
+    "\n",
+    "from openstef_core.testing import configure_notebook_display, setup_notebook_logging\n",
+    "\n",
+    "configure_notebook_display()\n",
+    "logger = setup_notebook_logging(__name__)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f2afee2d",
+   "id": "fdddf593",
    "metadata": {},
    "source": [
     "## 📦 Step 1: Download the Dataset\n",
@@ -59,404 +67,15 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "ead642f4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Downloading load_measurements/mv_feeder/OS Gorredijk.parquet...\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/egor.dmitriev/projects/openstef/openstef4-clean/.venv/lib/python3.12/site-packages/huggingface_hub/utils/_validators.py:202: UserWarning:\n",
-      "\n",
-      "The `local_dir_use_symlinks` argument is deprecated and ignored in `hf_hub_download`. Downloading to a local directory does not use symlinks anymore.\n",
-      "\n",
-      "[2025-12-18 10:00:14,002][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/load_measurements/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n",
-      "[2025-12-18 10:00:14,122][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/weather_forecasts_versioned/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✓ load_measurements/mv_feeder/OS Gorredijk.parquet downloaded\n",
-      "Downloading weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet...\n",
-      "✓ weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet downloaded\n",
-      "Downloading EPEX.parquet...\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2025-12-18 10:00:14,247][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/EPEX.parquet \"HTTP/1.1 302 Found\"\n",
-      "[2025-12-18 10:00:14,366][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/profiles.parquet \"HTTP/1.1 302 Found\"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✓ EPEX.parquet downloaded\n",
-      "Downloading profiles.parquet...\n",
-      "✓ profiles.parquet downloaded\n",
-      "\n",
-      "✅ All files downloaded successfully!\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Download dataset from HuggingFace Hub\n",
-    "# The dataset is stored as parquet files for efficient loading\n",
-    "from huggingface_hub import hf_hub_download # pyright: ignore[reportUnknownVariableType]\n",
-    "from pathlib import Path\n",
-    "\n",
-    "repo_id = \"OpenSTEF/liander2024-energy-forecasting-benchmark\"  # Public benchmark dataset\n",
-    "local_dir = Path(\"./liander_dataset\")\n",
-    "target = \"mv_feeder/OS Gorredijk\"  # Specific installation to focus on\n",
-    "\n",
-    "# Download required files: load measurements, weather, prices, and profiles\n",
-    "files_to_download = [\n",
-    "    f\"load_measurements/{target}.parquet\",  # Energy consumption data\n",
-    "    f\"weather_forecasts_versioned/{target}.parquet\",  # Weather features\n",
-    "    \"EPEX.parquet\",  # Electricity prices (optional feature)\n",
-    "    \"profiles.parquet\"  # Standard load profiles (optional feature)\n",
-    "]\n",
-    "\n",
-    "for filename in files_to_download:\n",
-    "    print(f\"Downloading {filename}...\")\n",
-    "    hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\",\n",
-    "                    local_dir=local_dir, local_dir_use_symlinks=False) # pyright: ignore[reportCallIssue]\n",
-    "    print(f\"✓ {filename} downloaded\")\n",
-    "\n",
-    "print(\"\\n✅ All files downloaded successfully!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "81d12312",
-   "metadata": {},
-   "source": [
-    "## 📊 Step 2: Load and Prepare the Data\n",
-    "\n",
-    "OpenSTEF uses **VersionedTimeSeriesDataset** — a specialized data structure that handles:\n",
-    "- **Time versioning** — tracks when data became available (crucial for realistic backtesting)\n",
-    "- **Lazy composition** — efficiently combines datasets without O(n²) memory overhead\n",
-    "- **Temporal alignment** — ensures all features are properly aligned by timestamp"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a5522df3",
+   "id": "3a97b4a1",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2025-12-18 10:00:21,726][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
-      "[2025-12-18 10:00:21,746][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
-      "[2025-12-18 10:00:21,771][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
-      "[2025-12-18 10:00:21,780][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dataset shape: (35136, 28)\n",
-      "Date range: 2024-01-01 00:00:00+00:00 to 2024-12-31 23:45:00+00:00\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>load</th>\n",
-       "      <th>temperature_2m</th>\n",
-       "      <th>relative_humidity_2m</th>\n",
-       "      <th>surface_pressure</th>\n",
-       "      <th>cloud_cover</th>\n",
-       "      <th>wind_speed_10m</th>\n",
-       "      <th>wind_speed_80m</th>\n",
-       "      <th>wind_direction_10m</th>\n",
-       "      <th>shortwave_radiation</th>\n",
-       "      <th>direct_radiation</th>\n",
-       "      <th>...</th>\n",
-       "      <th>E1C_AMI_A</th>\n",
-       "      <th>E2A_AZI_A</th>\n",
-       "      <th>E2A_AMI_A</th>\n",
-       "      <th>E2B_AZI_A</th>\n",
-       "      <th>E2B_AMI_A</th>\n",
-       "      <th>E3A_A</th>\n",
-       "      <th>E3B_A</th>\n",
-       "      <th>E3C_A</th>\n",
-       "      <th>E3D_A</th>\n",
-       "      <th>E4A_A</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>timestamp</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>2024-01-01 00:00:00+00:00</th>\n",
-       "      <td>423333.333333</td>\n",
-       "      <td>7.243500</td>\n",
-       "      <td>85.025322</td>\n",
-       "      <td>994.236450</td>\n",
-       "      <td>100.0</td>\n",
-       "      <td>28.185953</td>\n",
-       "      <td>43.832863</td>\n",
-       "      <td>204.928452</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>0.000064</td>\n",
-       "      <td>0.000024</td>\n",
-       "      <td>0.000034</td>\n",
-       "      <td>0.000053</td>\n",
-       "      <td>0.000064</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000079</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2024-01-01 00:15:00+00:00</th>\n",
-       "      <td>436666.666667</td>\n",
-       "      <td>7.281000</td>\n",
-       "      <td>84.808533</td>\n",
-       "      <td>994.186523</td>\n",
-       "      <td>100.0</td>\n",
-       "      <td>28.753380</td>\n",
-       "      <td>44.976219</td>\n",
-       "      <td>206.931015</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>0.000061</td>\n",
-       "      <td>0.000024</td>\n",
-       "      <td>0.000034</td>\n",
-       "      <td>0.000052</td>\n",
-       "      <td>0.000063</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000079</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2024-01-01 00:30:00+00:00</th>\n",
-       "      <td>410000.000000</td>\n",
-       "      <td>7.318501</td>\n",
-       "      <td>84.591743</td>\n",
-       "      <td>994.136597</td>\n",
-       "      <td>100.0</td>\n",
-       "      <td>29.320807</td>\n",
-       "      <td>46.119572</td>\n",
-       "      <td>208.933563</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>0.000060</td>\n",
-       "      <td>0.000023</td>\n",
-       "      <td>0.000033</td>\n",
-       "      <td>0.000051</td>\n",
-       "      <td>0.000063</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000058</td>\n",
-       "      <td>0.000079</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2024-01-01 00:45:00+00:00</th>\n",
-       "      <td>403333.333333</td>\n",
-       "      <td>7.356000</td>\n",
-       "      <td>84.374954</td>\n",
-       "      <td>994.086731</td>\n",
-       "      <td>100.0</td>\n",
-       "      <td>29.888233</td>\n",
-       "      <td>47.262924</td>\n",
-       "      <td>210.936127</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>0.000057</td>\n",
-       "      <td>0.000023</td>\n",
-       "      <td>0.000032</td>\n",
-       "      <td>0.000051</td>\n",
-       "      <td>0.000061</td>\n",
-       "      <td>0.000059</td>\n",
-       "      <td>0.000059</td>\n",
-       "      <td>0.000059</td>\n",
-       "      <td>0.000059</td>\n",
-       "      <td>0.000079</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2024-01-01 01:00:00+00:00</th>\n",
-       "      <td>420000.000000</td>\n",
-       "      <td>7.393500</td>\n",
-       "      <td>84.158165</td>\n",
-       "      <td>994.036804</td>\n",
-       "      <td>100.0</td>\n",
-       "      <td>30.455660</td>\n",
-       "      <td>48.406281</td>\n",
-       "      <td>212.938690</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>...</td>\n",
-       "      <td>0.000055</td>\n",
-       "      <td>0.000024</td>\n",
-       "      <td>0.000032</td>\n",
-       "      <td>0.000052</td>\n",
-       "      <td>0.000060</td>\n",
-       "      <td>0.000057</td>\n",
-       "      <td>0.000057</td>\n",
-       "      <td>0.000057</td>\n",
-       "      <td>0.000057</td>\n",
-       "      <td>0.000079</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>5 rows × 28 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                                    load  temperature_2m  \\\n",
-       "timestamp                                                  \n",
-       "2024-01-01 00:00:00+00:00  423333.333333        7.243500   \n",
-       "2024-01-01 00:15:00+00:00  436666.666667        7.281000   \n",
-       "2024-01-01 00:30:00+00:00  410000.000000        7.318501   \n",
-       "2024-01-01 00:45:00+00:00  403333.333333        7.356000   \n",
-       "2024-01-01 01:00:00+00:00  420000.000000        7.393500   \n",
-       "\n",
-       "                           relative_humidity_2m  surface_pressure  \\\n",
-       "timestamp                                                           \n",
-       "2024-01-01 00:00:00+00:00             85.025322        994.236450   \n",
-       "2024-01-01 00:15:00+00:00             84.808533        994.186523   \n",
-       "2024-01-01 00:30:00+00:00             84.591743        994.136597   \n",
-       "2024-01-01 00:45:00+00:00             84.374954        994.086731   \n",
-       "2024-01-01 01:00:00+00:00             84.158165        994.036804   \n",
-       "\n",
-       "                           cloud_cover  wind_speed_10m  wind_speed_80m  \\\n",
-       "timestamp                                                                \n",
-       "2024-01-01 00:00:00+00:00        100.0       28.185953       43.832863   \n",
-       "2024-01-01 00:15:00+00:00        100.0       28.753380       44.976219   \n",
-       "2024-01-01 00:30:00+00:00        100.0       29.320807       46.119572   \n",
-       "2024-01-01 00:45:00+00:00        100.0       29.888233       47.262924   \n",
-       "2024-01-01 01:00:00+00:00        100.0       30.455660       48.406281   \n",
-       "\n",
-       "                           wind_direction_10m  shortwave_radiation  \\\n",
-       "timestamp                                                            \n",
-       "2024-01-01 00:00:00+00:00          204.928452                  0.0   \n",
-       "2024-01-01 00:15:00+00:00          206.931015                  0.0   \n",
-       "2024-01-01 00:30:00+00:00          208.933563                  0.0   \n",
-       "2024-01-01 00:45:00+00:00          210.936127                  0.0   \n",
-       "2024-01-01 01:00:00+00:00          212.938690                  0.0   \n",
-       "\n",
-       "                           direct_radiation  ...  E1C_AMI_A  E2A_AZI_A  \\\n",
-       "timestamp                                    ...                         \n",
-       "2024-01-01 00:00:00+00:00               0.0  ...   0.000064   0.000024   \n",
-       "2024-01-01 00:15:00+00:00               0.0  ...   0.000061   0.000024   \n",
-       "2024-01-01 00:30:00+00:00               0.0  ...   0.000060   0.000023   \n",
-       "2024-01-01 00:45:00+00:00               0.0  ...   0.000057   0.000023   \n",
-       "2024-01-01 01:00:00+00:00               0.0  ...   0.000055   0.000024   \n",
-       "\n",
-       "                           E2A_AMI_A  E2B_AZI_A  E2B_AMI_A     E3A_A  \\\n",
-       "timestamp                                                              \n",
-       "2024-01-01 00:00:00+00:00   0.000034   0.000053   0.000064  0.000058   \n",
-       "2024-01-01 00:15:00+00:00   0.000034   0.000052   0.000063  0.000058   \n",
-       "2024-01-01 00:30:00+00:00   0.000033   0.000051   0.000063  0.000058   \n",
-       "2024-01-01 00:45:00+00:00   0.000032   0.000051   0.000061  0.000059   \n",
-       "2024-01-01 01:00:00+00:00   0.000032   0.000052   0.000060  0.000057   \n",
-       "\n",
-       "                              E3B_A     E3C_A     E3D_A     E4A_A  \n",
-       "timestamp                                                          \n",
-       "2024-01-01 00:00:00+00:00  0.000058  0.000058  0.000058  0.000079  \n",
-       "2024-01-01 00:15:00+00:00  0.000058  0.000058  0.000058  0.000079  \n",
-       "2024-01-01 00:30:00+00:00  0.000058  0.000058  0.000058  0.000079  \n",
-       "2024-01-01 00:45:00+00:00  0.000059  0.000059  0.000059  0.000079  \n",
-       "2024-01-01 01:00:00+00:00  0.000057  0.000057  0.000057  0.000079  \n",
-       "\n",
-       "[5 rows x 28 columns]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Load datasets using OpenSTEF's VersionedTimeSeriesDataset\n",
-    "# This class handles versioned data where each value has an \"available_at\" timestamp\n",
-    "from openstef_core.datasets import VersionedTimeSeriesDataset\n",
-    "\n",
-    "# Load each data source from parquet files\n",
-    "load_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
-    "    local_dir / f\"load_measurements/{target}.parquet\"\n",
-    ")\n",
-    "weather_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
-    "    local_dir / f\"weather_forecasts_versioned/{target}.parquet\"\n",
-    ")\n",
-    "epex_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"EPEX.parquet\")\n",
-    "profiles_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"profiles.parquet\")\n",
+    "# Download and combine the Liander benchmark dataset into a single TimeSeriesDataset.\n",
+    "from openstef_core.testing import load_liander_dataset, prepare_tutorial_datasets\n",
     "\n",
-    "# Combine all datasets using left join (keep all load timestamps, match features where available)\n",
-    "# select_version() materializes the lazy dataset into a concrete TimeSeriesDataset\n",
-    "dataset = VersionedTimeSeriesDataset.concat(\n",
-    "    [load_dataset, weather_dataset, epex_dataset, profiles_dataset], \n",
-    "    mode=\"left\"  # Left join keeps all timestamps from the first dataset\n",
-    ").select_version()\n",
+    "dataset = load_liander_dataset()\n",
     "\n",
-    "# Preview the combined dataset\n",
     "print(f\"Dataset shape: {dataset.data.shape}\")\n",
     "print(f\"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}\")\n",
     "dataset.data.head()"
@@ -464,7 +83,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "675e594e",
+   "id": "c1f4660d",
    "metadata": {},
    "source": [
     "## ✂️ Step 3: Split Data into Training and Forecast Periods\n",
@@ -476,64 +95,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "844ac4a2",
+   "execution_count": null,
+   "id": "95f4a401",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "📈 Training period: 2024-03-01 to 2024-05-30 (8640 samples)\n",
-      "🔮 Forecast period: 2024-05-30 to 2024-06-13 (1344 samples)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Define training and forecast time periods\n",
-    "from datetime import datetime, timedelta\n",
-    "\n",
-    "# Training period: 90 days of historical data\n",
-    "train_start = datetime.fromisoformat(\"2024-03-01T00:00:00Z\")\n",
-    "train_end = train_start + timedelta(days=90)\n",
-    "\n",
-    "# Forecast period: 14 days after training (this is where we'll predict)\n",
-    "forecast_start = train_end\n",
-    "forecast_end = forecast_start + timedelta(days=14)\n",
-    "\n",
-    "# Split the dataset using time-based filtering\n",
-    "train_dataset = dataset.filter_by_range(start=train_start, end=train_end)\n",
-    "forecast_dataset = dataset.filter_by_range(start=forecast_start, end=forecast_end)\n",
-    "\n",
-    "print(f\"📈 Training period: {train_start.date()} to {train_end.date()} ({len(train_dataset.data)} samples)\")\n",
-    "print(f\"🔮 Forecast period: {forecast_start.date()} to {forecast_end.date()} ({len(forecast_dataset.data)} samples)\")"
+    "# Split the dataset into training (90 days) and forecast (14 days) periods.\n",
+    "train_dataset, forecast_dataset = prepare_tutorial_datasets()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "07c5b563",
+   "execution_count": null,
+   "id": "162c0fc2",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the training data\n",
     "# The plot shows the 'load' column (energy consumption in MW) over time\n",
-    "fig = train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\")\n",
+    "# cast() needed: pandas returns plotly Figure at runtime (backend=\"plotly\") but typed as Axes\n",
+    "fig = cast(Any, train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\"))\n",
     "fig.update_layout(yaxis_title=\"Load (MW)\", xaxis_title=\"Time\")\n",
     "fig.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "6c13fe2b",
+   "id": "6c64db35",
    "metadata": {},
    "source": [
     "## ⚙️ Step 4: Configure the Forecasting Workflow\n",
@@ -552,18 +140,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "1b5c88dc",
+   "execution_count": null,
+   "id": "5afd85eb",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Workflow configured successfully!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Import workflow components\n",
     "from openstef_core.types import LeadTime, Q  # LeadTime: forecast horizon, Q: quantile\n",
@@ -576,29 +156,24 @@
     "        # Model identification\n",
     "        model_id=\"gblinear_demo_v1\",\n",
     "        model=\"gblinear\",  # Use gradient boosted linear model\n",
-    "        \n",
     "        # Forecast settings\n",
     "        horizons=[LeadTime.from_string(\"PT36H\")],  # Predict up to 36 hours ahead\n",
     "        quantiles=[Q(0.5), Q(0.1), Q(0.9)],  # Median + 80% prediction interval\n",
-    "        \n",
     "        # Target column (what we're predicting)\n",
     "        target_column=\"load\",\n",
-    "        \n",
     "        # Weather feature columns (from the dataset)\n",
     "        temperature_column=\"temperature_2m\",\n",
     "        relative_humidity_column=\"relative_humidity_2m\",\n",
     "        wind_speed_column=\"wind_speed_10m\",\n",
     "        radiation_column=\"shortwave_radiation\",  # Solar radiation\n",
     "        pressure_column=\"surface_pressure\",\n",
-    "        \n",
     "        # Training settings\n",
     "        verbosity=1,  # Show progress during training\n",
     "        mlflow_storage=None,  # Disable MLflow tracking for this demo\n",
-    "        \n",
     "        # Model-specific hyperparameters\n",
     "        gblinear_hyperparams=GBLinearForecaster.HyperParams(\n",
     "            n_steps=50  # Number of boosting iterations\n",
-    "        )\n",
+    "        ),\n",
     "    )\n",
     ")\n",
     "\n",
@@ -607,7 +182,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "8915b7ec",
+   "id": "293d3e51",
    "metadata": {},
    "source": [
     "## 🏋️ Step 5: Train the Model\n",
@@ -620,116 +195,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "0b941aec",
+   "execution_count": null,
+   "id": "7ab71aca",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2025-12-18 10:02:56,143][INFO] 🏋️ Starting model training...\n",
-      "[2025-12-18 10:03:01,055][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
-      "[2025-12-18 10:03:01,145][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0]\tvalidation_0-mean_pinball_loss:0.34654\tvalidation_1-mean_pinball_loss:0.36681\n",
-      "[1]\tvalidation_0-mean_pinball_loss:0.28074\tvalidation_1-mean_pinball_loss:0.28772\n",
-      "[2]\tvalidation_0-mean_pinball_loss:0.23783\tvalidation_1-mean_pinball_loss:0.24820\n",
-      "[3]\tvalidation_0-mean_pinball_loss:0.19941\tvalidation_1-mean_pinball_loss:0.20827\n",
-      "[4]\tvalidation_0-mean_pinball_loss:0.16488\tvalidation_1-mean_pinball_loss:0.17611\n",
-      "[5]\tvalidation_0-mean_pinball_loss:0.14004\tvalidation_1-mean_pinball_loss:0.15021\n",
-      "[6]\tvalidation_0-mean_pinball_loss:0.12265\tvalidation_1-mean_pinball_loss:0.13525\n",
-      "[7]\tvalidation_0-mean_pinball_loss:0.11013\tvalidation_1-mean_pinball_loss:0.12140\n",
-      "[8]\tvalidation_0-mean_pinball_loss:0.10130\tvalidation_1-mean_pinball_loss:0.11318\n",
-      "[9]\tvalidation_0-mean_pinball_loss:0.09485\tvalidation_1-mean_pinball_loss:0.10748\n",
-      "[10]\tvalidation_0-mean_pinball_loss:0.09078\tvalidation_1-mean_pinball_loss:0.10319\n",
-      "[11]\tvalidation_0-mean_pinball_loss:0.08784\tvalidation_1-mean_pinball_loss:0.10065\n",
-      "[12]\tvalidation_0-mean_pinball_loss:0.08576\tvalidation_1-mean_pinball_loss:0.09836\n",
-      "[13]\tvalidation_0-mean_pinball_loss:0.08408\tvalidation_1-mean_pinball_loss:0.09706\n",
-      "[14]\tvalidation_0-mean_pinball_loss:0.08281\tvalidation_1-mean_pinball_loss:0.09572\n",
-      "[15]\tvalidation_0-mean_pinball_loss:0.08183\tvalidation_1-mean_pinball_loss:0.09474\n",
-      "[16]\tvalidation_0-mean_pinball_loss:0.08119\tvalidation_1-mean_pinball_loss:0.09385\n",
-      "[17]\tvalidation_0-mean_pinball_loss:0.08059\tvalidation_1-mean_pinball_loss:0.09331\n",
-      "[18]\tvalidation_0-mean_pinball_loss:0.08052\tvalidation_1-mean_pinball_loss:0.09299\n",
-      "[19]\tvalidation_0-mean_pinball_loss:0.08036\tvalidation_1-mean_pinball_loss:0.09239\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/egor.dmitriev/projects/openstef/openstef4-clean/.venv/lib/python3.12/site-packages/sklearn/utils/validation.py:2749: UserWarning:\n",
-      "\n",
-      "X does not have valid feature names, but StandardScaler was fitted with feature names\n",
-      "\n",
-      "/Users/egor.dmitriev/projects/openstef/openstef4-clean/.venv/lib/python3.12/site-packages/sklearn/utils/validation.py:2749: UserWarning:\n",
-      "\n",
-      "X does not have valid feature names, but StandardScaler was fitted with feature names\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[20]\tvalidation_0-mean_pinball_loss:0.08052\tvalidation_1-mean_pinball_loss:0.09255\n",
-      "[21]\tvalidation_0-mean_pinball_loss:0.08114\tvalidation_1-mean_pinball_loss:0.09265\n",
-      "[22]\tvalidation_0-mean_pinball_loss:0.08175\tvalidation_1-mean_pinball_loss:0.09235\n",
-      "[23]\tvalidation_0-mean_pinball_loss:0.08205\tvalidation_1-mean_pinball_loss:0.09331\n",
-      "[24]\tvalidation_0-mean_pinball_loss:0.08073\tvalidation_1-mean_pinball_loss:0.09111\n",
-      "[25]\tvalidation_0-mean_pinball_loss:0.08169\tvalidation_1-mean_pinball_loss:0.09298\n",
-      "[26]\tvalidation_0-mean_pinball_loss:0.08060\tvalidation_1-mean_pinball_loss:0.09054\n",
-      "[27]\tvalidation_0-mean_pinball_loss:0.08125\tvalidation_1-mean_pinball_loss:0.09222\n",
-      "[28]\tvalidation_0-mean_pinball_loss:0.08073\tvalidation_1-mean_pinball_loss:0.09113\n",
-      "[29]\tvalidation_0-mean_pinball_loss:0.08109\tvalidation_1-mean_pinball_loss:0.09149\n",
-      "[30]\tvalidation_0-mean_pinball_loss:0.07938\tvalidation_1-mean_pinball_loss:0.08998\n",
-      "[31]\tvalidation_0-mean_pinball_loss:0.08070\tvalidation_1-mean_pinball_loss:0.09116\n",
-      "[32]\tvalidation_0-mean_pinball_loss:0.07935\tvalidation_1-mean_pinball_loss:0.08972\n",
-      "[33]\tvalidation_0-mean_pinball_loss:0.08050\tvalidation_1-mean_pinball_loss:0.09142\n",
-      "[34]\tvalidation_0-mean_pinball_loss:0.07927\tvalidation_1-mean_pinball_loss:0.08984\n",
-      "[35]\tvalidation_0-mean_pinball_loss:0.07933\tvalidation_1-mean_pinball_loss:0.08964\n",
-      "[36]\tvalidation_0-mean_pinball_loss:0.07902\tvalidation_1-mean_pinball_loss:0.08964\n",
-      "[37]\tvalidation_0-mean_pinball_loss:0.07927\tvalidation_1-mean_pinball_loss:0.08951\n",
-      "[38]\tvalidation_0-mean_pinball_loss:0.07846\tvalidation_1-mean_pinball_loss:0.08889\n",
-      "[39]\tvalidation_0-mean_pinball_loss:0.07865\tvalidation_1-mean_pinball_loss:0.08893\n",
-      "[40]\tvalidation_0-mean_pinball_loss:0.07885\tvalidation_1-mean_pinball_loss:0.08864\n",
-      "[41]\tvalidation_0-mean_pinball_loss:0.07833\tvalidation_1-mean_pinball_loss:0.08871\n",
-      "[42]\tvalidation_0-mean_pinball_loss:0.07842\tvalidation_1-mean_pinball_loss:0.08826\n",
-      "[43]\tvalidation_0-mean_pinball_loss:0.07787\tvalidation_1-mean_pinball_loss:0.08790\n",
-      "[44]\tvalidation_0-mean_pinball_loss:0.07879\tvalidation_1-mean_pinball_loss:0.08864\n",
-      "[45]\tvalidation_0-mean_pinball_loss:0.07836\tvalidation_1-mean_pinball_loss:0.08847\n",
-      "[46]\tvalidation_0-mean_pinball_loss:0.07775\tvalidation_1-mean_pinball_loss:0.08809\n",
-      "[47]\tvalidation_0-mean_pinball_loss:0.07848\tvalidation_1-mean_pinball_loss:0.08877\n",
-      "[48]\tvalidation_0-mean_pinball_loss:0.07738\tvalidation_1-mean_pinball_loss:0.08726\n",
-      "[49]\tvalidation_0-mean_pinball_loss:0.07937\tvalidation_1-mean_pinball_loss:0.08972\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2025-12-18 10:03:01,684][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
-      "[2025-12-18 10:03:01,845][INFO] ✅ Training complete!\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "📊 Training Evaluation Metrics:\n",
-      "   quantile        R2  observed_probability\n",
-      "0       0.5  0.832467              0.588542\n",
-      "1       0.1  0.546606              0.097106\n",
-      "2       0.9  0.673674              0.896412\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Train the model on historical data\n",
     "logger.info(\"🏋️ Starting model training...\")\n",
@@ -741,7 +210,7 @@
     "    logger.info(\"✅ Training complete!\")\n",
     "    print(\"\\n📊 Training Evaluation Metrics:\")\n",
     "    print(result.metrics_full.to_dataframe())\n",
-    "    \n",
+    "\n",
     "    if result.metrics_test is not None:\n",
     "        print(\"\\n📊 Test Set Metrics (held-out validation):\")\n",
     "        print(result.metrics_test.to_dataframe())"
@@ -749,12 +218,13 @@
   },
   {
    "cell_type": "markdown",
-   "id": "2f89ec59",
+   "id": "95f5f18a",
    "metadata": {},
    "source": [
     "## 🔮 Step 6: Generate Forecasts\n",
     "\n",
-    "Now we use the trained model to predict energy load for the next 14 days. The output is a **ForecastDataset** containing:\n",
+    "Now we use the trained model to predict energy load for the next 14 days.\n",
+    "The output is a **ForecastDataset** containing:\n",
     "- **Median prediction** (`quantile_P50`)\n",
     "- **Lower bound** (`quantile_P10`) — 10th percentile\n",
     "- **Upper bound** (`quantile_P90`) — 90th percentile"
@@ -762,45 +232,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "5e18b079",
+   "execution_count": null,
+   "id": "b341466f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[2025-12-18 10:03:35,739][INFO] 🔮 Generating forecasts...\n",
-      "[2025-12-18 10:03:35,799][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "📈 Forecast generated for 1344 timestamps\n",
-      "📊 Quantiles: [0.5, 0.1, 0.9]\n",
-      "\n",
-      "🔍 Last 5 forecast values:\n",
-      "                           quantile_P50  quantile_P10  quantile_P90  \\\n",
-      "timestamp                                                             \n",
-      "2024-06-12 22:45:00+00:00  447179.46875  349485.43750  463569.37500   \n",
-      "2024-06-12 23:00:00+00:00  426611.46875  338778.75000  441480.65625   \n",
-      "2024-06-12 23:15:00+00:00  419707.53125  333263.15625  432374.56250   \n",
-      "2024-06-12 23:30:00+00:00  407833.06250  322110.18750  417114.21875   \n",
-      "2024-06-12 23:45:00+00:00  391867.12500  309917.56250  400718.81250   \n",
-      "\n",
-      "                                    load         stdev  \n",
-      "timestamp                                               \n",
-      "2024-06-12 22:45:00+00:00  326666.666667  37886.939488  \n",
-      "2024-06-12 23:00:00+00:00  326666.666667  35856.540448  \n",
-      "2024-06-12 23:15:00+00:00  320000.000000  35856.540448  \n",
-      "2024-06-12 23:30:00+00:00  310000.000000  35856.540448  \n",
-      "2024-06-12 23:45:00+00:00  296666.666667  35856.540448  \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Generate probabilistic forecasts for the forecast period\n",
     "from openstef_core.datasets import ForecastDataset\n",
@@ -817,7 +252,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "67585d92",
+   "id": "f3c5c3c6",
    "metadata": {},
    "source": [
     "## 📈 Step 7: Visualize Forecast Results\n",
@@ -830,18 +265,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "dbdead5d",
+   "execution_count": null,
+   "id": "17801cef",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create an interactive forecast visualization\n",
     "from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter\n",
@@ -854,7 +281,7 @@
     "    .add_model(\n",
     "        model_name=\"GBLinear\",\n",
     "        forecast=forecast.median_series,  # P50 prediction\n",
-    "        quantiles=forecast.quantiles_data  # P10-P90 confidence band\n",
+    "        quantiles=forecast.quantiles_data,  # P10-P90 confidence band\n",
     "    )\n",
     "    .plot()\n",
     ")\n",
@@ -864,42 +291,38 @@
     "    title=\"🔮 Energy Load Forecast vs Actual\",\n",
     "    yaxis_title=\"Load (MW)\",\n",
     "    xaxis_title=\"Time\",\n",
-    "    height=500\n",
+    "    height=500,\n",
     ")\n",
     "fig.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f1647ef2",
+   "id": "6f24ae06",
    "metadata": {},
    "source": [
     "## 🔍 Step 8: Explain Feature Importance\n",
     "\n",
-    "Understanding **why** the model makes certain predictions is crucial for trust and debugging. GBLinear models provide clear feature importance rankings."
+    "Understanding **why** the model makes certain predictions is crucial for trust\n",
+    "and debugging. GBLinear models provide clear feature importance rankings."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "d5c6859c",
+   "execution_count": null,
+   "id": "932b62c8",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize feature importance using the ExplainableForecaster interface\n",
     "from typing import cast\n",
+    "\n",
     "from openstef_models.explainability import ExplainableForecaster\n",
+    "from openstef_models.models.forecasting_model import ForecastingModel\n",
     "\n",
     "# The GBLinear model implements ExplainableForecaster, providing feature importance\n",
-    "explainable_model = cast(ExplainableForecaster, workflow.model.forecaster)\n",
+    "forecaster = cast(ForecastingModel, workflow.model).forecaster\n",
+    "explainable_model = cast(ExplainableForecaster, forecaster)\n",
     "\n",
     "# Create an interactive treemap of feature importances\n",
     "# Larger boxes = more important features\n",
@@ -910,7 +333,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "01c28d0d",
+   "id": "1f53f172",
    "metadata": {},
    "source": [
     "---\n",
@@ -935,22 +358,13 @@
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
    "display_name": ".venv",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
   }
  },
  "nbformat": 4,
diff --git a/examples/tutorials/forecasting_with_workflow_presets.py b/examples/tutorials/forecasting_with_workflow_presets.py
new file mode 100644
index 000000000..4c7f8be3d
--- /dev/null
+++ b/examples/tutorials/forecasting_with_workflow_presets.py
@@ -0,0 +1,255 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: .venv
+#     language: python
+#     name: python3
+# ---
+
+# %%
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# pyright: basic
+
+# %% [markdown]
+# # 🔮 Forecasting with OpenSTEF 4.0 Workflow Presets
+#
+# This tutorial demonstrates how to use **OpenSTEF 4.0** to create energy load forecasts
+# using the **Workflow Presets** pattern. You'll learn how to:
+#
+# 1. **Load real-world energy data** from the Liander 2024 benchmark dataset
+# 2. **Configure a forecasting workflow** with weather features and prediction quantiles
+# 3. **Train a model** and inspect its performance
+# 4. **Generate probabilistic forecasts** with confidence intervals
+# 5. **Visualize results** and explain feature importance
+#
+# > **OpenSTEF** (Short-Term Energy Forecasting) is a modular library for creating
+# > accurate energy forecasts in the power grid domain.
+
+# %%
+# --- Setup: Logging and Display Configuration ---
+from typing import Any, cast
+
+from openstef_core.testing import configure_notebook_display, setup_notebook_logging
+
+configure_notebook_display()
+logger = setup_notebook_logging(__name__)
+
+# %% [markdown]
+# ## 📦 Step 1: Download the Dataset
+#
+# We'll use the **Liander 2024 Energy Forecasting Benchmark** dataset from HuggingFace Hub. This dataset contains:
+# - **Load measurements** — historical energy consumption from various installations (mv feeders, transformers, etc.)
+# - **Weather forecasts** — versioned weather predictions (temperature, radiation, wind, etc.)
+# - **EPEX prices** — day-ahead electricity market prices
+# - **Profiles** — typical daily/weekly load patterns
+
+# %%
+# Download and combine the Liander benchmark dataset into a single TimeSeriesDataset.
+from openstef_core.testing import load_liander_dataset, prepare_tutorial_datasets
+
+dataset = load_liander_dataset()
+
+print(f"Dataset shape: {dataset.data.shape}")
+print(f"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}")
+dataset.data.head()
+
+# %% [markdown]
+# ## ✂️ Step 3: Split Data into Training and Forecast Periods
+#
+# We'll use:
+# - **90 days** of historical data for training
+# - **14 days** as the forecast period (where we'll generate predictions)
+
+# %%
+# Split the dataset into training (90 days) and forecast (14 days) periods.
+train_dataset, forecast_dataset = prepare_tutorial_datasets()
+
+# %%
+# Visualize the training data
+# The plot shows the 'load' column (energy consumption in MW) over time
+# cast() needed: pandas returns plotly Figure at runtime (backend="plotly") but typed as Axes
+fig = cast(Any, train_dataset.data[["load"]].plot(title="Training Data: Energy Load over Time"))
+fig.update_layout(yaxis_title="Load (MW)", xaxis_title="Time")
+fig.show()
+
+# %% [markdown]
+# ## ⚙️ Step 4: Configure the Forecasting Workflow
+#
+# OpenSTEF uses a **ForecastingWorkflowConfig** to define all aspects of the forecasting pipeline:
+# - **Model type** — `gblinear` (gradient boosted linear model) or `xgboost`
+# - **Forecast horizons** — how far ahead to predict (e.g., 36 hours)
+# - **Quantiles** — prediction intervals for probabilistic forecasts
+# - **Feature columns** — which weather variables to use
+#
+# The **GBLinear** model is particularly good for energy forecasting because:
+# 1. It can extrapolate beyond training data (important for rare events)
+# 2. It provides interpretable feature importance
+# 3. It's fast to train and predict
+
+# %%
+# Import workflow components
+from openstef_core.types import LeadTime, Q  # LeadTime: forecast horizon, Q: quantile
+from openstef_models.presets import ForecastingWorkflowConfig, create_forecasting_workflow
+from openstef_models.presets.forecasting_workflow import GBLinearForecaster
+
+# Configure the forecasting workflow
+workflow = create_forecasting_workflow(
+    config=ForecastingWorkflowConfig(
+        # Model identification
+        model_id="gblinear_demo_v1",
+        model="gblinear",  # Use gradient boosted linear model
+        # Forecast settings
+        horizons=[LeadTime.from_string("PT36H")],  # Predict up to 36 hours ahead
+        quantiles=[Q(0.5), Q(0.1), Q(0.9)],  # Median + 80% prediction interval
+        # Target column (what we're predicting)
+        target_column="load",
+        # Weather feature columns (from the dataset)
+        temperature_column="temperature_2m",
+        relative_humidity_column="relative_humidity_2m",
+        wind_speed_column="wind_speed_10m",
+        radiation_column="shortwave_radiation",  # Solar radiation
+        pressure_column="surface_pressure",
+        # Training settings
+        verbosity=1,  # Show progress during training
+        mlflow_storage=None,  # Disable MLflow tracking for this demo
+        # Model-specific hyperparameters
+        gblinear_hyperparams=GBLinearForecaster.HyperParams(
+            n_steps=50  # Number of boosting iterations
+        ),
+    )
+)
+
+print("✅ Workflow configured successfully!")
+
+# %% [markdown]
+# ## 🏋️ Step 5: Train the Model
+#
+# The workflow's `fit()` method handles the entire training pipeline:
+# 1. **Preprocessing** — feature engineering, data validation, scaling
+# 2. **Training** — fit the model on historical data
+# 3. **Evaluation** — compute metrics on training data
+
+# %%
+# Train the model on historical data
+logger.info("🏋️ Starting model training...")
+
+result = workflow.fit(train_dataset)
+
+# Display training metrics
+if result is not None:
+    logger.info("✅ Training complete!")
+    print("\n📊 Training Evaluation Metrics:")
+    print(result.metrics_full.to_dataframe())
+
+    if result.metrics_test is not None:
+        print("\n📊 Test Set Metrics (held-out validation):")
+        print(result.metrics_test.to_dataframe())
+
+# %% [markdown]
+# ## 🔮 Step 6: Generate Forecasts
+#
+# Now we use the trained model to predict energy load for the next 14 days.
+# The output is a **ForecastDataset** containing:
+# - **Median prediction** (`quantile_P50`)
+# - **Lower bound** (`quantile_P10`) — 10th percentile
+# - **Upper bound** (`quantile_P90`) — 90th percentile
+
+# %%
+# Generate probabilistic forecasts for the forecast period
+from openstef_core.datasets import ForecastDataset
+
+logger.info("🔮 Generating forecasts...")
+forecast: ForecastDataset = workflow.predict(forecast_dataset)
+
+# Display forecast summary
+print(f"\n📈 Forecast generated for {len(forecast.data)} timestamps")
+print(f"📊 Quantiles: {forecast.quantiles}")
+print("\n🔍 Last 5 forecast values:")
+print(forecast.data.tail())
+
+# %% [markdown]
+# ## 📈 Step 7: Visualize Forecast Results
+#
+# OpenSTEF-BEAM provides **ForecastTimeSeriesPlotter** for beautiful interactive visualizations:
+# - Actual measurements shown as a line
+# - Forecast median shown as another line
+# - Prediction intervals shown as shaded areas
+
+# %%
+# Create an interactive forecast visualization
+from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter
+
+fig = (
+    ForecastTimeSeriesPlotter()
+    # Add actual measurements (ground truth)
+    .add_measurements(measurements=forecast_dataset.data["load"])
+    # Add model predictions with confidence bands
+    .add_model(
+        model_name="GBLinear",
+        forecast=forecast.median_series,  # P50 prediction
+        quantiles=forecast.quantiles_data,  # P10-P90 confidence band
+    )
+    .plot()
+)
+
+# Update layout for better presentation
+fig.update_layout(
+    title="🔮 Energy Load Forecast vs Actual",
+    yaxis_title="Load (MW)",
+    xaxis_title="Time",
+    height=500,
+)
+fig.show()
+
+# %% [markdown]
+# ## 🔍 Step 8: Explain Feature Importance
+#
+# Understanding **why** the model makes certain predictions is crucial for trust
+# and debugging. GBLinear models provide clear feature importance rankings.
+
+# %%
+# Visualize feature importance using the ExplainableForecaster interface
+from typing import cast
+
+from openstef_models.explainability import ExplainableForecaster
+from openstef_models.models.forecasting_model import ForecastingModel
+
+# The GBLinear model implements ExplainableForecaster, providing feature importance
+forecaster = cast(ForecastingModel, workflow.model).forecaster
+explainable_model = cast(ExplainableForecaster, forecaster)
+
+# Create an interactive treemap of feature importances
+# Larger boxes = more important features
+fig = explainable_model.plot_feature_importances()
+fig.update_layout(title="🔍 Feature Importance Treemap")
+fig.show()
+
+# %% [markdown]
+# ---
+#
+# ## 🎯 Summary
+#
+# In this tutorial, you learned how to:
+#
+# 1. ✅ **Load energy data** from the Liander 2024 benchmark dataset
+# 2. ✅ **Configure a workflow** with `ForecastingWorkflowConfig`
+# 3. ✅ **Train a GBLinear model** for probabilistic forecasting
+# 4. ✅ **Generate forecasts** with confidence intervals
+# 5. ✅ **Visualize results** and feature importance
+#
+# ### 🚀 Next Steps
+#
+# - Try different models: `"xgboost"` for more complex patterns
+# - Experiment with more quantiles for narrower prediction intervals
+# - Use the **backtesting notebook** to evaluate model performance systematically
+# - Explore MLflow integration for experiment tracking
diff --git a/examples/tutorials/hyperparameter_tuning_with_optuna.ipynb b/examples/tutorials/hyperparameter_tuning_with_optuna.ipynb
new file mode 100644
index 000000000..84e8f6685
--- /dev/null
+++ b/examples/tutorials/hyperparameter_tuning_with_optuna.ipynb
@@ -0,0 +1,327 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feff3c78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>\n",
+    "#\n",
+    "# SPDX-License-Identifier: MPL-2.0\n",
+    "\n",
+    "# pyright: basic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31e74f93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- Setup: Logging and Display Configuration ---\n",
+    "# Configure logging and display settings for the notebook\n",
+    "from typing import Literal\n",
+    "\n",
+    "from openstef_core.testing import configure_notebook_display, setup_notebook_logging\n",
+    "\n",
+    "configure_notebook_display()\n",
+    "logger = setup_notebook_logging(__name__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb35b300",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Download and combine the Liander benchmark dataset into a single TimeSeriesDataset.\n",
+    "from openstef_core.testing import load_liander_dataset, prepare_tutorial_datasets\n",
+    "\n",
+    "dataset = load_liander_dataset()\n",
+    "\n",
+    "print(f\"Dataset shape: {dataset.data.shape}\")\n",
+    "print(f\"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}\")\n",
+    "dataset.data.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eee2c101",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Split the dataset into training (90 days) and forecast (14 days) periods.\n",
+    "train_dataset, forecast_dataset = prepare_tutorial_datasets()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "695ea7fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize the training data\n",
+    "# The plot shows the 'load' column (energy consumption in MW) over time\n",
+    "fig = train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\")\n",
+    "fig.update_layout(yaxis_title=\"Load (MW)\", xaxis_title=\"Time\")  # type: ignore[union-attr]  # plotly Figure\n",
+    "fig.show()  # type: ignore[union-attr]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed1b233e",
+   "metadata": {},
+   "source": [
+    "## Define a base config with inline search space\n",
+    "\n",
+    "Override default hyperparameters with `TuningRange(tune=True)` to mark them for tuning.\n",
+    "Any parameter left as a plain value keeps its default during tuning."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc276f61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openstef_beam.evaluation.metric_providers import ObservedProbabilityProvider, RMAEProvider\n",
+    "from openstef_core.mixins.param_ranges import FloatRange, IntRange\n",
+    "from openstef_core.types import LeadTime, Q\n",
+    "from openstef_models.integrations.optuna import HyperparameterTuner\n",
+    "from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams\n",
+    "from openstef_models.presets import ForecastingWorkflowConfig, create_forecasting_workflow\n",
+    "\n",
+    "config = ForecastingWorkflowConfig(\n",
+    "    model_id=\"tuning_demo\",\n",
+    "    model=\"xgboost\",\n",
+    "    # Forecast settings\n",
+    "    horizons=[LeadTime.from_string(\"PT36H\")],  # Predict up to 36 hours ahead\n",
+    "    quantiles=[Q(0.5), Q(0.1), Q(0.9)],  # Median + 80% prediction interval\n",
+    "    # Target column (what we're predicting)\n",
+    "    target_column=\"load\",\n",
+    "    # Weather feature columns (from the dataset)\n",
+    "    temperature_column=\"temperature_2m\",\n",
+    "    relative_humidity_column=\"relative_humidity_2m\",\n",
+    "    wind_speed_column=\"wind_speed_10m\",\n",
+    "    radiation_column=\"shortwave_radiation\",  # Solar radiation\n",
+    "    pressure_column=\"surface_pressure\",\n",
+    "    # Hyperparameters to tune\n",
+    "    xgboost_hyperparams=XGBoostHyperParams(\n",
+    "        learning_rate=FloatRange(0.01, 0.3, log=True, tune=True),  # pyright: ignore[reportCallIssue]  # ranges accepted at runtime via Annotated\n",
+    "        n_estimators=IntRange(50, 500, tune=True),\n",
+    "        max_depth=IntRange(3, 10, tune=True),\n",
+    "        subsample=FloatRange(0.5, 1.0, tune=True),\n",
+    "        colsample_bytree=FloatRange(0.5, 1.0, tune=True),\n",
+    "    ),\n",
+    "    evaluation_metrics=[RMAEProvider(), ObservedProbabilityProvider()],\n",
+    "    mlflow_storage=None,  # Disable MLFlow tune to avoid reusing models between trials.\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7168a1a8",
+   "metadata": {},
+   "source": [
+    "## Inspect the resolved search space\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41f1b6ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Get the search space from the hyperparams instance (resolve fills None bounds from class-level defaults).\n",
+    "resolved_space = config.xgboost_hyperparams.get_search_space()\n",
+    "\n",
+    "print(\"Resolved search space:\")\n",
+    "for name, param in resolved_space.items():\n",
+    "    if isinstance(param, (FloatRange, IntRange)):\n",
+    "        scale = \"  [log]\" if param.log else \"\"\n",
+    "        print(f\"  {name:25s}: {type(param).__name__}  [{param.low} — {param.high}]{scale}\")\n",
+    "    else:\n",
+    "        print(f\"  {name:25s}: CategoricalRange  {param.choices}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dabeaa30",
+   "metadata": {},
+   "source": [
+    "## Run the Optuna study with `HyperparameterTuner`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b170806",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "import optuna\n",
+    "\n",
+    "optuna.logging.set_verbosity(optuna.logging.WARNING)  # Suppress per-trial logs\n",
+    "\n",
+    "tuner = HyperparameterTuner(\n",
+    "    config=config,\n",
+    "    train_dataset=train_dataset,\n",
+    "    create_workflow=create_forecasting_workflow,\n",
+    "    target_quantile=Q(0.5),\n",
+    "    metric_name=\"rMAE\",\n",
+    "    direction=\"minimize\",\n",
+    "    n_trials=20,\n",
+    "    seed=42,\n",
+    ")\n",
+    "tuning_result = tuner.fit_with_tuning()\n",
+    "\n",
+    "print(f\"Study complete: {len(tuning_result.study.trials)} trials\")\n",
+    "print(f\"Best value: {tuning_result.study.best_value:.4f}\")\n",
+    "print(f\"Best params: {tuning_result.study.best_params}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "602f6b4f",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "# Inspect which hyperparameters were tuned vs kept at their default.\n",
+    "best_config = tuning_result.best_config  # type: ignore[union-attr]  # known to be ForecastingWorkflowConfig\n",
+    "print(\"Final XGBoost hyperparameters (tuned values marked):\")\n",
+    "final_hp = best_config.xgboost_hyperparams\n",
+    "baseline_hp = config.xgboost_hyperparams\n",
+    "best_params = tuning_result.study.best_params\n",
+    "\n",
+    "for field in type(final_hp).model_fields:\n",
+    "    value = getattr(final_hp, field)\n",
+    "    baseline = getattr(baseline_hp, field)\n",
+    "    marker: Literal[\" <- tuned\", \"\"] = \" <- tuned\" if field in best_params else \"\"\n",
+    "    print(f\"  {field:25s}: {value}{marker}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2875de25",
+   "metadata": {},
+   "source": [
+    "## The fitted workflow\n",
+    "\n",
+    "`fit_with_tuning()` already trains a final workflow on the full training set using the best\n",
+    "hyperparameters — no separate fit step is needed. The result is in `tuning_result.workflow`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d91be63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "workflow = tuning_result.workflow"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb6ba8c7",
+   "metadata": {},
+   "source": [
+    "## Inspect the study and forecast\n",
+    "\n",
+    "1. How did $rMAE$ improve over trials?\n",
+    "2. Which parameters had the most impact?\n",
+    "3. Final tuned model predictions on the held-out forecast window.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d34a7fa",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "from optuna.visualization import plot_optimization_history, plot_param_importances\n",
+    "\n",
+    "study = tuning_result.study\n",
+    "\n",
+    "# How the best score evolved over trials\n",
+    "fig = plot_optimization_history(study)\n",
+    "fig.update_layout(title=\"Optimization History: rMAE over Trials\")\n",
+    "fig.show()\n",
+    "\n",
+    "# Which hyperparameters mattered most (requires ≥ ~20 trials for reliable ranking)\n",
+    "fig2 = plot_param_importances(study)\n",
+    "fig2.update_layout(title=\"Hyperparameter Importances\")\n",
+    "fig2.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b2b1124",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [],
+   "source": [
+    "from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter\n",
+    "\n",
+    "forecast = workflow.predict(forecast_dataset)\n",
+    "\n",
+    "fig = (\n",
+    "    ForecastTimeSeriesPlotter()\n",
+    "    .add_measurements(measurements=forecast_dataset.data[\"load\"])\n",
+    "    .add_model(\n",
+    "        model_name=\"XGBoost (tuned)\",\n",
+    "        forecast=forecast.median_series,\n",
+    "        quantiles=forecast.quantiles_data,\n",
+    "    )\n",
+    "    .plot()\n",
+    ")\n",
+    "fig.update_layout(\n",
+    "    title=\"Tuned XGBoost Forecast vs Actual\",\n",
+    "    yaxis_title=\"Load (MW)\",\n",
+    "    xaxis_title=\"Time\",\n",
+    "    height=500,\n",
+    ")\n",
+    "fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4a861db",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/tutorials/hyperparameter_tuning_with_optuna.py b/examples/tutorials/hyperparameter_tuning_with_optuna.py
new file mode 100644
index 000000000..ad4608b19
--- /dev/null
+++ b/examples/tutorials/hyperparameter_tuning_with_optuna.py
@@ -0,0 +1,209 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: .venv
+#     language: python
+#     name: python3
+# ---
+
+# %%
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# pyright: basic
+
+# %%
+# --- Setup: Logging and Display Configuration ---
+# Configure logging and display settings for the notebook
+from typing import Literal
+
+from openstef_core.testing import configure_notebook_display, setup_notebook_logging
+
+configure_notebook_display()
+logger = setup_notebook_logging(__name__)
+
+# %%
+# Download and combine the Liander benchmark dataset into a single TimeSeriesDataset.
+from openstef_core.testing import load_liander_dataset, prepare_tutorial_datasets
+
+dataset = load_liander_dataset()
+
+print(f"Dataset shape: {dataset.data.shape}")
+print(f"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}")
+dataset.data.head()
+
+# %%
+# Split the dataset into training (90 days) and forecast (14 days) periods.
+train_dataset, forecast_dataset = prepare_tutorial_datasets()
+
+# %%
+# Visualize the training data
+# The plot shows the 'load' column (energy consumption in MW) over time
+fig = train_dataset.data[["load"]].plot(title="Training Data: Energy Load over Time")
+fig.update_layout(yaxis_title="Load (MW)", xaxis_title="Time")  # type: ignore[union-attr]  # plotly Figure
+fig.show()  # type: ignore[union-attr]
+
+# %% [markdown]
+# ## Define a base config with inline search space
+#
+# Override default hyperparameters with `TuningRange(tune=True)` to mark them for tuning.
+# Any parameter left as a plain value keeps its default during tuning.
+
+# %%
+from openstef_beam.evaluation.metric_providers import ObservedProbabilityProvider, RMAEProvider
+from openstef_core.mixins.param_ranges import FloatRange, IntRange
+from openstef_core.types import LeadTime, Q
+from openstef_models.integrations.optuna import HyperparameterTuner
+from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams
+from openstef_models.presets import ForecastingWorkflowConfig, create_forecasting_workflow
+
+config = ForecastingWorkflowConfig(
+    model_id="tuning_demo",
+    model="xgboost",
+    # Forecast settings
+    horizons=[LeadTime.from_string("PT36H")],  # Predict up to 36 hours ahead
+    quantiles=[Q(0.5), Q(0.1), Q(0.9)],  # Median + 80% prediction interval
+    # Target column (what we're predicting)
+    target_column="load",
+    # Weather feature columns (from the dataset)
+    temperature_column="temperature_2m",
+    relative_humidity_column="relative_humidity_2m",
+    wind_speed_column="wind_speed_10m",
+    radiation_column="shortwave_radiation",  # Solar radiation
+    pressure_column="surface_pressure",
+    # Hyperparameters to tune
+    xgboost_hyperparams=XGBoostHyperParams(
+        learning_rate=FloatRange(0.01, 0.3, log=True, tune=True),  # pyright: ignore[reportCallIssue]  # ranges accepted at runtime via Annotated
+        n_estimators=IntRange(50, 500, tune=True),
+        max_depth=IntRange(3, 10, tune=True),
+        subsample=FloatRange(0.5, 1.0, tune=True),
+        colsample_bytree=FloatRange(0.5, 1.0, tune=True),
+    ),
+    evaluation_metrics=[RMAEProvider(), ObservedProbabilityProvider()],
+    mlflow_storage=None,  # Disable MLFlow tune to avoid reusing models between trials.
+)
+
+# %% [markdown]
+# ## Inspect the resolved search space
+#
+
+# %%
+
+# Get the search space from the hyperparams instance (resolve fills None bounds from class-level defaults).
+resolved_space = config.xgboost_hyperparams.get_search_space()
+
+print("Resolved search space:")
+for name, param in resolved_space.items():
+    if isinstance(param, (FloatRange, IntRange)):
+        scale = "  [log]" if param.log else ""
+        print(f"  {name:25s}: {type(param).__name__}  [{param.low} — {param.high}]{scale}")
+    else:
+        print(f"  {name:25s}: CategoricalRange  {param.choices}")
+
+# %% [markdown]
+# ## Run the Optuna study with `HyperparameterTuner`
+
+# %%
+import optuna
+
+optuna.logging.set_verbosity(optuna.logging.WARNING)  # Suppress per-trial logs
+
+tuner = HyperparameterTuner(
+    config=config,
+    train_dataset=train_dataset,
+    create_workflow=create_forecasting_workflow,
+    target_quantile=Q(0.5),
+    metric_name="rMAE",
+    direction="minimize",
+    n_trials=20,
+    seed=42,
+)
+tuning_result = tuner.fit_with_tuning()
+
+print(f"Study complete: {len(tuning_result.study.trials)} trials")
+print(f"Best value: {tuning_result.study.best_value:.4f}")
+print(f"Best params: {tuning_result.study.best_params}")
+
+
+# %%
+# Inspect which hyperparameters were tuned vs kept at their default.
+best_config = tuning_result.best_config  # type: ignore[union-attr]  # known to be ForecastingWorkflowConfig
+print("Final XGBoost hyperparameters (tuned values marked):")
+final_hp = best_config.xgboost_hyperparams
+baseline_hp = config.xgboost_hyperparams
+best_params = tuning_result.study.best_params
+
+for field in type(final_hp).model_fields:
+    value = getattr(final_hp, field)
+    baseline = getattr(baseline_hp, field)
+    marker: Literal[" <- tuned", ""] = " <- tuned" if field in best_params else ""
+    print(f"  {field:25s}: {value}{marker}")
+
+
+# %% [markdown]
+# ## The fitted workflow
+#
+# `fit_with_tuning()` already trains a final workflow on the full training set using the best
+# hyperparameters — no separate fit step is needed. The result is in `tuning_result.workflow`.
+#
+
+# %%
+workflow = tuning_result.workflow
+
+# %% [markdown]
+# ## Inspect the study and forecast
+#
+# 1. How did $rMAE$ improve over trials?
+# 2. Which parameters had the most impact?
+# 3. Final tuned model predictions on the held-out forecast window.
+#
+
+# %%
+from optuna.visualization import plot_optimization_history, plot_param_importances
+
+study = tuning_result.study
+
+# How the best score evolved over trials
+fig = plot_optimization_history(study)
+fig.update_layout(title="Optimization History: rMAE over Trials")
+fig.show()
+
+# Which hyperparameters mattered most (requires ≥ ~20 trials for reliable ranking)
+fig2 = plot_param_importances(study)
+fig2.update_layout(title="Hyperparameter Importances")
+fig2.show()
+
+
+# %%
+from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter
+
+forecast = workflow.predict(forecast_dataset)
+
+fig = (
+    ForecastTimeSeriesPlotter()
+    .add_measurements(measurements=forecast_dataset.data["load"])
+    .add_model(
+        model_name="XGBoost (tuned)",
+        forecast=forecast.median_series,
+        quantiles=forecast.quantiles_data,
+    )
+    .plot()
+)
+fig.update_layout(
+    title="Tuned XGBoost Forecast vs Actual",
+    yaxis_title="Load (MW)",
+    xaxis_title="Time",
+    height=500,
+)
+fig.show()
+
+
+# %%
diff --git a/packages/openstef-beam/src/openstef_beam/evaluation/metric_providers.py b/packages/openstef-beam/src/openstef_beam/evaluation/metric_providers.py
index 757200fda..994cffa2d 100644
--- a/packages/openstef-beam/src/openstef_beam/evaluation/metric_providers.py
+++ b/packages/openstef-beam/src/openstef_beam/evaluation/metric_providers.py
@@ -128,6 +128,15 @@ def compute_probabilistic(
 
         return metrics
 
+    @property
+    def metric_names(self) -> frozenset[str]:
+        """Declared metric names that this provider produces.
+
+        Override in subclasses to enable eager metric-name validation
+        (e.g. in the hyperparameter tuner).
+        """
+        return frozenset()
+
     def compute_deterministic(
         self,
         y_true: npt.NDArray[np.floating],
@@ -153,6 +162,11 @@ class CompletenessProvider(MetricProvider):
     Measures the proportion of non-missing values in the predictions.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"completeness"})
+
     @override
     def compute_deterministic(
         self,
@@ -170,6 +184,20 @@ class PeakMetricProvider(MetricProvider):
     effective cases. Uses confusion matrix based on specified thresholds.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({
+            "num_predicted_peaks",
+            "num_true_peaks",
+            "precision",
+            "recall",
+            "effective_precision",
+            "effective_recall",
+            f"F{self.beta}",
+            f"effective_F{self.beta}",
+        })
+
     limit_pos: float = Field(
         default=0.5,
         description="Positive peak detection threshold. Predictions above this value are considered a peak.",
@@ -217,6 +245,11 @@ class RCRPSProvider(MetricProvider):
     processing individual quantiles.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"rCRPS"})
+
     lower_quantile: float = Field(
         default=0.01,
         description="Lower quantile bound for rCRPS normalization.",
@@ -262,6 +295,11 @@ class RCRPSSampleWeightedProvider(MetricProvider):
     processing individual quantiles.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"rCRPS_sample_weighted"})
+
     lower_quantile: float = Field(
         default=0.01,
         description="Lower quantile bound for rCRPS normalization.",
@@ -325,6 +363,11 @@ class MAEProvider(MetricProvider):
     Computes the average absolute error between predictions and true values.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"MAE"})
+
     allow_nan: bool = Field(
         default=True,
         description="Whether to allow NaN values in input. If False, NaN value will result in NaN metric output.",
@@ -347,6 +390,11 @@ class RMAEProvider(MetricProvider):
     comparable across different scales.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"rMAE"})
+
     lower_quantile: float = Field(
         default=0.01,
         description="Lower quantile bound for rMAE normalization.",
@@ -391,6 +439,11 @@ class RMAEPeakHoursProvider(MetricProvider):
     data points between 8:00 and 20:00 hours.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"rMAE_peak_hours"})
+
     lower_quantile: float = Field(
         default=0.01,
         description="Lower quantile bound for rMAE normalization.",
@@ -457,6 +510,11 @@ class MAPEProvider(MetricProvider):
     errors across different scales.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"MAPE"})
+
     @override
     def compute_deterministic(
         self,
@@ -475,6 +533,11 @@ class R2Provider(MetricProvider):
     Values range from -∞ to 1.0, where 1.0 is perfect prediction.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"R2"})
+
     @override
     def compute_deterministic(
         self,
@@ -494,6 +557,11 @@ class ObservedProbabilityProvider(MetricProvider):
     This metric is only useful as a global metric and not windowed.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"observed_probability"})
+
     @override
     def compute_deterministic(
         self,
@@ -513,6 +581,11 @@ class MeanAbsoluteCalibrationErrorProvider(MetricProvider):
     observed probabilities and predicted quantiles across all samples.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"mean_absolute_calibration_error"})
+
     @override
     def compute_probabilistic(
         self,
@@ -549,6 +622,11 @@ class RIQDProvider(MetricProvider):
     its symmetric counterpart and computes rIQD between them.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"rIQD"})
+
     median_quantile: float = 0.5
 
     measurement_range_lower_q: float = Field(
@@ -627,6 +705,11 @@ class RelativePinballLossProvider(MetricProvider):
     and suitable for comparing quantile prediction errors across different datasets.
     """
 
+    @property
+    @override
+    def metric_names(self) -> frozenset[str]:
+        return frozenset({"relative_pinball_loss"})
+
     measurement_range_lower_q: float = Field(
         default=0.01,
         description="Lower quantile bound for measurement range normalization.",
diff --git a/packages/openstef-core/pyproject.toml b/packages/openstef-core/pyproject.toml
index cc436ee40..8f5aa3576 100644
--- a/packages/openstef-core/pyproject.toml
+++ b/packages/openstef-core/pyproject.toml
@@ -36,6 +36,10 @@ dependencies = [
   "pydantic-extra-types>=2.10.5,<3",
 ]
 
+optional-dependencies.benchmark = [
+  "huggingface-hub>=1.2.2",
+]
+
 urls.Documentation = "https://openstef.github.io/openstef/index.html"
 urls.Homepage = "https://lfenergy.org/projects/openstef/"
 urls.Issues = "https://github.com/OpenSTEF/openstef/issues"
diff --git a/packages/openstef-core/src/openstef_core/base_model.py b/packages/openstef-core/src/openstef_core/base_model.py
index 7321fdf96..c16ef0092 100644
--- a/packages/openstef-core/src/openstef_core/base_model.py
+++ b/packages/openstef-core/src/openstef_core/base_model.py
@@ -15,7 +15,14 @@
 
 import yaml
 from pydantic import BaseModel as PydanticBaseModel
-from pydantic import BeforeValidator, ConfigDict, GetCoreSchemaHandler, TypeAdapter
+from pydantic import (
+    BeforeValidator,
+    ConfigDict,
+    GetCoreSchemaHandler,
+    GetJsonSchemaHandler,
+    TypeAdapter,
+    ValidationInfo,
+)
 from pydantic_core import core_schema
 
 
@@ -115,7 +122,7 @@ def from_string(cls, s: str) -> Self:
         raise NotImplementedError("Subclasses must implement from_string")
 
     @classmethod
-    def validate(cls, v: Any, _info: Any = None) -> Self:  # noqa: ANN401
+    def validate(cls, v: Any, _info: ValidationInfo | None = None) -> Self:  # noqa: ANN401
         """Validate and convert input to this type.
 
         Args:
@@ -154,7 +161,7 @@ def __get_pydantic_core_schema__(
     def __get_pydantic_json_schema__(  # noqa: PLW3201
         cls,
         _schema: core_schema.CoreSchema,
-        handler: Any,  # noqa: ANN401
+        handler: GetJsonSchemaHandler,
     ) -> dict[str, Any]:
         """Generate JSON schema for OpenAPI / FastAPI compatibility.
 
diff --git a/packages/openstef-core/src/openstef_core/constants.py b/packages/openstef-core/src/openstef_core/constants.py
new file mode 100644
index 000000000..b39418ba8
--- /dev/null
+++ b/packages/openstef-core/src/openstef_core/constants.py
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Shared constants for the openstef_core package."""
+
+LIANDER_DATASET_REPO_ID = "OpenSTEF/liander2024-energy-forecasting-benchmark"
+
+
+__all__ = ["LIANDER_DATASET_REPO_ID"]
diff --git a/packages/openstef-core/src/openstef_core/datasets/validated_datasets.py b/packages/openstef-core/src/openstef_core/datasets/validated_datasets.py
index efd24ce13..2371ad6b1 100644
--- a/packages/openstef-core/src/openstef_core/datasets/validated_datasets.py
+++ b/packages/openstef-core/src/openstef_core/datasets/validated_datasets.py
@@ -12,6 +12,7 @@
 from datetime import datetime, timedelta
 from typing import Self, override
 
+import numpy as np
 import pandas as pd
 
 from openstef_core.datasets.timeseries_dataset import TimeSeriesDataset
@@ -277,6 +278,35 @@ def __init__(
 
         self.quantiles = [Quantile.parse(col) for col in quantile_feature_names]
 
+    @classmethod
+    def from_quantile_predictions(
+        cls,
+        predictions: np.ndarray,
+        index: pd.Index,
+        quantiles: list[Quantile],
+        sample_interval: timedelta,
+        *,
+        target_column: str = "load",
+    ) -> "ForecastDataset":
+        """Build a ``ForecastDataset`` from a raw predictions array.
+
+        Args:
+            predictions: Shape ``(n_samples, n_quantiles)``.
+            index: Time index for the predictions.
+            quantiles: Quantiles the model was trained on, in the same order as columns in *predictions*.
+            sample_interval: Temporal resolution of the dataset.
+            target_column: Name of the target column to attach to the dataset.
+
+        Returns:
+            ``ForecastDataset`` with quantile columns and the provided time index.
+        """
+        df = pd.DataFrame(
+            data=predictions,
+            index=index,
+            columns=[q.format() for q in quantiles],
+        )
+        return cls(data=df, sample_interval=sample_interval, target_column=target_column)
+
     @property
     def target_series(self) -> pd.Series | None:
         """Extract the target time series from the dataset.
diff --git a/packages/openstef-core/src/openstef_core/mixins/param_ranges.py b/packages/openstef-core/src/openstef_core/mixins/param_ranges.py
new file mode 100644
index 000000000..ceb0ed485
--- /dev/null
+++ b/packages/openstef-core/src/openstef_core/mixins/param_ranges.py
@@ -0,0 +1,131 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+"""Tuning range types and metadata for hyperparameter search spaces.
+
+Range types (``FloatRange``, ``IntRange``, ``CategoricalRange``) are frozen
+dataclasses used as ``Annotated`` metadata on ``HyperParams`` fields, where
+Pydantic treats plain dataclasses as opaque field metadata.
+
+``ModelTuningInfo`` is a Pydantic model used outside ``Annotated`` context.
+"""
+
+from dataclasses import dataclass, replace
+from typing import Any, Self
+
+from pydantic import ConfigDict, Field, model_validator
+from pydantic.fields import FieldInfo
+
+from openstef_core.base_model import BaseConfig, BaseModel
+
+
+@dataclass(frozen=True)
+class _BoundedRange:
+    """Shared validation and resolution logic for numeric range types.
+
+    Not part of the public API — use ``FloatRange`` or ``IntRange`` instead.
+    """
+
+    low: Any = None
+    high: Any = None
+    log: bool = False
+    tune: bool = False
+
+    def __post_init__(self) -> None:
+        if self.low is not None and self.high is not None and self.low > self.high:
+            msg = f"low ({self.low}) must be <= high ({self.high})"
+            raise ValueError(msg)
+
+    def resolve(self, class_default: Self | None) -> Self:
+        """Fill ``None`` bounds from *class_default*.
+
+        Returns:
+            Resolved range.
+        """
+        if class_default is None:
+            return self
+        return replace(
+            self,
+            low=self.low if self.low is not None else class_default.low,
+            high=self.high if self.high is not None else class_default.high,
+        )
+
+
+@dataclass(frozen=True)
+class FloatRange(_BoundedRange):
+    """Annotate a ``HyperParams`` float field as tunable within ``[low, high]``."""
+
+    low: float | None = None
+    high: float | None = None
+
+
+@dataclass(frozen=True)
+class IntRange(_BoundedRange):
+    """Annotate a ``HyperParams`` int field as tunable within ``[low, high]``."""
+
+    low: int | None = None
+    high: int | None = None
+
+
+@dataclass(frozen=True)
+class CategoricalRange:
+    """Annotate a ``HyperParams`` field as tunable over discrete ``choices``."""
+
+    choices: tuple[Any, ...] | None = None
+    tune: bool = False
+
+    def __post_init__(self) -> None:  # noqa: D105
+        if self.choices is not None and len(self.choices) == 0:
+            msg = "choices must not be empty"
+            raise ValueError(msg)
+
+    def resolve(self, class_default: Self | None) -> Self:
+        """Fill ``None`` choices from *class_default*.
+
+        Returns:
+            Resolved range.
+        """
+        if class_default is None:
+            return self
+        return replace(
+            self,
+            choices=self.choices if self.choices is not None else class_default.choices,
+        )
+
+
+type TuningRange = FloatRange | IntRange | CategoricalRange
+
+
+class ModelTuningInfo(BaseModel):
+    """Groups a hyperparameter config with its resolved search space."""
+
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    field_name: str = Field(description="Name of the HyperParams field on the parent config.")
+    hyperparams: BaseConfig = Field(description="The HyperParams instance that owns the search space.")
+    search_space: dict[str, TuningRange] = Field(description="Resolved tuning ranges keyed by parameter name.")
+
+    @model_validator(mode="after")
+    def _validate_search_space(self) -> Self:
+        if not self.search_space:
+            msg = f"search_space for '{self.field_name}' must not be empty"
+            raise ValueError(msg)
+        return self
+
+
+def get_tuning_range(field_info: FieldInfo) -> TuningRange | None:
+    """Return the first TuningRange found in a Pydantic FieldInfo's metadata."""
+    for meta in field_info.metadata:
+        if isinstance(meta, (FloatRange, IntRange, CategoricalRange)):
+            return meta
+    return None
+
+
+__all__ = [
+    "CategoricalRange",
+    "FloatRange",
+    "IntRange",
+    "ModelTuningInfo",
+    "TuningRange",
+    "get_tuning_range",
+]
diff --git a/packages/openstef-core/src/openstef_core/mixins/predictor.py b/packages/openstef-core/src/openstef_core/mixins/predictor.py
index 4e237b234..75557b9b8 100644
--- a/packages/openstef-core/src/openstef_core/mixins/predictor.py
+++ b/packages/openstef-core/src/openstef_core/mixins/predictor.py
@@ -10,11 +10,14 @@
 Stateful interface.
 """
 
-from typing import Any
+from typing import Any, Self, cast
+
+from pydantic import PrivateAttr, ValidatorFunctionWrapHandler, model_validator
 
 from openstef_core.base_model import BaseConfig
 from openstef_core.datasets.mixins import abstractmethod
 from openstef_core.exceptions import PredictError
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange, TuningRange, get_tuning_range
 from openstef_core.mixins.stateful import Stateful
 
 
@@ -187,18 +190,114 @@ class HyperParams(BaseConfig):
     """Base configuration for model hyperparameters.
 
     Serves as the foundation for model-specific hyperparameter configurations.
-    Inheriting classes should add their specific parameters as Pydantic fields
-    with appropriate validation and documentation.
+    Supports tuning ranges: pass a ``FloatRange``, ``IntRange``, or
+    ``CategoricalRange`` as a field value at construction time and it will be
+    extracted into ``_instance_ranges`` while the field keeps its declared default.
 
     Example:
-        Creating custom hyperparameters for a specific model:
-
-        >>> from pydantic import Field
-        >>> class MyModelHyperParams(HyperParams):
-        ...     learning_rate: float = Field(default=0.01, gt=0, description="Learning rate for training")
-        ...     max_epochs: int = Field(default=100, gt=0, description="Maximum training epochs")
+        >>> from typing import Annotated
+        >>> from openstef_core.mixins.param_ranges import FloatRange, IntRange
+        >>> class MyHP(HyperParams):
+        ...     lr: Annotated[float, FloatRange(low=0.01, high=1.0)] = 0.3
+        ...     depth: Annotated[int, IntRange(low=1, high=15)] = 6
+        >>> hp = MyHP(lr=FloatRange(low=0.001, high=0.5, tune=True))
+        >>> hp.lr  # field keeps its default
+        0.3
+        >>> hp.get_search_space()  # extracted range
+        {'lr': FloatRange(low=0.001, high=0.5, log=False, tune=True)}
     """
 
+    _instance_ranges: dict[str, TuningRange] = PrivateAttr(default_factory=dict[str, TuningRange])
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def _extract_tuning_ranges(
+        cls,
+        data: dict[str, object] | object,
+        handler: ValidatorFunctionWrapHandler,
+    ) -> Self:
+        """Strip TuningRange values from kwargs and store as instance metadata.
+
+        Returns:
+            Validated ``HyperParams`` with tuning ranges stored separately.
+        """
+        instance_ranges: dict[str, TuningRange] = {}
+        if isinstance(data, dict):
+            raw = cast(dict[str, object], data)
+            cleaned: dict[str, Any] = {}
+            for key, value in raw.items():
+                if isinstance(value, (FloatRange, IntRange, CategoricalRange)):
+                    instance_ranges[key] = value
+                else:
+                    cleaned[key] = value
+            data = cleaned
+        result: HyperParams = handler(data)
+        if instance_ranges and result.__pydantic_private__ is not None:
+            result._instance_ranges = instance_ranges
+        return result  # type: ignore[return-value]
+
+    def get_search_space(self, include: set[str] | None = None) -> dict[str, TuningRange]:
+        """Merge instance and class-level ranges, returning only ``tune=True`` fields.
+
+        Args:
+            include: If given, restrict output to these field names.
+
+        Returns:
+            Mapping of field name to resolved ``TuningRange``.
+
+        Raises:
+            KeyError: If *include* contains names not in the tunable space.
+        """
+        result: dict[str, TuningRange] = {}
+        for field_name, field_info in type(self).model_fields.items():
+            tuning_range = get_tuning_range(field_info)
+            override = self._instance_ranges.get(field_name)
+
+            if override is not None:
+                if not override.tune:
+                    continue
+                result[field_name] = override.resolve(tuning_range)  # type: ignore[arg-type]
+            elif tuning_range is not None and tuning_range.tune:
+                result[field_name] = tuning_range
+
+        if include is not None:
+            missing = include - result.keys()
+            if missing:
+                msg = (
+                    f"Fields {sorted(missing)!r} not found in the tunable search space. "
+                    "Check that they exist on the HyperParams class and were passed as "
+                    "TuningRange(tune=True) in the constructor."
+                )
+                raise KeyError(msg)
+            result = {k: result[k] for k in include}
+
+        return result
+
+    def get_tuning_overrides(self) -> dict[str, TuningRange]:
+        """Return the unresolved range overrides that were passed at construction time."""
+        return dict(self._instance_ranges)
+
+    def clear_tuning_ranges(self) -> Self:
+        """Clear any stored tuning range overrides from this hyperparameter config.
+
+        Returns:
+            ``self`` with ``_instance_ranges`` cleared.
+        """
+        self._instance_ranges = {}
+        return self
+
+    def materialize(self, update: dict[str, Any] | None = None) -> Self:
+        """Return a copy with concrete values only and no stored tuning ranges.
+
+        Args:
+            update: Optional field updates to apply before clearing tuning metadata.
+
+        Returns:
+            Copy of ``self`` with ``_instance_ranges`` cleared.
+        """
+        result = self.model_copy(update=update or {})
+        return result.clear_tuning_ranges()
+
 
 __all__ = [
     "BatchPredictor",
diff --git a/packages/openstef-core/src/openstef_core/testing.py b/packages/openstef-core/src/openstef_core/testing.py
index 66e98ab15..3c8c4e8b2 100644
--- a/packages/openstef-core/src/openstef_core/testing.py
+++ b/packages/openstef-core/src/openstef_core/testing.py
@@ -8,13 +8,19 @@
 DataFrames and Series with equality semantics.
 """
 
+from collections.abc import Sequence
 from datetime import datetime, timedelta
-from typing import Any, override
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, override
 
 import numpy as np
 import pandas as pd
 
-from openstef_core.datasets import TimeSeriesDataset
+from openstef_core.constants import LIANDER_DATASET_REPO_ID
+from openstef_core.datasets import TimeSeriesDataset, VersionedTimeSeriesDataset
+
+if TYPE_CHECKING:
+    import logging
 
 
 class IsSamePandas:
@@ -151,3 +157,137 @@ def create_synthetic_forecasting_dataset(  # noqa: PLR0913, PLR0917 - complex fu
         ),
         sample_interval=sample_interval,
     )
+
+
+def load_liander_dataset(
+    *,
+    target: str = "mv_feeder/OS Gorredijk",
+    repo_id: str = LIANDER_DATASET_REPO_ID,
+    local_dir: Path = Path("./liander_dataset"),
+    extra_files: list[str] | None = None,
+) -> TimeSeriesDataset:
+    """Download and combine the Liander benchmark dataset into a single TimeSeriesDataset.
+
+    Downloads load measurements, weather forecasts, electricity prices, and standard load
+    profiles from HuggingFace Hub, then combines them via left join.
+
+    Raises:
+        ImportError: When ``huggingface-hub`` is not installed.
+
+    Args:
+        target: Sub-path within the repo identifying the installation (e.g. ``"mv_feeder/OS Gorredijk"``).
+        repo_id: HuggingFace dataset repository ID.
+        local_dir: Local directory for caching downloaded files.
+        extra_files: Additional parquet files to download and include (paths relative to repo root).
+
+    Returns:
+        Combined dataset with all features aligned by timestamp.
+    """
+    try:
+        from huggingface_hub import hf_hub_download  # pyright: ignore[reportUnknownVariableType]  # noqa: PLC0415
+    except ImportError:
+        msg = "huggingface-hub is required for benchmark datasets: pip install openstef-core[benchmark]"
+        raise ImportError(msg) from None
+
+    files_to_download = [
+        f"load_measurements/{target}.parquet",
+        f"weather_forecasts_versioned/{target}.parquet",
+        "EPEX.parquet",
+        "profiles.parquet",
+        *(extra_files or []),
+    ]
+
+    for filename in files_to_download:
+        hf_hub_download(  # pyright: ignore[reportCallIssue]
+            repo_id=repo_id,
+            filename=filename,
+            repo_type="dataset",
+            local_dir=local_dir,
+            local_dir_use_symlinks=False,
+        )
+
+    datasets = [VersionedTimeSeriesDataset.read_parquet(local_dir / f) for f in files_to_download]
+    return VersionedTimeSeriesDataset.concat(datasets, mode="left").select_version()
+
+
+__all__ = [
+    "LIANDER_DATASET_REPO_ID",
+    "IsSamePandas",
+    "assert_timeseries_equal",
+    "configure_notebook_display",
+    "create_synthetic_forecasting_dataset",
+    "create_timeseries_dataset",
+    "load_liander_dataset",
+    "prepare_tutorial_datasets",
+    "setup_notebook_logging",
+]
+
+
+def configure_notebook_display(renderer: str = "png") -> None:
+    """Configure pandas plotting backend and plotly renderer for notebook output.
+
+    Args:
+        renderer: Plotly renderer to use.  ``"png"`` (default) renders static
+            images suitable for VS Code and CI.  ``"auto"`` lets Plotly pick the
+            best interactive renderer for the current environment.  Any valid
+            plotly renderer string is accepted (e.g. ``"browser"``, ``"jupyterlab"``).
+    """
+    import plotly.io as pio  # noqa: PLC0415
+
+    pd.options.plotting.backend = "plotly"
+    pio.renderers.default = renderer
+
+
+_DEFAULT_NOISY_LOGGERS: tuple[str, ...] = ("choreographer", "kaleido")
+
+
+def setup_notebook_logging(
+    name: str | None = None,
+    suppress: Sequence[str] | None = None,
+) -> "logging.Logger":
+    """Configure logging for tutorial notebooks and return a named logger.
+
+    Sets the root logger to INFO level and silences the loggers in *suppress*
+    by raising their level to ERROR and disabling them entirely.
+
+    Args:
+        name: Logger name, typically ``__name__`` of the calling module.
+        suppress: Sequence of logger names to silence.  Defaults to
+            ``("choreographer", "kaleido")``.
+
+    Returns:
+        Configured Logger instance.
+    """
+    import logging  # noqa: PLC0415
+
+    noisy = suppress if suppress is not None else _DEFAULT_NOISY_LOGGERS
+    logging.basicConfig(level=logging.INFO, format="[%(asctime)s][%(levelname)s] %(message)s")
+    for logger_name in noisy:
+        logging.getLogger(logger_name).setLevel(logging.ERROR)
+        logging.getLogger(logger_name).disabled = True
+    return logging.getLogger(name)
+
+
+def prepare_tutorial_datasets(
+    *,
+    train_start_iso: str = "2024-03-01T00:00:00Z",
+    train_days: int = 90,
+    forecast_days: int = 14,
+) -> tuple[TimeSeriesDataset, TimeSeriesDataset]:
+    """Load the Liander benchmark dataset and split into training and forecast periods.
+
+    Args:
+        train_start_iso: ISO-format start date for the training period.
+        train_days: Number of days in the training window.
+        forecast_days: Number of days in the forecast window (starts immediately after training).
+
+    Returns:
+        Tuple of ``(train_dataset, forecast_dataset)``.
+    """
+    train_start = datetime.fromisoformat(train_start_iso)
+    train_end = train_start + timedelta(days=train_days)
+    dataset = load_liander_dataset()
+    return (
+        dataset.filter_by_range(start=train_start, end=train_end),
+        dataset.filter_by_range(start=train_end, end=train_end + timedelta(days=forecast_days)),
+    )
diff --git a/packages/openstef-core/src/openstef_core/types.py b/packages/openstef-core/src/openstef_core/types.py
index 280749c42..e3a70adf7 100644
--- a/packages/openstef-core/src/openstef_core/types.py
+++ b/packages/openstef-core/src/openstef_core/types.py
@@ -21,7 +21,7 @@
 
 import pandas as pd
 import pytz
-from pydantic import GetCoreSchemaHandler, TypeAdapter
+from pydantic import GetCoreSchemaHandler, TypeAdapter, ValidationInfo
 from pydantic_core import CoreSchema, core_schema
 
 from openstef_core.base_model import PydanticStringPrimitive
@@ -85,7 +85,7 @@ def from_string(cls, s: str) -> Self:
 
     @classmethod
     @override
-    def validate(cls, v: Self | str | timedelta, _info: Any = None) -> Self:
+    def validate(cls, v: Self | str | timedelta, _info: ValidationInfo | None = None) -> Self:
         """Validates and converts various input types to LeadTime.
 
         Accepts LeadTime objects, ISO 8601 duration strings, or timedelta objects.
diff --git a/packages/openstef-core/tests/unit/test_hyperparams_tuning.py b/packages/openstef-core/tests/unit/test_hyperparams_tuning.py
new file mode 100644
index 000000000..7b19d9d98
--- /dev/null
+++ b/packages/openstef-core/tests/unit/test_hyperparams_tuning.py
@@ -0,0 +1,115 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+from typing import Annotated
+
+import pytest
+
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange
+from openstef_core.mixins.predictor import HyperParams
+
+
+class SampleHP(HyperParams):
+    lr: Annotated[float, FloatRange(low=0.01, high=1.0)] = 0.3
+    depth: Annotated[int, IntRange(low=1, high=15)] = 6
+    method: Annotated[str, CategoricalRange(choices=("hist", "approx"))] = "hist"
+    plain: float = 1.0  # not annotated with a range
+
+
+def test_hyperparams_range_extracted_from_kwargs():
+    """TuningRange values are extracted; field keeps its class default."""
+    # Arrange / Act
+    hp = SampleHP(
+        lr=FloatRange(low=0.001, high=0.5, tune=True),
+        depth=IntRange(tune=True),
+    )
+
+    # Assert — field values are the class defaults
+    assert hp.lr == pytest.approx(0.3)
+    assert hp.depth == 6
+
+
+def test_hyperparams_mixed_range_and_plain_value():
+    """Can pass a range for one field and a plain value for another."""
+    # Arrange / Act
+    hp = SampleHP(
+        lr=FloatRange(low=0.001, high=0.5, tune=True),
+        depth=10,  # plain override
+    )
+
+    # Assert
+    assert hp.lr == pytest.approx(0.3)  # range extracted, field keeps default
+    assert hp.depth == 10  # plain value applied
+
+
+def test_get_search_space_returns_only_tune_true():
+    """Only fields with tune=True appear in the search space."""
+    # Arrange
+    hp = SampleHP(
+        lr=FloatRange(low=0.001, high=0.5, tune=True),
+        depth=IntRange(tune=False),  # explicit tune=False
+    )
+
+    # Act
+    space = hp.get_search_space()
+
+    # Assert
+    assert "lr" in space
+    assert "depth" not in space
+
+
+def test_get_search_space_resolves_none_bounds():
+    """None bounds on instance range are resolved from class-level Annotated metadata."""
+    # Arrange
+    hp = SampleHP(depth=IntRange(low=None, high=None, tune=True))
+
+    # Act
+    space = hp.get_search_space()
+
+    # Assert — resolved from class-level IntRange(1, 15)
+    assert space["depth"].low == 1
+    assert space["depth"].high == 15
+
+
+def test_get_search_space_with_class_level_tune():
+    """Class-level Annotated range with tune=True is included without instance override."""
+
+    # Arrange
+    class AutoTuneHP(HyperParams):
+        lr: Annotated[float, FloatRange(low=0.01, high=1.0, tune=True)] = 0.3
+
+    hp = AutoTuneHP()
+
+    # Act
+    space = hp.get_search_space()
+
+    # Assert
+    assert "lr" in space
+    assert space["lr"].low == pytest.approx(0.01)
+
+
+def test_get_search_space_include_filter():
+    """include parameter restricts output to requested fields."""
+    # Arrange
+    hp = SampleHP(
+        lr=FloatRange(tune=True),
+        depth=IntRange(tune=True),
+        method=CategoricalRange(choices=("hist",), tune=True),
+    )
+
+    # Act
+    space = hp.get_search_space(include={"lr", "depth"})
+
+    # Assert
+    assert set(space.keys()) == {"lr", "depth"}
+
+
+def test_get_search_space_include_raises_on_missing():
+    """include with a non-existent field raises KeyError."""
+    # Arrange
+    hp = SampleHP(lr=FloatRange(tune=True))
+
+    # Act / Assert
+    with pytest.raises(KeyError, match="nonexistent"):
+        hp.get_search_space(include={"lr", "nonexistent"})
diff --git a/packages/openstef-core/tests/unit/test_param_ranges.py b/packages/openstef-core/tests/unit/test_param_ranges.py
new file mode 100644
index 000000000..e99792ee5
--- /dev/null
+++ b/packages/openstef-core/tests/unit/test_param_ranges.py
@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+import pytest
+
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange
+
+
+def test_float_range_frozen():
+    # Arrange
+    fr = FloatRange(low=0.01, high=1.0)
+
+    # Act / Assert
+    with pytest.raises(AttributeError):
+        fr.low = 5.0  # type: ignore[misc]
+
+
+def test_float_range_validates_low_gt_high():
+    # Act / Assert
+    with pytest.raises(ValueError, match=r"low.*must be <= high"):
+        FloatRange(low=10.0, high=1.0)
+
+
+def test_float_range_resolve_fills_none_bounds():
+    # Arrange
+    override = FloatRange(low=None, high=None, log=True, tune=True)
+    class_default = FloatRange(low=0.01, high=1.0)
+
+    # Act
+    resolved = override.resolve(class_default)
+
+    # Assert
+    assert resolved.low == pytest.approx(0.01)
+    assert resolved.high == pytest.approx(1.0)
+    assert resolved.log is True  # kept from override
+    assert resolved.tune is True
+
+
+def test_float_range_resolve_keeps_explicit_bounds():
+    # Arrange
+    override = FloatRange(low=0.001, high=0.5, tune=True)
+    class_default = FloatRange(low=0.01, high=1.0)
+
+    # Act
+    resolved = override.resolve(class_default)
+
+    # Assert — explicit bounds not overwritten
+    assert resolved.low == pytest.approx(0.001)
+    assert resolved.high == pytest.approx(0.5)
+
+
+def test_float_range_resolve_with_none_class_default():
+    # Arrange
+    override = FloatRange(low=0.01, high=1.0, tune=True)
+
+    # Act
+    resolved = override.resolve(None)
+
+    # Assert — unchanged
+    assert resolved.low == pytest.approx(0.01)
+    assert resolved.high == pytest.approx(1.0)
+
+
+def test_int_range_validates_low_gt_high():
+    # Act / Assert
+    with pytest.raises(ValueError, match=r"low.*must be <= high"):
+        IntRange(low=20, high=5)
+
+
+def test_int_range_resolve_fills_none_bounds():
+    # Arrange
+    override = IntRange(low=None, high=None, tune=True)
+    class_default = IntRange(low=1, high=15)
+
+    # Act
+    resolved = override.resolve(class_default)
+
+    # Assert
+    assert resolved.low == 1
+    assert resolved.high == 15
+
+
+def test_categorical_range_validates_empty_choices():
+    # Act / Assert
+    with pytest.raises(ValueError, match="choices must not be empty"):
+        CategoricalRange(choices=())
+
+
+def test_categorical_range_resolve_fills_none_choices():
+    # Arrange
+    override = CategoricalRange(choices=None, tune=True)
+    class_default = CategoricalRange(choices=("hist", "approx"))
+
+    # Act
+    resolved = override.resolve(class_default)
+
+    # Assert
+    assert resolved.choices == ("hist", "approx")
+    assert resolved.tune is True
+
+
+def test_categorical_range_resolve_keeps_explicit_choices():
+    # Arrange
+    override = CategoricalRange(choices=("x", "y"), tune=True)
+    class_default = CategoricalRange(choices=("a", "b", "c"))
+
+    # Act
+    resolved = override.resolve(class_default)
+
+    # Assert
+    assert resolved.choices == ("x", "y")
diff --git a/packages/openstef-meta/tests/unit/models/test_ensemble_forecasting_model.py b/packages/openstef-meta/tests/unit/models/test_ensemble_forecasting_model.py
index 7acdfcee6..7c9dac1a0 100644
--- a/packages/openstef-meta/tests/unit/models/test_ensemble_forecasting_model.py
+++ b/packages/openstef-meta/tests/unit/models/test_ensemble_forecasting_model.py
@@ -4,12 +4,10 @@
 
 import pickle  # noqa: S403 - Controlled test
 from datetime import datetime, timedelta
-from typing import override
+from typing import TYPE_CHECKING, override
 
-import numpy as np
 import pandas as pd
 import pytest
-from pydantic import PrivateAttr
 
 from openstef_core.datasets import ForecastInputDataset
 from openstef_core.datasets.timeseries_dataset import TimeSeriesDataset
@@ -21,42 +19,11 @@
 from openstef_core.types import LeadTime, Q
 from openstef_meta.models.ensemble_forecasting_model import EnsembleForecastingModel
 from openstef_meta.models.forecast_combiners.forecast_combiner import ForecastCombiner
-from openstef_models.models.forecasting.forecaster import Forecaster
+from openstef_models.testing import SimpleForecaster, create_sample_timeseries_dataset, create_standard_preprocessing
 from openstef_models.transforms.postprocessing.quantile_sorter import QuantileSorter
-from openstef_models.transforms.time_domain.lags_adder import LagsAdder
 
-
-class SimpleForecaster(Forecaster):
-    """Simple test forecaster that returns predictable values for testing."""
-
-    _is_fitted: bool = PrivateAttr(default=False)
-
-    @property
-    @override
-    def hparams(self) -> HyperParams:
-        return HyperParams()
-
-    @property
-    @override
-    def is_fitted(self) -> bool:
-        return self._is_fitted
-
-    @override
-    def fit(self, data: ForecastInputDataset, data_val: ForecastInputDataset | None = None) -> None:
-        self._is_fitted = True
-
-    @override
-    def predict(self, data: ForecastInputDataset) -> ForecastDataset:
-        # Return predictable forecast values
-        forecast_values = {quantile: 100.0 + quantile * 10 for quantile in self.quantiles}
-        return ForecastDataset(
-            pd.DataFrame(
-                {quantile.format(): [forecast_values[quantile]] * len(data.index) for quantile in self.quantiles},
-                index=data.index,
-            ),
-            data.sample_interval,
-            data.forecast_start,
-        )
+if TYPE_CHECKING:
+    from openstef_models.models.forecasting.forecaster import Forecaster
 
 
 class SimpleCombiner(ForecastCombiner):
@@ -116,19 +83,7 @@ def predict_contributions(
 @pytest.fixture
 def sample_timeseries_dataset() -> TimeSeriesDataset:
     """Create sample time series data with typical energy forecasting features."""
-    n_samples = 25
-    rng = np.random.default_rng(seed=42)
-
-    data = pd.DataFrame(
-        {
-            "load": 100.0 + rng.normal(10.0, 5.0, n_samples),
-            "temperature": 20.0 + rng.normal(1.0, 0.5, n_samples),
-            "radiation": rng.uniform(0.0, 500.0, n_samples),
-        },
-        index=pd.date_range("2025-01-01 10:00", periods=n_samples, freq="h"),
-    )
-
-    return TimeSeriesDataset(data, timedelta(hours=1))
+    return create_sample_timeseries_dataset()
 
 
 @pytest.fixture
@@ -226,17 +181,7 @@ def test_forecasting_model__pickle_roundtrip():
     original_model = EnsembleForecastingModel(
         forecasters=forecasters,
         combiner=combiner,
-        preprocessing=TransformPipeline(
-            transforms=[
-                LagsAdder(
-                    history_available=timedelta(days=14),
-                    horizons=horizons,
-                    max_day_lags=7,
-                    add_trivial_lags=True,
-                    add_autocorr_lags=False,
-                ),
-            ]
-        ),
+        preprocessing=create_standard_preprocessing(horizons),
         postprocessing=TransformPipeline(transforms=[QuantileSorter()]),
         cutoff_history=timedelta(days=7),
         target_column="load",
diff --git a/packages/openstef-models/pyproject.toml b/packages/openstef-models/pyproject.toml
index 8c29e8a28..9d3087930 100644
--- a/packages/openstef-models/pyproject.toml
+++ b/packages/openstef-models/pyproject.toml
@@ -42,13 +42,14 @@ optional-dependencies.lgbm = [
   "lightgbm>=4.6",
 ]
 
+optional-dependencies.tuning = [ "optuna>=4.7" ]
+
 optional-dependencies.xgb-cpu = [
   "xgboost>=3,<4; sys_platform=='darwin'",
   "xgboost-cpu>=3,<4; sys_platform=='linux' or sys_platform=='win32'",
 ]
 
 optional-dependencies.xgb-gpu = [ "xgboost>=3,<4" ]
-
 urls.Documentation = "https://openstef.github.io/openstef/index.html"
 urls.Homepage = "https://lfenergy.org/projects/openstef/"
 urls.Issues = "https://github.com/OpenSTEF/openstef/issues"
diff --git a/packages/openstef-models/src/openstef_models/integrations/optuna/__init__.py b/packages/openstef-models/src/openstef_models/integrations/optuna/__init__.py
new file mode 100644
index 000000000..c83821ee5
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/integrations/optuna/__init__.py
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Optuna-powered hyperparameter tuning integration.
+
+Requires ``optuna`` (install via ``pip install openstef-models[tuning]``).
+
+Public API
+----------
+- `HyperparameterTuner` — orchestrates Bayesian tuning over HyperParams search spaces.
+- `TuningResult` — result container with best config and Optuna study.
+"""
+
+from openstef_models.integrations.optuna.tuner import (
+    HyperparameterTuner,
+    TuningResult,
+)
+
+__all__ = [
+    "HyperparameterTuner",
+    "TuningResult",
+]
diff --git a/packages/openstef-models/src/openstef_models/integrations/optuna/tuner.py b/packages/openstef-models/src/openstef_models/integrations/optuna/tuner.py
new file mode 100644
index 000000000..633ab8121
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/integrations/optuna/tuner.py
@@ -0,0 +1,354 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Hyperparameter tuner and supporting types."""
+
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Literal, NamedTuple, cast
+
+from pydantic import ConfigDict, Field, SkipValidation
+
+try:
+    import optuna
+except ImportError as _err:
+    from openstef_core.exceptions import MissingExtraError
+
+    raise MissingExtraError("optuna", "openstef-models[tuning]") from _err
+
+from openstef_core.base_model import BaseConfig
+from openstef_core.datasets import TimeSeriesDataset
+from openstef_core.mixins.param_ranges import (
+    CategoricalRange,
+    FloatRange,
+    IntRange,
+    ModelTuningInfo,
+    TuningRange,
+)
+from openstef_core.mixins.predictor import HyperParams
+from openstef_core.types import QuantileOrGlobal
+from openstef_models.workflows.custom_forecasting_workflow import CustomForecastingWorkflow
+
+
+class _SearchSpaceEntry(NamedTuple):
+    """Maps an Optuna trial key back to its source HyperParams field and parameter."""
+
+    config_field: str
+    param_name: str
+    range: TuningRange
+
+
+def _collect_available_metric_names(config: BaseConfig) -> set[str] | None:
+    """Extract declared metric names from *config* if it has ``evaluation_metrics``.
+
+    Returns:
+        Metric name set, or ``None`` when the config doesn't expose metric providers.
+    """
+    providers = getattr(config, "evaluation_metrics", None)
+    if providers is None:
+        return None
+
+    names: set[str] = set()
+    for provider in providers:
+        if hasattr(provider, "metric_names"):
+            names.update(provider.metric_names)
+    return names or None
+
+
+@dataclass(repr=False)
+class TuningResult[ConfigT: BaseConfig]:
+    """Result container for ``HyperparameterTuner.fit_with_tuning``."""
+
+    best_config: ConfigT
+    study: optuna.Study
+    workflow: CustomForecastingWorkflow
+
+    def __repr__(self) -> str:  # noqa: D105  # self-explanatory
+        n = len(self.study.best_params)
+        return f"TuningResult({n} params tuned)" if n else "TuningResult(no tuning)"
+
+
+class HyperparameterTuner[ConfigT: BaseConfig](BaseConfig):
+    """Bayesian hyperparameter tuner powered by Optuna.
+
+    Orchestrates an Optuna study over the tunable search spaces declared on
+    ``HyperParams`` fields of the provided *config*.  Override methods
+    prefixed with ``_`` to customise study creation, objective evaluation,
+    or parameter suggestion.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    config: SkipValidation[ConfigT] = Field(description="Configuration with tunable HyperParams fields.")
+    train_dataset: SkipValidation[TimeSeriesDataset] = Field(description="Training data for each trial.")
+    create_workflow: SkipValidation[Callable[[ConfigT], CustomForecastingWorkflow]] = Field(
+        description="Factory that builds a workflow from a config."
+    )
+    target_quantile: QuantileOrGlobal = Field(description="Quantile (or 'global') for metric evaluation.")
+    metric_name: str = Field(description="Name of the metric to optimise.")
+    direction: Literal["maximize", "minimize"] = Field(
+        default="maximize", description="Optimisation direction for the metric."
+    )
+    n_trials: int = Field(default=20, description="Number of Optuna trials.")
+    n_jobs: int = Field(
+        default=1,
+        description="Number of parallel trial workers. Set >1 when the underlying model is single-threaded.",
+    )
+    seed: int | None = Field(default=42, description="Random seed for reproducibility.")
+    study_name: str = Field(default="hyperparameter_tuning", description="Optuna study name.")
+
+    def _discover_search_spaces(self) -> list[ModelTuningInfo]:
+        """Scan *config* for ``HyperParams`` fields with non-empty search spaces.
+
+        Returns:
+            One ``ModelTuningInfo`` per tunable ``HyperParams`` field.
+        """
+        return [
+            ModelTuningInfo(field_name=field_name, hyperparams=value, search_space=space)
+            for field_name in type(self.config).model_fields
+            if isinstance(value := getattr(self.config, field_name), HyperParams)
+            and (space := value.get_search_space())
+        ]
+
+    @staticmethod
+    def _build_combined_space(model_tuning_info: list[ModelTuningInfo]) -> dict[str, _SearchSpaceEntry]:
+        """Merge per-field search spaces into a single dict keyed by Optuna trial key.
+
+        When multiple HyperParams groups are tuned, trial keys are prefixed with the
+        field name (e.g. ``"xgboost_hyperparams.learning_rate"``) to avoid collisions.
+
+        Returns:
+            Combined search space mapping trial keys to ``_SearchSpaceEntry``.
+        """
+        multi = len(model_tuning_info) > 1
+        return {
+            (f"{info.field_name}.{param_name}" if multi else param_name): _SearchSpaceEntry(
+                info.field_name, param_name, tuning_range
+            )
+            for info in model_tuning_info
+            for param_name, tuning_range in info.search_space.items()
+        }
+
+    @property
+    def _trial_base(self) -> ConfigT:
+        """Config with tracking disabled so each trial trains from scratch.
+
+        Strips ``mlflow_storage`` when present — without this, the MLflow callback
+        can reuse a previously stored model and short-circuit training, making trials
+        non-comparable and invalidating the optimisation.
+
+        Override to disable additional callbacks or change trial-specific settings.
+
+        Returns:
+            Config copy suitable for use inside ``_evaluate_trial``.
+        """
+        if hasattr(self.config, "mlflow_storage"):
+            return self.config.model_copy(update={"mlflow_storage": None})  # type: ignore[return-value]
+        return self.config
+
+    def _create_study(self) -> optuna.Study:
+        """Create and configure the Optuna study.
+
+        Override to use a different sampler, pruner, or storage backend.
+
+        Returns:
+            Configured ``optuna.Study`` ready for optimisation.
+        """
+        return optuna.create_study(
+            direction=self.direction,
+            sampler=optuna.samplers.TPESampler(seed=self.seed),
+            pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+            study_name=self.study_name,
+        )
+
+    @staticmethod
+    def _build_default_trial_params(
+        config: BaseConfig,
+        combined_space: dict[str, _SearchSpaceEntry],
+    ) -> dict[str, bool | int | float | str | None]:
+        """Build a trial parameter dict from the config's current concrete defaults.
+
+        Returns:
+            Mapping of trial keys to the concrete parameter values currently set on *config*.
+        """
+        return {
+            trial_key: getattr(cast(HyperParams, getattr(config, entry.config_field)), entry.param_name)
+            for trial_key, entry in combined_space.items()
+        }
+
+    @staticmethod
+    def suggest_value(
+        trial: optuna.Trial,
+        trial_key: str,
+        tuning_range: TuningRange,
+    ) -> bool | int | float | str | None:
+        """Suggest a single parameter value via the Optuna trial API.
+
+        Override to add custom suggestion logic or constraints.
+
+        Returns:
+            Suggested value, or ``None`` when the range is incomplete.
+        """
+        if isinstance(tuning_range, FloatRange) and tuning_range.low is not None and tuning_range.high is not None:
+            return trial.suggest_float(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+        if isinstance(tuning_range, IntRange) and tuning_range.low is not None and tuning_range.high is not None:
+            return trial.suggest_int(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+        if isinstance(tuning_range, CategoricalRange) and tuning_range.choices is not None:
+            return trial.suggest_categorical(trial_key, list(tuning_range.choices))
+        return None
+
+    def _evaluate_trial(
+        self,
+        trial: optuna.Trial,
+        combined_space: dict[str, _SearchSpaceEntry],
+        model_tuning_info: list[ModelTuningInfo],
+    ) -> float:
+        """Score a single Optuna trial.
+
+        Suggests HP values, builds a config copy, fits a workflow, and extracts the
+        configured metric.  Override to change how trials are evaluated (e.g.
+        cross-validation).
+
+        Returns:
+            Metric score for the trial (lower / higher is better depending on *direction*).
+
+        Raises:
+            ValueError: If ``metric_name`` is not found in the evaluation metrics.
+        """
+        # Group suggested values by their owning HyperParams field
+        per_field: dict[str, dict[str, Any]] = defaultdict(dict)
+        for trial_key, entry in combined_space.items():
+            value = self.suggest_value(trial, trial_key, entry.range)
+            if value is not None:
+                per_field[entry.config_field][entry.param_name] = value
+
+        # Replace each HyperParams instance with a copy containing the trial's suggestions
+        tuned_config = self._trial_base.model_copy(
+            update={
+                # Materialize copied HyperParams so workflows only ever see concrete values during fit.
+                info.field_name: cast(HyperParams, info.hyperparams).materialize(update=per_field[info.field_name])
+                for info in model_tuning_info
+                if info.field_name in per_field
+            }
+        )
+
+        # Create a workflow and train from the trial config
+        workflow = self.create_workflow(tuned_config)
+        fit_result = workflow.fit(self.train_dataset)
+        if fit_result is None:
+            return float("-inf") if self.direction == "maximize" else float("inf")
+
+        # Prefer validation metrics; fall back to training metrics
+        metrics = fit_result.metrics_val if fit_result.metrics_val is not None else fit_result.metrics_train
+        score = metrics.get_metric(quantile=self.target_quantile, metric_name=self.metric_name)
+        if score is None:
+            available = sorted(metrics.to_flat_dict())
+            msg = (
+                f"Metric {self.metric_name!r} (quantile={self.target_quantile!r}) not found. "
+                f"Available metrics: {available}"
+            )
+            raise ValueError(msg)
+        return float(score)
+
+    @staticmethod
+    def _reconstruct_best_config(
+        config: BaseConfig,
+        model_tuning_info: list[ModelTuningInfo],
+        study: optuna.Study,
+    ) -> BaseConfig:
+        """Apply the best trial params back to the original config.
+
+        Returns:
+            Config copy with the best trial's parameters applied.
+        """
+        multi = len(model_tuning_info) > 1
+        per_field: dict[str, dict[str, Any]] = defaultdict(dict)
+        for trial_key, value in study.best_params.items():
+            if multi and "." in trial_key:
+                field_name, param_name = trial_key.split(".", 1)
+            else:
+                # Single-model shortcut — params aren't prefixed
+                field_name = model_tuning_info[0].field_name
+                param_name = trial_key
+            per_field[field_name][param_name] = value
+
+        return config.model_copy(
+            update={
+                info.field_name: cast(HyperParams, info.hyperparams).materialize(update=per_field[info.field_name])
+                for info in model_tuning_info
+                if info.field_name in per_field
+            }
+        )
+
+    def _validate_metric_name(self) -> None:
+        """Eagerly check that ``metric_name`` is valid for the configured evaluation metrics.
+
+        Only performs the check when the *config* exposes ``evaluation_metrics``
+        with providers that declare ``metric_names``.  Silently skips otherwise
+        (validation will still occur at trial time).
+
+        Raises:
+            ValueError: If *metric_name* is not among the declared provider metric names.
+        """
+        known = _collect_available_metric_names(self.config)
+        if known is not None and self.metric_name not in known:
+            msg = (
+                f"Metric {self.metric_name!r} is not provided by the configured evaluation_metrics. "
+                f"Available: {sorted(known)}"
+            )
+            raise ValueError(msg)
+
+    def tune(self, *, show_progress_bar: bool = True) -> tuple[ConfigT, optuna.Study]:
+        """Run the Optuna study and return the best config.
+
+        Returns:
+            ``(best_config, study)`` tuple.
+
+        Raises:
+            ValueError: If no tunable fields are found or *metric_name* is invalid.
+        """
+        self._validate_metric_name()
+
+        model_tuning_info = self._discover_search_spaces()
+        if not model_tuning_info:
+            msg = "No tunable hyperparameters found. Pass TuningRange(tune=True) in the HyperParams constructor."
+            raise ValueError(msg)
+
+        combined_space = self._build_combined_space(model_tuning_info)
+        study = self._create_study()
+        # Evaluate the current OpenSTEF defaults first, then let Optuna explore alternatives.
+        study.enqueue_trial(self._build_default_trial_params(self.config, combined_space))
+
+        def objective(trial: optuna.Trial) -> float:
+            return self._evaluate_trial(trial, combined_space, model_tuning_info)
+
+        study.optimize(objective, n_trials=self.n_trials, n_jobs=self.n_jobs, show_progress_bar=show_progress_bar)
+        best_config = self._reconstruct_best_config(
+            config=self.config, model_tuning_info=model_tuning_info, study=study
+        )
+        return best_config, study  # type: ignore[return-value]  # ConfigT narrowing not expressible
+
+    def fit_with_tuning(self, *, show_progress_bar: bool = True) -> TuningResult[ConfigT]:
+        """Tune, then fit a final workflow with the best config.
+
+        Returns:
+            ``TuningResult`` with the best config and Optuna study.
+
+        Raises:
+            RuntimeError: If the final workflow fit fails after tuning.
+        """
+        best_config, study = self.tune(show_progress_bar=show_progress_bar)
+        workflow = self.create_workflow(best_config)
+        fit_result = workflow.fit(self.train_dataset)
+        if fit_result is None:
+            msg = "Final workflow fit failed after hyperparameter tuning."
+            raise RuntimeError(msg)
+        return TuningResult(best_config=best_config, study=study, workflow=workflow)
+
+
+__all__ = [
+    "HyperparameterTuner",
+    "TuningResult",
+]
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
index bda6435d7..75d52e536 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
@@ -11,7 +11,7 @@
 to predict values outside the range of the training data.
 """
 
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
 
 import numpy as np
 import pandas as pd
@@ -22,6 +22,7 @@
 from openstef_core.datasets.mixins import LeadTime
 from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
 from openstef_core.exceptions import InputValidationError, MissingExtraError, NotFittedError
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange
 from openstef_core.mixins.predictor import HyperParams
 from openstef_core.utils.pandas import normalize_to_unit_sum
 from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
@@ -32,6 +33,7 @@
     get_objective_function,
     xgb_prepare_target_for_objective,
 )
+from openstef_models.utils.xgboost import get_median_shap_contribs
 
 try:
     import xgboost as xgb
@@ -43,15 +45,15 @@ class GBLinearHyperParams(HyperParams):
     """Hyperparameter configuration for GBLinear forecaster."""
 
     # Learning Parameters
-    n_steps: int = Field(
+    n_steps: Annotated[int, IntRange(50, 1000)] = Field(
         default=500,
         description="Number for steps (boosting rounds) to train the GBLinear model.",
     )
-    updater: str = Field(
+    updater: Annotated[str, CategoricalRange(("shotgun", "coord_descent"))] = Field(
         default="shotgun",
         description="The updater to use for the GBLinear booster.",
     )
-    learning_rate: float = Field(
+    learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
         default=0.15,
         description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require more boosting "
         "rounds.",
@@ -68,15 +70,15 @@ class GBLinearHyperParams(HyperParams):
     )
 
     # Regularization
-    reg_alpha: float = Field(
+    reg_alpha: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
         default=0.0001, description="L1 regularization on weights. Higher values increase regularization. Range: [0,∞]"
     )
-    reg_lambda: float = Field(
+    reg_lambda: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
         default=0.1, description="L2 regularization on weights. Higher values increase regularization. Range: [0,∞]"
     )
 
     # Feature selection
-    feature_selector: str = Field(
+    feature_selector: Annotated[str, CategoricalRange(("cyclic", "shuffle", "random", "greedy", "thrifty"))] = Field(
         default="shuffle",
         description="Feature selection method.",
     )
@@ -280,16 +282,11 @@ def predict(self, data: ForecastInputDataset) -> ForecastDataset:
         if len(predictions_array) > 0:
             predictions_array = self._target_scaler.inverse_transform(predictions_array)
 
-        # Construct DataFrame with appropriate quantile columns
-        predictions = pd.DataFrame(
-            data=predictions_array,
-            index=input_data.index,
-            columns=[quantile.format() for quantile in self.quantiles],
-        )
-
-        return ForecastDataset(
-            data=predictions,
-            sample_interval=data.sample_interval,
+        return ForecastDataset.from_quantile_predictions(
+            predictions_array,
+            input_data.index,
+            self.quantiles,
+            data.sample_interval,
             target_column=data.target_column,
         )
 
@@ -309,18 +306,7 @@ def predict_contributions(self, data: ForecastInputDataset) -> TimeSeriesDataset
             raise NotFittedError(self.__class__.__name__)
 
         input_data: pd.DataFrame = data.input_data(start=data.forecast_start)
-        booster = self._gblinear_model.get_booster()
-        dmatrix = xgb.DMatrix(input_data)
-        contribs_raw: np.ndarray = booster.predict(dmatrix, pred_contribs=True)
-
-        # Reshape to (n_samples, n_quantiles, n_features + 1)
-        n_samples = len(input_data)
-        n_quantiles = len(self.quantiles)
-        contribs_3d = contribs_raw.reshape(n_samples, n_quantiles, -1)
-
-        # Extract median quantile contributions
-        median_idx = min(range(n_quantiles), key=lambda i: abs(float(self.quantiles[i]) - 0.5))
-        contribs = contribs_3d[:, median_idx, :].copy()
+        contribs = get_median_shap_contribs(self._gblinear_model.get_booster(), input_data, self.quantiles)
 
         # Inverse transform for target scaling
         if self._target_scaler.scale_ is None or self._target_scaler.mean_ is None:
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
index 0153fd60d..2e311eb2c 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
@@ -9,7 +9,7 @@
 comprehensive hyperparameter control for production forecasting workflows.
 """
 
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
 
 import numpy as np
 import pandas as pd
@@ -18,7 +18,8 @@
 
 from openstef_core.datasets import ForecastDataset, ForecastInputDataset, TimeSeriesDataset
 from openstef_core.exceptions import MissingExtraError, NotFittedError
-from openstef_core.mixins import HyperParams
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange
+from openstef_core.mixins.predictor import HyperParams
 from openstef_core.utils.pandas import normalize_to_unit_sum
 from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
 from openstef_models.models.forecasting.forecaster import Forecaster
@@ -28,6 +29,7 @@
     get_objective_function,
     xgb_prepare_target_for_objective,
 )
+from openstef_models.utils.xgboost import get_median_shap_contribs
 
 try:
     import xgboost as xgb
@@ -65,28 +67,28 @@ class XGBoostHyperParams(HyperParams):
     """
 
     # Core Tree Boosting Parameters
-    n_estimators: int = Field(
+    n_estimators: Annotated[int, IntRange(50, 500)] = Field(
         default=100,
         description="Number of boosting rounds/trees to fit. Higher values may improve performance but "
         "increase training time and risk overfitting.",
     )
-    learning_rate: float = Field(
+    learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
         default=0.3,
         alias="eta",
         description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require "
         "more boosting rounds.",
     )
-    max_depth: int = Field(
+    max_depth: Annotated[int, IntRange(1, 15)] = Field(
         default=6,
         description="Maximum depth of trees. Higher values capture more complex patterns but risk "
         "overfitting. Range: [1,∞]",
     )
-    min_child_weight: float = Field(
+    min_child_weight: Annotated[float, FloatRange(1.0, 10.0)] = Field(
         default=1,
         description="Minimum sum of instance weight (hessian) needed in a child. Higher values prevent "
         "overfitting. Range: [0,∞]",
     )
-    gamma: float = Field(
+    gamma: Annotated[float, FloatRange(0.0, 5.0)] = Field(
         default=0,
         alias="min_split_loss",
         description="Minimum loss reduction required to make a split. Higher values make algorithm more "
@@ -103,10 +105,10 @@ class XGBoostHyperParams(HyperParams):
     )
 
     # Regularization
-    reg_alpha: float = Field(
+    reg_alpha: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
         default=0, description="L1 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
     )
-    reg_lambda: float = Field(
+    reg_lambda: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
         default=1, description="L2 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
     )
     max_delta_step: float = Field(
@@ -119,7 +121,7 @@ class XGBoostHyperParams(HyperParams):
     max_leaves: int = Field(
         default=0, description="Maximum number of leaves. 0 means no limit. Only relevant when grow_policy='lossguide'."
     )
-    grow_policy: Literal["depthwise", "lossguide"] = Field(
+    grow_policy: Annotated[Literal["depthwise", "lossguide"], CategoricalRange(("depthwise", "lossguide"))] = Field(
         default="depthwise",
         description="Controls how new nodes are added. 'depthwise' grows level by level, 'lossguide' adds leaves "
         "with highest loss reduction.",
@@ -136,11 +138,11 @@ class XGBoostHyperParams(HyperParams):
     )
 
     # Subsampling Parameters
-    subsample: float = Field(
+    subsample: Annotated[float, FloatRange(0.5, 1.0)] = Field(
         default=1.0,
         description="Fraction of training samples used for each tree. Lower values prevent overfitting. Range: (0,1]",
     )
-    colsample_bytree: float = Field(
+    colsample_bytree: Annotated[float, FloatRange(0.5, 1.0)] = Field(
         default=1.0, description="Fraction of features used when constructing each tree. Range: (0,1]"
     )
     colsample_bylevel: float = Field(
@@ -151,7 +153,10 @@ class XGBoostHyperParams(HyperParams):
     )
 
     # Tree Construction Method
-    tree_method: Literal["auto", "exact", "hist", "approx", "gpu_hist"] = Field(
+    tree_method: Annotated[
+        Literal["auto", "exact", "hist", "approx", "gpu_hist"],
+        CategoricalRange(("auto", "hist", "approx")),
+    ] = Field(
         default="auto",
         description="Tree construction algorithm. 'hist' is fastest for large datasets, 'exact' for small "
         "datasets, 'approx' is deprecated.",
@@ -351,16 +356,11 @@ def predict(self, data: ForecastInputDataset) -> ForecastDataset:
         if self._target_scaler is not None and len(predictions_array) > 0:
             predictions_array = self._target_scaler.inverse_transform(predictions_array)
 
-        # Construct DataFrame with appropriate quantile columns
-        predictions = pd.DataFrame(
-            data=predictions_array,
-            index=input_data.index,
-            columns=[quantile.format() for quantile in self.quantiles],
-        )
-
-        return ForecastDataset(
-            data=predictions,
-            sample_interval=data.sample_interval,
+        return ForecastDataset.from_quantile_predictions(
+            predictions_array,
+            input_data.index,
+            self.quantiles,
+            data.sample_interval,
             target_column=data.target_column,
         )
 
@@ -380,18 +380,7 @@ def predict_contributions(self, data: ForecastInputDataset) -> TimeSeriesDataset
             raise NotFittedError(self.__class__.__name__)
 
         input_data: pd.DataFrame = data.input_data(start=data.forecast_start)
-        booster = self._xgboost_model.get_booster()
-        dmatrix = xgb.DMatrix(input_data)
-        contribs_raw: np.ndarray = booster.predict(dmatrix, pred_contribs=True)
-
-        # Reshape to (n_samples, n_quantiles, n_features + 1)
-        n_samples = len(input_data)
-        n_quantiles = len(self.quantiles)
-        contribs_3d = contribs_raw.reshape(n_samples, n_quantiles, -1)
-
-        # Extract median quantile contributions
-        median_idx = min(range(n_quantiles), key=lambda i: abs(float(self.quantiles[i]) - 0.5))
-        contribs = contribs_3d[:, median_idx, :].copy()
+        contribs = get_median_shap_contribs(self._xgboost_model.get_booster(), input_data, self.quantiles)
 
         # Inverse transform for target scaling
         if (
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting_model.py b/packages/openstef-models/src/openstef_models/models/forecasting_model.py
index b3aba128b..a2596d641 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting_model.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting_model.py
@@ -14,11 +14,11 @@
 from abc import abstractmethod
 from datetime import datetime, timedelta
 from functools import partial
-from typing import cast, override
+from typing import Self, cast, override
 
 import numpy as np
 import pandas as pd
-from pydantic import Field, PrivateAttr
+from pydantic import Field, PrivateAttr, model_validator
 
 from openstef_beam.evaluation import EvaluationConfig, EvaluationPipeline, SubsetMetric
 from openstef_beam.evaluation.metric_providers import MetricProvider, ObservedProbabilityProvider, R2Provider
@@ -181,6 +181,31 @@ def component_hyperparams(self) -> dict[str, HyperParams]:
         """
         return {}
 
+    @model_validator(mode="after")
+    def _validate_tuning_ready(self) -> Self:
+        """Reject models that are constructed with unresolved tuning ranges.
+
+        Returns:
+            Validated model instance.
+
+        Raises:
+            ValueError: If any hyperparameter config still carries unresolved tuning ranges.
+        """
+        unresolved = [f"hyperparams.{name}" for name in self.hyperparams.get_tuning_overrides()]
+        unresolved.extend(
+            f"components.{component_name}.{param_name}"
+            for component_name, hyperparams in self.component_hyperparams.items()
+            for param_name in hyperparams.get_tuning_overrides()
+        )
+        if unresolved:
+            msg = (
+                "Model contains unresolved tuning ranges: "
+                f"{sorted(unresolved)}. "
+                "Use HyperparameterTuner.tune()/fit_with_tuning() first or replace the ranges with concrete values."
+            )
+            raise ValueError(msg)
+        return self
+
     def get_explainable_components(self) -> dict[str, ExplainableForecaster]:  # noqa: PLR6301
         """Return named components that support feature-importance plotting.
 
diff --git a/packages/openstef-models/src/openstef_models/presets/__init__.py b/packages/openstef-models/src/openstef_models/presets/__init__.py
index 0615a0ea4..e79b985a3 100644
--- a/packages/openstef-models/src/openstef_models/presets/__init__.py
+++ b/packages/openstef-models/src/openstef_models/presets/__init__.py
@@ -5,9 +5,13 @@
 """Forecasting workflow presets package.
 
 Provides configurations and utilities for setting up forecasting workflows.
+Tuning symbols live in ``openstef_models.integrations.optuna``.
 """
 
-from .forecasting_workflow import ForecastingWorkflowConfig, create_forecasting_workflow
+from .forecasting_workflow import (
+    ForecastingWorkflowConfig,
+    create_forecasting_workflow,
+)
 
 __all__ = [
     "ForecastingWorkflowConfig",
diff --git a/packages/openstef-models/src/openstef_models/testing.py b/packages/openstef-models/src/openstef_models/testing.py
new file mode 100644
index 000000000..9c8998ddc
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/testing.py
@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Testing utilities for openstef-models.
+
+Provides shared test helpers (stub forecasters, fixture factories, pipeline
+builders) that are used across openstef-models and openstef-meta test suites.
+"""
+
+from datetime import timedelta
+
+import numpy as np
+import pandas as pd
+from pydantic import PrivateAttr
+
+from openstef_core.datasets import TimeSeriesDataset
+from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
+from openstef_core.mixins import TransformPipeline
+from openstef_core.mixins.predictor import HyperParams
+from openstef_core.types import LeadTime, override
+from openstef_models.models.forecasting.forecaster import Forecaster
+from openstef_models.transforms.time_domain.lags_adder import LagsAdder
+
+__all__ = ["SimpleForecaster", "create_sample_timeseries_dataset", "create_standard_preprocessing"]
+
+
+class SimpleForecaster(Forecaster):
+    """Simple test forecaster that returns predictable values for testing."""
+
+    _is_fitted: bool = PrivateAttr(default=False)
+
+    @property
+    @override
+    def hparams(self) -> HyperParams:  # noqa: D102
+        return HyperParams()
+
+    @property
+    @override
+    def is_fitted(self) -> bool:  # noqa: D102
+        return self._is_fitted
+
+    @override
+    def fit(self, data: ForecastInputDataset, data_val: ForecastInputDataset | None = None) -> None:  # noqa: D102, ARG002
+        self._is_fitted = True
+
+    @override
+    def predict(self, data: ForecastInputDataset) -> ForecastDataset:  # noqa: D102
+        # Return predictable forecast values
+        forecast_values = {quantile: 100.0 + float(quantile) * 10 for quantile in self.quantiles}
+        return ForecastDataset(
+            pd.DataFrame(
+                {quantile.format(): [forecast_values[quantile]] * len(data.index) for quantile in self.quantiles},
+                index=data.index,
+            ),
+            data.sample_interval,
+            data.forecast_start,
+        )
+
+
+def create_sample_timeseries_dataset() -> TimeSeriesDataset:
+    """Create a small synthetic TimeSeriesDataset for use in unit tests.
+
+    Returns:
+        TimeSeriesDataset with 25 hourly samples of load, temperature, and radiation.
+    """
+    n_samples = 25
+    rng = np.random.default_rng(seed=42)
+
+    data = pd.DataFrame(
+        {
+            "load": 100.0 + rng.normal(10.0, 5.0, n_samples),
+            "temperature": 20.0 + rng.normal(1.0, 0.5, n_samples),
+            "radiation": rng.uniform(0.0, 500.0, n_samples),
+        },
+        index=pd.date_range("2025-01-01 10:00", periods=n_samples, freq="h"),
+    )
+
+    return TimeSeriesDataset(data, timedelta(hours=1))
+
+
+def create_standard_preprocessing(horizons: list[LeadTime]) -> TransformPipeline[TimeSeriesDataset]:
+    """Create the standard LagsAdder preprocessing pipeline used in pickle/roundtrip tests.
+
+    Returns:
+        TransformPipeline with a 14-day LagsAdder.
+    """
+    return TransformPipeline(
+        transforms=[
+            LagsAdder(
+                history_available=timedelta(days=14),
+                horizons=horizons,
+                max_day_lags=7,
+                add_trivial_lags=True,
+                add_autocorr_lags=False,
+            ),
+        ]
+    )
diff --git a/packages/openstef-models/src/openstef_models/utils/xgboost.py b/packages/openstef-models/src/openstef_models/utils/xgboost.py
new file mode 100644
index 000000000..c33a6fff9
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/utils/xgboost.py
@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""XGBoost-specific utility helpers."""
+
+import numpy as np
+import pandas as pd
+
+from openstef_core.types import Quantile
+
+try:
+    import xgboost as xgb
+except ImportError as e:
+    from openstef_core.exceptions import MissingExtraError
+
+    raise MissingExtraError("xgboost", "openstef-models") from e
+
+
+def get_median_shap_contribs(
+    booster: xgb.Booster,
+    input_data: pd.DataFrame,
+    quantiles: list[Quantile],
+) -> np.ndarray:
+    """Compute SHAP contributions and return the median-quantile slice.
+
+    Args:
+        booster: Fitted XGBoost Booster.
+        input_data: Feature matrix for which to compute contributions.
+        quantiles: Quantiles the model was trained on.
+
+    Returns:
+        Array of shape ``(n_samples, n_features + 1)`` where the last column is
+        the model bias.
+    """
+    dmatrix = xgb.DMatrix(input_data)
+    contribs_raw: np.ndarray = booster.predict(dmatrix, pred_contribs=True)
+    n_samples = len(input_data)
+    n_quantiles = len(quantiles)
+    contribs_3d = contribs_raw.reshape(n_samples, n_quantiles, -1)
+    median_idx = min(range(n_quantiles), key=lambda i: abs(float(quantiles[i]) - 0.5))
+    return contribs_3d[:, median_idx, :].copy()
+
+
+__all__ = ["get_median_shap_contribs"]
diff --git a/packages/openstef-models/tests/unit/integrations/optuna/__init__.py b/packages/openstef-models/tests/unit/integrations/optuna/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/openstef-models/tests/unit/integrations/optuna/test_tuner.py b/packages/openstef-models/tests/unit/integrations/optuna/test_tuner.py
new file mode 100644
index 000000000..78d4de4dd
--- /dev/null
+++ b/packages/openstef-models/tests/unit/integrations/optuna/test_tuner.py
@@ -0,0 +1,304 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for the Optuna hyperparameter tuning integration."""
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import optuna
+import pytest
+
+from openstef_core.base_model import BaseConfig
+from openstef_core.mixins.param_ranges import CategoricalRange, FloatRange, IntRange, ModelTuningInfo
+from openstef_models.integrations.optuna import (
+    HyperparameterTuner,
+    TuningResult,
+)
+from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams
+from openstef_models.presets.forecasting_workflow import ForecastingWorkflowConfig
+
+# Suppress Optuna progress output during tests
+optuna.logging.set_verbosity(optuna.logging.WARNING)
+
+
+def _config(**kwargs: Any) -> ForecastingWorkflowConfig:
+    """Minimal ForecastingWorkflowConfig for tuning tests."""
+    return ForecastingWorkflowConfig(model_id="test", model="xgboost", **kwargs)
+
+
+def _make_mock_workflow(score: float = 0.8) -> MagicMock:
+    """Return a mock workflow whose fit() reports a fixed metric score."""
+    mock_metrics = MagicMock()
+    mock_metrics.get_metric.return_value = score
+    mock_fit_result = MagicMock()
+    mock_fit_result.metrics_val = mock_metrics
+    mock_workflow = MagicMock()
+    mock_workflow.fit.return_value = mock_fit_result
+    return mock_workflow
+
+
+def _make_tuner(**overrides: Any) -> HyperparameterTuner[ForecastingWorkflowConfig]:
+    """Create a HyperparameterTuner with sensible defaults for testing."""
+    defaults: dict[str, Any] = {
+        "config": _config(),
+        "train_dataset": MagicMock(),
+        "create_workflow": MagicMock(return_value=_make_mock_workflow()),
+        "target_quantile": "global",
+        "metric_name": "R2",
+        "n_trials": 2,
+        "seed": 0,
+    }
+    defaults.update(overrides)
+    return HyperparameterTuner(**defaults)
+
+
+# _suggest_value
+
+
+@pytest.mark.parametrize(
+    ("tuning_range", "suggest_method", "call_args", "call_kwargs"),
+    [
+        pytest.param(FloatRange(0.1, 0.9), "suggest_float", ("param", 0.1, 0.9), {"log": False}, id="float"),
+        pytest.param(
+            FloatRange(0.01, 0.5, log=True), "suggest_float", ("param", 0.01, 0.5), {"log": True}, id="float-log"
+        ),
+        pytest.param(IntRange(10, 100), "suggest_int", ("param", 10, 100), {"log": False}, id="int"),
+        pytest.param(CategoricalRange(("a", "b")), "suggest_categorical", ("param", ["a", "b"]), {}, id="categorical"),
+    ],
+)
+def test_suggest_value__calls_correct_optuna_api(
+    tuning_range: FloatRange | IntRange | CategoricalRange,
+    suggest_method: str,
+    call_args: tuple[object, ...],
+    call_kwargs: dict[str, object],
+) -> None:
+    """_suggest_value calls the correct optuna.Trial method for each TuningRange type."""
+    # Arrange
+    trial = MagicMock(spec=optuna.Trial)
+    getattr(trial, suggest_method).return_value = 0.5
+
+    # Act
+    HyperparameterTuner.suggest_value(trial, "param", tuning_range)
+
+    # Assert
+    getattr(trial, suggest_method).assert_called_once_with(*call_args, **call_kwargs)
+
+
+@pytest.mark.parametrize(
+    "incomplete_range",
+    [
+        pytest.param(FloatRange(None, 0.9), id="float-missing-low"),
+        pytest.param(FloatRange(0.1, None), id="float-missing-high"),
+        pytest.param(IntRange(None, 100), id="int-missing-low"),
+        pytest.param(CategoricalRange(None), id="categorical-missing-choices"),
+    ],
+)
+def test_suggest_value__returns_none_for_incomplete_range(
+    incomplete_range: FloatRange | IntRange | CategoricalRange,
+) -> None:
+    """_suggest_value returns None when bounds or choices are missing."""
+    # Arrange
+    trial = MagicMock(spec=optuna.Trial)
+
+    # Act / Assert
+    assert HyperparameterTuner.suggest_value(trial, "param", incomplete_range) is None
+
+
+# TuningResult
+
+
+@pytest.mark.parametrize(
+    ("best_params", "expected_repr"),
+    [
+        pytest.param({"alpha": 0.5, "n_iter": 42}, "TuningResult(2 params tuned)", id="with-params"),
+        pytest.param({}, "TuningResult(no tuning)", id="no-params"),
+    ],
+)
+def test_tuning_result__repr_reflects_param_count(best_params: dict[str, Any], expected_repr: str) -> None:
+    """TuningResult.__repr__ summarises the count of tuned parameters."""
+    # Arrange
+    study = MagicMock(spec=optuna.Study)
+    study.best_params = best_params
+
+    result = TuningResult(study=study, best_config=MagicMock(), workflow=MagicMock())
+
+    # Act / Assert
+    assert repr(result) == expected_repr
+
+
+# HyperparameterTuner._reconstruct_best_config
+
+
+def test_reconstruct_best_config__single_model_applies_best_params() -> None:
+    """_reconstruct_best_config updates the single hyperparams field with best_params values."""
+    # Arrange
+    config = _config()
+    tuner = _make_tuner(config=config)
+    info = ModelTuningInfo(
+        field_name="xgboost_hyperparams",
+        hyperparams=config.xgboost_hyperparams,
+        search_space={"n_estimators": IntRange(50, 500, tune=True)},
+    )
+    study = MagicMock(spec=optuna.Study)
+    study.best_params = {"n_estimators": 300}
+
+    # Act
+    best_config = tuner._reconstruct_best_config(config, [info], study)
+
+    # Assert
+    assert best_config.xgboost_hyperparams.n_estimators == 300
+    assert best_config.xgboost_hyperparams.max_depth == config.xgboost_hyperparams.max_depth
+
+
+def test_reconstruct_best_config__multi_model_parses_dotted_trial_keys() -> None:
+    """_reconstruct_best_config routes 'field.param' keys to the correct HP group."""
+    # Arrange
+    config = _config()
+    tuner = _make_tuner(config=config)
+    info_xgb = ModelTuningInfo(
+        field_name="xgboost_hyperparams",
+        hyperparams=config.xgboost_hyperparams,
+        search_space={"n_estimators": IntRange(50, 500, tune=True)},
+    )
+    info_gblinear = ModelTuningInfo(
+        field_name="gblinear_hyperparams",
+        hyperparams=config.gblinear_hyperparams,
+        search_space={"n_estimators": IntRange(50, 500, tune=True)},
+    )
+    study = MagicMock(spec=optuna.Study)
+    study.best_params = {"xgboost_hyperparams.n_estimators": 300, "gblinear_hyperparams.n_estimators": 150}
+
+    # Act
+    best_config = tuner._reconstruct_best_config(config, [info_xgb, info_gblinear], study)
+
+    # Assert
+    assert best_config.xgboost_hyperparams.n_estimators == 300
+    assert best_config.gblinear_hyperparams.n_estimators == 150
+
+
+# HyperparameterTuner.tune / fit_with_tuning
+
+
+def test_hyperparameter_tuner__tune_raises_when_no_tunable_hyperparams() -> None:
+    """HyperparameterTuner.tune() raises ValueError when no tune=True ranges exist."""
+    # Arrange
+    tuner = _make_tuner()
+
+    # Act / Assert
+    with pytest.raises(ValueError, match="No tunable hyperparameters"):
+        tuner.tune()
+
+
+def test_hyperparameter_tuner__tune_returns_best_config_and_study() -> None:
+    """HyperparameterTuner.tune() returns a best_config and completed study."""
+    # Arrange
+    config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+    tuner = _make_tuner(config=config)
+
+    # Act
+    best_config, study = tuner.tune()
+
+    # Assert
+    assert isinstance(best_config, ForecastingWorkflowConfig)
+    assert isinstance(study, optuna.Study)
+    assert len(study.trials) == 2
+    assert "n_estimators" in study.best_params
+    assert 50 <= study.best_params["n_estimators"] <= 500
+
+
+def test_hyperparameter_tuner__fit_with_tuning_returns_tuning_result() -> None:
+    """HyperparameterTuner.fit_with_tuning() returns a TuningResult with best config and study."""
+    # Arrange
+    config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+    create_workflow = MagicMock(return_value=_make_mock_workflow())
+    tuner = _make_tuner(config=config, create_workflow=create_workflow)
+
+    # Act
+    result = tuner.fit_with_tuning()
+
+    # Assert
+    assert isinstance(result, TuningResult)
+    assert isinstance(result.study, optuna.Study)
+    assert isinstance(result.workflow, MagicMock)
+    # 2 trial fits during tuning + 1 final fit with the best config
+    assert create_workflow.call_count == 3
+
+
+def test_hyperparameter_tuner__tune_enqueues_openstef_defaults_as_first_trial() -> None:
+    """tune() enqueues the config defaults before Optuna samples additional trials."""
+    # Arrange
+    config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+    tuner = _make_tuner(config=config)
+
+    # Act
+    _, study = tuner.tune()
+
+    # Assert
+    assert study.trials[0].params == {"n_estimators": config.xgboost_hyperparams.n_estimators}
+
+
+def test_hyperparameter_tuner__create_study_returns_configured_study() -> None:
+    """_create_study creates a study with the configured direction and study name."""
+    # Arrange
+    tuner = _make_tuner(direction="minimize", study_name="custom_study")
+
+    # Act
+    study = tuner._create_study()
+
+    # Assert
+    assert study.direction.name == "MINIMIZE"
+    assert study.study_name == "custom_study"
+
+
+# Metric name validation
+
+
+def test_hyperparameter_tuner__tune_raises_for_invalid_metric_name_with_providers() -> None:
+    """tune() raises ValueError when metric_name doesn't match any provider metric_names."""
+    # Arrange — config with evaluation_metrics whose providers declare metric_names
+    mock_provider = MagicMock()
+    mock_provider.metric_names = frozenset({"R2", "MAE"})
+    config = _config()
+    config = config.model_copy(update={"evaluation_metrics": [mock_provider]})
+    tuner = _make_tuner(
+        config=config,
+        metric_name="nonexistent_metric",
+        # Need at least one tunable field so tune() doesn't exit early
+    )
+
+    # Act / Assert
+    with pytest.raises(ValueError, match=r"nonexistent_metric.*not provided"):
+        tuner.tune()
+
+
+def test_hyperparameter_tuner__tune_skips_validation_when_no_providers() -> None:
+    """tune() skips metric_name validation when config lacks evaluation_metrics."""
+    # Arrange — use a bare BaseConfig without evaluation_metrics field
+    bare_config = BaseConfig()
+    tuner = HyperparameterTuner(
+        config=bare_config,
+        train_dataset=MagicMock(),
+        create_workflow=MagicMock(),
+        target_quantile="global",
+        metric_name="anything",
+        n_trials=2,
+        seed=0,
+    )
+
+    # Act / Assert — raises for missing tunable params, NOT for invalid metric
+    with pytest.raises(ValueError, match="No tunable hyperparameters"):
+        tuner.tune()
+
+
+# n_jobs parallelism
+
+
+def test_hyperparameter_tuner__n_jobs_defaults_to_one() -> None:
+    """HyperparameterTuner.n_jobs defaults to 1."""
+    # Arrange / Act
+    tuner = _make_tuner()
+
+    # Assert
+    assert tuner.n_jobs == 1
diff --git a/packages/openstef-models/tests/unit/models/test_forecasting_model.py b/packages/openstef-models/tests/unit/models/test_forecasting_model.py
index f1d8ef79b..7a4fa3373 100644
--- a/packages/openstef-models/tests/unit/models/test_forecasting_model.py
+++ b/packages/openstef-models/tests/unit/models/test_forecasting_model.py
@@ -11,69 +11,45 @@
 from pydantic import PrivateAttr
 
 from openstef_core.datasets import TimeSeriesDataset
-from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
+from openstef_core.datasets.validated_datasets import ForecastDataset
 from openstef_core.exceptions import InsufficientlyCompleteError, NotFittedError
 from openstef_core.mixins import TransformPipeline
+from openstef_core.mixins.param_ranges import IntRange
 from openstef_core.mixins.predictor import HyperParams
 from openstef_core.testing import assert_timeseries_equal, create_synthetic_forecasting_dataset
 from openstef_core.types import LeadTime, Quantile, override
 from openstef_models.models.forecasting.constant_quantile_forecaster import ConstantQuantileForecaster
-from openstef_models.models.forecasting.forecaster import Forecaster
 from openstef_models.models.forecasting_model import ForecastingModel, restore_target
+from openstef_models.testing import SimpleForecaster, create_sample_timeseries_dataset, create_standard_preprocessing
 from openstef_models.transforms.general.outlier_handler import OUTLIER_NAN_MASK_PREFIX
 from openstef_models.transforms.postprocessing.quantile_sorter import QuantileSorter
-from openstef_models.transforms.time_domain.lags_adder import LagsAdder
 
 
-class SimpleForecaster(Forecaster):
-    """Simple test forecaster that returns predictable values for testing."""
+class TunableTestHyperParams(HyperParams):
+    """Test hyperparameters that can carry a tuning override."""
 
-    _is_fitted: bool = PrivateAttr(default=False)
+    depth: int = 3
 
-    @property
-    @override
-    def hparams(self) -> HyperParams:
-        return HyperParams()
 
-    @property
-    @override
-    def is_fitted(self) -> bool:
-        return self._is_fitted
+class TunableSimpleForecaster(SimpleForecaster):
+    """Simple forecaster exposing unresolved tuning ranges for validation tests."""
 
-    @override
-    def fit(self, data: ForecastInputDataset, data_val: ForecastInputDataset | None = None) -> None:
-        self._is_fitted = True
+    _hparams: TunableTestHyperParams = PrivateAttr(default_factory=TunableTestHyperParams)
 
+    def __init__(self, *, quantiles: list[Quantile], horizons: list[LeadTime], supports_batching: bool = False) -> None:
+        super().__init__(quantiles=quantiles, horizons=horizons, supports_batching=supports_batching)
+        self._hparams = TunableTestHyperParams(depth=IntRange(1, 5, tune=True))  # pyright: ignore[reportArgumentType]
+
+    @property
     @override
-    def predict(self, data: ForecastInputDataset) -> ForecastDataset:
-        # Return predictable forecast values
-        forecast_values = {quantile: 100.0 + quantile * 10 for quantile in self.quantiles}
-        return ForecastDataset(
-            pd.DataFrame(
-                {quantile.format(): [forecast_values[quantile]] * len(data.index) for quantile in self.quantiles},
-                index=data.index,
-            ),
-            data.sample_interval,
-            data.forecast_start,
-        )
+    def hparams(self) -> HyperParams:
+        return self._hparams
 
 
 @pytest.fixture
 def sample_timeseries_dataset() -> TimeSeriesDataset:
     """Create sample time series data with typical energy forecasting features."""
-    n_samples = 25
-    rng = np.random.default_rng(seed=42)
-
-    data = pd.DataFrame(
-        {
-            "load": 100.0 + rng.normal(10.0, 5.0, n_samples),
-            "temperature": 20.0 + rng.normal(1.0, 0.5, n_samples),
-            "radiation": rng.uniform(0.0, 500.0, n_samples),
-        },
-        index=pd.date_range("2025-01-01 10:00", periods=n_samples, freq="h"),
-    )
-
-    return TimeSeriesDataset(data, timedelta(hours=1))
+    return create_sample_timeseries_dataset()
 
 
 def test_forecasting_model__init__uses_defaults():
@@ -142,6 +118,16 @@ def test_forecasting_model__fit_all_nan_target():
     assert not model.is_fitted
 
 
+def test_forecasting_model__init_raises_for_unresolved_tuning_ranges() -> None:
+    """Model construction fails fast when unresolved tuning ranges are still attached."""
+    # Arrange
+    horizons = [LeadTime(timedelta(hours=6))]
+
+    # Act / Assert
+    with pytest.raises(ValueError, match="unresolved tuning ranges"):
+        ForecastingModel(forecaster=TunableSimpleForecaster(quantiles=[Quantile(0.5)], horizons=horizons))
+
+
 def test_forecasting_model__predict(sample_timeseries_dataset: TimeSeriesDataset):
     """Test that predict correctly orchestrates preprocessing and forecaster calls."""
     # Arrange
@@ -220,17 +206,7 @@ def test_forecasting_model__pickle_roundtrip():
             quantiles=[Quantile(0.1), Quantile(0.5), Quantile(0.9)],
             horizons=horizons,
         ),
-        preprocessing=TransformPipeline(
-            transforms=[
-                LagsAdder(
-                    history_available=timedelta(days=14),
-                    horizons=horizons,
-                    max_day_lags=7,
-                    add_trivial_lags=True,
-                    add_autocorr_lags=False,
-                ),
-            ]
-        ),
+        preprocessing=create_standard_preprocessing(horizons),
         postprocessing=TransformPipeline(transforms=[QuantileSorter()]),
         cutoff_history=timedelta(days=7),
         target_column="load",
diff --git a/pyproject.toml b/pyproject.toml
index 15a43c8cc..6dfe79d66 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -54,6 +54,7 @@ urls.Repository = "https://github.com/OpenSTEF/openstef"
 
 [dependency-groups]
 dev = [
+  "jupytext>=1.19.1",
   "licensecheck>=2025.1",
   "microsoft-python-type-stubs",
   "moto[s3,server]>=5.1.11",
@@ -77,6 +78,11 @@ dev = [
 [tool.hatch.build.targets.wheel]
 bypass-selection = true
 
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+default = true
+
 [tool.uv.sources]
 openstef-beam = { workspace = true }
 openstef-models = { workspace = true }
@@ -121,6 +127,15 @@ lint.ignore = [
   "TC006",  # Let's not force quoting the first param of typing.cast
   "TRY003", # simplify exception messages
 ]
+lint.per-file-ignores."./examples/tutorials/*" = [
+  "D100",   # Notebooks don't need module docstrings
+  "E402",   # Imports not at top — notebook cells have natural ordering
+  "ERA001", # Jupytext YAML frontmatter looks like commented-out code
+  "F821",   # Cell-scoped names appear undefined to Ruff's module-level analysis
+  "INP001", # Not a namespace package — notebooks don't need __init__.py
+  "S101",   # Tutorials may use assert for runtime checks
+  "T201",   # Tutorials may use print for demonstration
+]
 lint.per-file-ignores."./packages/*/tests/*" = [
   "ARG",     # Unused function args -> fixtures nevertheless are functionally relevant...
   "D",       # All docstring rules
@@ -215,6 +230,7 @@ include = [
   "packages/*/examples/**/*.py",
   "packages/*/tests/**/*.py",
 ]
+
 typeCheckingMode = "strict"
 reportPrivateImportUsage = false
 reportMissingTypeStubs = false
@@ -262,6 +278,17 @@ args = [
 help = "Run all docstring examples via pytest’s doctest plugin"
 cmd = "pytest --numprocesses=auto --doctest-modules packages/*/src --maxfail=1"
 
+[tool.poe.tasks.notebooks]
+help = "Sync jupytext .py percent sources → .ipynb notebooks (and vice versa)"
+cmd = "jupytext --sync examples/tutorials/*.py"
+
+[tool.poe.tasks.notebooks-check]
+help = "Check that .ipynb notebooks are in sync with their jupytext .py sources"
+sequence = [
+  { cmd = "jupytext --sync examples/tutorials/*.py" },
+  { cmd = "git diff --exit-code -- examples/tutorials/" },
+]
+
 [tool.poe.tasks.report]
 help = "Generate coverage report. Will use data from a previous cover command."
 sequence = [
@@ -303,6 +330,7 @@ switch = [
     "type",
     "tests",
     "doctests",
+    "notebooks-check",
   ], ignore_fail = "return_non_zero" },
   { sequence = [
     "licensecheck --check",
@@ -314,6 +342,7 @@ switch = [
     "type",
     "tests",
     "doctests",
+    "notebooks",
   ], ignore_fail = "return_non_zero" },
 ]
 
diff --git a/sonar-project.properties b/sonar-project.properties
new file mode 100644
index 000000000..28abab60f
--- /dev/null
+++ b/sonar-project.properties
@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# Exclude generated Jupyter notebook files from copy-paste detection.
+# Each .ipynb is generated from its paired .py jupytext source of truth,
+# so SonarCloud reports their content as duplication — it is a false positive.
+# The paired .py jupytext source files share the same boilerplate dataset setup,
+# so they are also excluded for the same reason.
+# Test files are excluded because fixture and helper duplication is expected and intentional.
+sonar.cpd.exclusions=**/*.ipynb,examples/tutorials/*.py,**/tests/**/*.py
diff --git a/uv.lock b/uv.lock
index d6360eecc..2271380e5 100644
--- a/uv.lock
+++ b/uv.lock
@@ -172,6 +172,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
 ]
 
+[[package]]
+name = "alembic"
+version = "1.18.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mako" },
+    { name = "sqlalchemy" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/41/ab8f624929847b49f84955c594b165855efd829b0c271e1a8cac694138e5/alembic-1.18.3.tar.gz", hash = "sha256:1212aa3778626f2b0f0aa6dd4e99a5f99b94bd25a0c1ac0bba3be65e081e50b0", size = 2052564, upload-time = "2026-01-29T20:24:15.124Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/8e/d79281f323e7469b060f15bd229e48d7cdd219559e67e71c013720a88340/alembic-1.18.3-py3-none-any.whl", hash = "sha256:12a0359bfc068a4ecbb9b3b02cf77856033abfdb59e4a5aca08b7eacd7b74ddd", size = 262282, upload-time = "2026-01-29T20:24:17.488Z" },
+]
+
 [[package]]
 name = "annotated-doc"
 version = "0.0.4"
@@ -632,6 +646,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
+[[package]]
+name = "colorlog"
+version = "6.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },
+]
+
 [[package]]
 name = "comm"
 version = "0.2.3"
@@ -1236,6 +1262,49 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/14/933037032608787fb92e365883ad6a741c235e0ff992865ec5d904a38f1e/graphql_core-3.2.7-py3-none-any.whl", hash = "sha256:17fc8f3ca4a42913d8e24d9ac9f08deddf0a0b2483076575757f6c412ead2ec0", size = 207262, upload-time = "2025-11-01T22:30:38.912Z" },
 ]
 
+[[package]]
+name = "greenlet"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
+    { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/cd/7a7ca57588dac3389e97f7c9521cb6641fd8b6602faf1eaa4188384757df/greenlet-3.3.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c620051669fd04ac6b60ebc70478210119c56e2d5d5df848baec4312e260e4ca", size = 622363, upload-time = "2026-01-23T16:15:54.754Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
+    { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
+    { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
+    { url = "https://files.pythonhosted.org/packages/06/00/95df0b6a935103c0452dad2203f5be8377e551b8466a29650c4c5a5af6cc/greenlet-3.3.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:12184c61e5d64268a160226fb4818af4df02cfead8379d7f8b99a56c3a54ff3e", size = 624375, upload-time = "2026-01-23T16:15:55.915Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
+    { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
+    { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/89/b95f2ddcc5f3c2bc09c8ee8d77be312df7f9e7175703ab780f2014a0e781/greenlet-3.3.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e0f3878ca3a3ff63ab4ea478585942b53df66ddde327b59ecb191b19dbbd62d", size = 671455, upload-time = "2026-01-23T16:15:57.232Z" },
+    { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
+    { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
+    { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
+    { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
+    { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/25/c51a63f3f463171e09cb586eb64db0861eb06667ab01a7968371a24c4f3b/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b9721549a95db96689458a1e0ae32412ca18776ed004463df3a9299c1b257ab", size = 662574, upload-time = "2026-01-23T16:15:58.364Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
+    { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
+    { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -1852,6 +1921,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" },
 ]
 
+[[package]]
+name = "jupytext"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/a5/80c02f307c8ce863cb33e27daf049315e9d96979e14eead700923b5ec9cc/jupytext-1.19.1.tar.gz", hash = "sha256:82587c07e299173c70ed5e8ec7e75183edf1be289ed518bab49ad0d4e3d5f433", size = 4307829, upload-time = "2026-01-25T21:35:13.276Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/5a/736dd2f4535dbf3bf26523f9158c011389ef88dd06ec2eef67fd744f1c7b/jupytext-1.19.1-py3-none-any.whl", hash = "sha256:d8975035155d034bdfde5c0c37891425314b7ea8d3a6c4b5d18c294348714cd9", size = 170478, upload-time = "2026-01-25T21:35:11.17Z" },
+]
+
 [[package]]
 name = "kaleido"
 version = "1.2.0"
@@ -2055,6 +2140,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
 ]
 
+[[package]]
+name = "mako"
+version = "1.3.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+]
+
 [[package]]
 name = "markdown"
 version = "3.10"
@@ -2707,6 +2804,7 @@ models = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "jupytext" },
     { name = "licensecheck" },
     { name = "microsoft-python-type-stubs" },
     { name = "moto", extra = ["s3", "server"] },
@@ -2744,6 +2842,7 @@ provides-extras = ["all", "beam", "meta", "models"]
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "jupytext", specifier = ">=1.19.1" },
     { name = "licensecheck", specifier = ">=2025.1" },
     { name = "microsoft-python-type-stubs", git = "https://github.com/microsoft/python-type-stubs.git" },
     { name = "moto", extras = ["s3", "server"], specifier = ">=5.1.11" },
@@ -2814,8 +2913,14 @@ dependencies = [
     { name = "pydantic-extra-types" },
 ]
 
+[package.optional-dependencies]
+benchmark = [
+    { name = "huggingface-hub" },
+]
+
 [package.metadata]
 requires-dist = [
+    { name = "huggingface-hub", marker = "extra == 'benchmark'", specifier = ">=1.2.2" },
     { name = "joblib", specifier = ">=1,<2" },
     { name = "numpy", specifier = ">=2.3.2,<3" },
     { name = "pandas", specifier = ">=2.3.1,<3" },
@@ -2823,6 +2928,7 @@ requires-dist = [
     { name = "pydantic", specifier = ">=2.12.4,<3" },
     { name = "pydantic-extra-types", specifier = ">=2.10.5,<3" },
 ]
+provides-extras = ["benchmark"]
 
 [[package]]
 name = "openstef-docs"
@@ -2880,19 +2986,19 @@ dependencies = [
 
 [package.optional-dependencies]
 tutorials = [
-    { name = "huggingface-hub" },
     { name = "jupyter" },
     { name = "kaleido" },
+    { name = "openstef-core", extra = ["benchmark"] },
 ]
 
 [package.metadata]
 requires-dist = [
-    { name = "huggingface-hub", marker = "extra == 'tutorials'", specifier = ">=1.2.2" },
     { name = "jupyter", marker = "extra == 'tutorials'", specifier = ">=1.1.1" },
     { name = "kaleido", marker = "extra == 'tutorials'" },
     { name = "openstef", editable = "." },
     { name = "openstef-beam", editable = "packages/openstef-beam" },
     { name = "openstef-core", editable = "packages/openstef-core" },
+    { name = "openstef-core", extras = ["benchmark"], marker = "extra == 'tutorials'", editable = "packages/openstef-core" },
     { name = "openstef-models", editable = "packages/openstef-models" },
 ]
 provides-extras = ["tutorials"]
@@ -2933,6 +3039,9 @@ dependencies = [
 lgbm = [
     { name = "lightgbm" },
 ]
+tuning = [
+    { name = "optuna" },
+]
 xgb-cpu = [
     { name = "xgboost", marker = "sys_platform == 'darwin'" },
     { name = "xgboost-cpu", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
@@ -2948,6 +3057,7 @@ requires-dist = [
     { name = "mlflow-skinny", specifier = ">=3,<4" },
     { name = "openstef-beam", editable = "packages/openstef-beam" },
     { name = "openstef-core", editable = "packages/openstef-core" },
+    { name = "optuna", marker = "extra == 'tuning'", specifier = ">=4.7" },
     { name = "pvlib", specifier = ">=0.13" },
     { name = "pycountry", specifier = ">=24.6.1" },
     { name = "scikit-learn", specifier = ">=1.7.1,<1.8" },
@@ -2956,7 +3066,7 @@ requires-dist = [
     { name = "xgboost", marker = "extra == 'xgb-gpu'", specifier = ">=3,<4" },
     { name = "xgboost-cpu", marker = "(sys_platform == 'linux' and extra == 'xgb-cpu') or (sys_platform == 'win32' and extra == 'xgb-cpu')", specifier = ">=3,<4" },
 ]
-provides-extras = ["lgbm", "xgb-cpu", "xgb-gpu"]
+provides-extras = ["lgbm", "tuning", "xgb-cpu", "xgb-gpu"]
 
 [[package]]
 name = "opentelemetry-api"
@@ -3010,6 +3120,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/24/7d/c88d7b15ba8fe5c6b8f93be50fc11795e9fc05386c44afaf6b76fe191f9b/opentelemetry_semantic_conventions-0.59b0-py3-none-any.whl", hash = "sha256:35d3b8833ef97d614136e253c1da9342b4c3c083bbaf29ce31d572a1c3825eed", size = 207954, upload-time = "2025-10-16T08:35:48.054Z" },
 ]
 
+[[package]]
+name = "optuna"
+version = "4.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "alembic" },
+    { name = "colorlog" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "sqlalchemy" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/b2/b5e12de7b4486556fe2257611b55dbabf30d0300bdb031831aa943ad20e4/optuna-4.7.0.tar.gz", hash = "sha256:d91817e2079825557bd2e97de2e8c9ae260bfc99b32712502aef8a5095b2d2c0", size = 479740, upload-time = "2026-01-19T05:45:52.604Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/d1/6c8a4fbb38a9e3565f5c36b871262a85ecab3da48120af036b1e4937a15c/optuna-4.7.0-py3-none-any.whl", hash = "sha256:e41ec84018cecc10eabf28143573b1f0bde0ba56dba8151631a590ecbebc1186", size = 413894, upload-time = "2026-01-19T05:45:50.815Z" },
+]
+
 [[package]]
 name = "optype"
 version = "0.14.0"
@@ -4774,6 +4902,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
 ]
 
+[[package]]
+name = "sqlalchemy"
+version = "2.0.46"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
+    { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
+    { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
+    { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
+    { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
+    { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
+    { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
+    { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
+]
+
 [[package]]
 name = "sqlparse"
 version = "0.5.3"