diff --git a/.gitignore b/.gitignore
index 50b2ff7d..346ade17 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,5 @@ uv.lock
 
 # evalml
 .evalml_snakemake_cmd.txt
+rulegraph.svg
+dag.svg
diff --git a/pyproject.toml b/pyproject.toml
index 53f4207c..2ee33197 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -59,7 +59,8 @@ markers = [
 packages = [
   "src/evalml",
   "src/verification",
-  "src/data_input"
+  "src/data_input",
+  "src/diagnostics"
 ]
 
 [tool.uv.sources]
diff --git a/resources/report/dashboard/script.js b/resources/report/dashboard/script.js
index 0934b4eb..beb8f85e 100644
--- a/resources/report/dashboard/script.js
+++ b/resources/report/dashboard/script.js
@@ -42,6 +42,136 @@ function getSelected(id) {
   return choicesInstances[id] ? choicesInstances[id].getValue(true) : [];
 }
 
+// Initial chart
+updateChart()
+
+
+// ---- System metrics tab ----
+
+const sysDataEl = document.getElementById("sysmetrics-data");
+const sysData = sysDataEl ? JSON.parse(sysDataEl.textContent) : [];
+
+if (sysData.length > 0) {
+  choicesInstances["sys-model-type-select"] = new Choices("#sys-model-type-select", {
+    searchEnabled: false,
+    removeItemButton: true,
+    shouldSort: false,
+    itemSelectText: "",
+    placeholder: false,
+  });
+  document.getElementById("sys-model-type-select").addEventListener("change", updateSysChart);
+
+  choicesInstances["sys-source-select"] = new Choices("#sys-source-select", {
+    searchEnabled: false,
+    removeItemButton: true,
+    shouldSort: false,
+    itemSelectText: "",
+    placeholder: false,
+  });
+  document.getElementById("sys-source-select").addEventListener("change", updateSysChart);
+
+  // Populate metric filter from the data, then initialise Choices on it
+  const sysMetricEl = document.getElementById("sys-metric-select");
+  [...new Set(sysData.map(d => d.metric))].sort().forEach(m => {
+    const opt = document.createElement("option");
+    opt.value = m;
+    opt.textContent = m;
+    opt.selected = true;
+    sysMetricEl.appendChild(opt);
+  });
+  choicesInstances["sys-metric-select"] = new Choices("#sys-metric-select", {
+    searchEnabled: false,
+    removeItemButton: true,
+    shouldSort: false,
+    itemSelectText: "",
+    placeholder: false,
+  });
+  document.getElementById("sys-metric-select").addEventListener("change", updateSysChart);
+
+  const sysSpec = {
+    "data": { "values": sysData },
+    "facet": { "field": "metric", "type": "nominal", "title": null },
+    "columns": 4,
+    "resolve": { "scale": { "x": "shared", "y": "independent" } },
+    "spec": {
+      "params": [
+        {
+          "name": "xZoom",
+          "select": {
+            "type": "interval",
+            "encodings": ["x"],
+            "zoom": "wheel![!event.shiftKey]"
+          },
+          "bind": "scales"
+        }
+      ],
+      "width": 300,
+      "height": 200,
+      "mark": { "type": "line", "point": { "filled": true, "size": 50 } },
+      "encoding": {
+        "x": {
+          "field": "init_time",
+          "type": "temporal",
+          "title": null,
+          "axis": { "labelAngle": -30, "format": "%b %d" }
+        },
+        "y": {
+          "field": "value",
+          "type": "quantitative",
+          "title": null,
+          "scale": { "zero": false }
+        },
+        "color": {
+          "field": "source",
+          "type": "nominal",
+          "legend": { "orient": "top", "title": "Source" }
+        },
+        "shape": {
+          "field": "model_type",
+          "type": "nominal",
+          "legend": { "orient": "top", "title": "Model type" }
+        },
+        "strokeDash": {
+          "field": "model_type",
+          "type": "nominal",
+          "legend": { "orient": "top", "title": "Model type" }
+        },
+        "tooltip": [
+          { "field": "source", "type": "nominal", "title": "Source" },
+          { "field": "model_type", "type": "nominal", "title": "Model type" },
+          { "field": "init_time", "type": "temporal", "title": "Init time", "format": "%Y-%m-%d %H:%M" },
+          { "field": "metric", "type": "nominal", "title": "Metric" },
+          { "field": "value", "type": "quantitative", "title": "Value", "format": ".3f" },
+          { "field": "n_gpu", "type": "quantitative", "title": "GPUs" },
+          { "field": "job_id", "type": "nominal", "title": "Job ID" },
+        ],
+      },
+    },
+  };
+
+  function updateSysChart() {
+    const selectedModelTypes = getSelectedValues("sys-model-type-select");
+    const selectedSources = getSelectedValues("sys-source-select");
+    const selectedMetrics = getSelectedValues("sys-metric-select");
+    const newSpec = JSON.parse(JSON.stringify(sysSpec));
+    const filters = [];
+    if (selectedModelTypes.length > 0) {
+      filters.push({ field: "model_type", oneOf: selectedModelTypes });
+    }
+    if (selectedSources.length > 0) {
+      filters.push({ field: "source", oneOf: selectedSources });
+    }
+    if (selectedMetrics.length > 0) {
+      filters.push({ field: "metric", oneOf: selectedMetrics });
+    }
+    if (filters.length > 0) {
+      newSpec.transform = [{ filter: { and: filters } }];
+    }
+    vegaEmbed("#sys-vis", newSpec, { actions: false });
+  }
+
+  updateSysChart();
+}
 // ---------------------------------------------------------------------------
 // Data
 // ---------------------------------------------------------------------------
diff --git a/resources/report/dashboard/template.html.jinja2 b/resources/report/dashboard/template.html.jinja2
index 429579a5..fc39cb02 100644
--- a/resources/report/dashboard/template.html.jinja2
+++ b/resources/report/dashboard/template.html.jinja2
@@ -109,6 +109,9 @@
 
 <div class="tab-buttons">
     <button class="tab-link active" data-tab="tab_scores">Standard verification</button>
+    {% if sysmetrics_sources %}
+    <button class="tab-link" data-tab="tab_sysmetrics">System metrics</button>
+    {% endif %}
     <button class="tab-link" data-tab="tab_config">Config</button>
 </div>
 
@@ -205,6 +208,37 @@
     </div>
 </div>
 
+
+<!-- System metrics tab -->
+{% if sysmetrics_sources %}
+<div id="tab_sysmetrics" class="tab-content">
+    <div class="controls">
+        <div class="control-group">
+            <label>Model type(s)</label>
+            <select id="sys-model-type-select" multiple>
+                {% for model_type in sysmetrics_model_types %}
+                <option value="{{model_type}}" selected>{{model_type}}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="control-group">
+            <label>Source(s)</label>
+            <select id="sys-source-select" multiple>
+                {% for source in sysmetrics_sources %}
+                <option value="{{source}}" selected>{{source}}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="control-group">
+            <label>Metric(s)</label>
+            <select id="sys-metric-select" multiple></select>
+        </div>
+    </div>
+    <div id="sys-vis"></div>
+</div>
+{% endif %}
+
+<!-- Config file tab -->
 <div id="tab_config" class="tab-content">
     <pre style="background:#f7f7f7; border:1px solid #ddd; padding:1em; overflow-x:auto; max-height:60vh;">
 {{ configfile_content | e }}
@@ -215,6 +249,22 @@
     {{ verif_data | safe | indent(4, false) }}
 </script>
 
+<script id="sysmetrics-data" type="application/json">
+    {{ sysmetrics_data | safe | indent(8, false) }}
+</script>
+
+<script id="verif-data" type="application/json">
+    {{ verif_data | safe | indent(8, false)}}
+</script>
+
+<script id="header-text" type="text">
+    {{ header_text }}
+</script>
+
+<script>
+    {{ js_src | indent(8, true) }}
+</script>
+
 <script>
 window.onerror = function(msg, src, line, col, err) {
     var d = document.getElementById("js-error-box");
diff --git a/src/diagnostics/__init__.py b/src/diagnostics/__init__.py
new file mode 100644
index 00000000..58a19152
--- /dev/null
+++ b/src/diagnostics/__init__.py
@@ -0,0 +1,270 @@
+"""System-performance diagnostics for inference jobs."""
+
+import logging
+import math
+from datetime import datetime
+from pathlib import Path
+
+LOG = logging.getLogger(__name__)
+
+# Columns exposed as distribution metrics in the dashboard
+SYSMETRICS_COLS = {
+    "wall_time_s": "Wall Time (s)",
+    "gpu_hours": "GPU Hours",
+    "max_rss_mb": "Peak CPU Memory (MB)",
+    "gpu_util_mean": "Mean GPU Util (%)",
+    "gpu_util_max": "Peak GPU Util (%)",
+    "gpu_mem_used_mean": "Mean GPU Memory (MiB)",
+    "gpu_mem_used_max": "Peak GPU Memory (MiB)",
+    "gpu_power_mean": "Mean GPU Power (W)",
+}
+
+
+def _parse_elapsed(s: str) -> float | None:
+    """Parse sacct elapsed 'D-HH:MM:SS' or 'HH:MM:SS' → seconds."""
+    s = s.strip()
+    try:
+        if "-" in s:
+            days, rest = s.split("-", 1)
+            h, m, sec = rest.split(":")
+            return int(days) * 86400 + int(h) * 3600 + int(m) * 60 + int(sec)
+        h, m, sec = s.split(":")
+        return int(h) * 3600 + int(m) * 60 + int(sec)
+    except Exception:
+        return None
+
+
+def _parse_memory(s: str) -> float | None:
+    """Parse sacct memory string ('2048K', '1.5M', '0.5G') → MB."""
+    s = s.strip()
+    if not s or s == "0":
+        return None
+    try:
+        if s.endswith("K"):
+            return float(s[:-1]) / 1024
+        if s.endswith("M"):
+            return float(s[:-1])
+        if s.endswith("G"):
+            return float(s[:-1]) * 1024
+        return float(s) / (1024 * 1024)
+    except ValueError:
+        return None
+
+
+def parse_sacct_log(log_path: str) -> dict:
+    """Parse slurm_metrics.log (sacct --parsable2 output) → metric dict.
+
+    Extracts wall_time_s from the parent job record (no dot in JobID) and
+    max_rss_mb as the maximum MaxRSS across all step records.
+    """
+    path = Path(log_path)
+    if not path.exists() or path.stat().st_size == 0:
+        return {}
+
+    lines = [ln for ln in path.read_text().splitlines() if ln.strip()]
+    if len(lines) < 2:
+        return {}
+
+    headers = [h.strip() for h in lines[0].split("|")]
+    rows = []
+    for line in lines[1:]:
+        fields = [f.strip() for f in line.split("|")]
+        if len(fields) >= len(headers):
+            rows.append(dict(zip(headers, fields)))
+
+    if not rows:
+        return {}
+
+    result: dict = {}
+
+    # Elapsed from the parent job record (no dot in JobID, no 'batch'/'extern' suffix)
+    for row in rows:
+        job_id = row.get("JobID", "")
+        if "." not in job_id and not job_id.endswith(("batch", "extern")):
+            val = _parse_elapsed(row.get("Elapsed", ""))
+            if val is not None:
+                result["wall_time_s"] = val
+            break
+
+    # MaxRSS: take the maximum across all step rows (parent job entry is 0)
+    rss_vals = [
+        v
+        for row in rows
+        if (v := _parse_memory(row.get("MaxRSS", ""))) is not None and v > 0
+    ]
+    if rss_vals:
+        result["max_rss_mb"] = round(max(rss_vals), 1)
+
+    return result
+
+
+def _parse_dmon_headers(header_line: str) -> dict[str, int]:
+    """Return {col_name: data_row_index} from a '# gpu …' nvidia-smi dmon header.
+
+    The first token after '#' is 'gpu' — a row-type label, not a data column —
+    so actual data indices are offset by -1 relative to the token positions.
+    """
+    tokens = header_line.lstrip("#").split()
+    return {name: i - 1 for i, name in enumerate(tokens) if i > 0}
+
+
+def parse_gpu_metrics_log(log_path: str) -> dict:
+    """Parse gpu_metrics.log (nvidia-smi dmon -o DT) → GPU utilisation/memory/power dict."""
+    path = Path(log_path)
+    if not path.exists() or path.stat().st_size == 0:
+        return {}
+
+    col_idx: dict[str, int] = {}
+    data_rows: list[list[float]] = []
+
+    for raw_line in path.read_text().splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        if line.startswith("#"):
+            tokens = line.lstrip("#").split()
+            # Column-name header contains 'sm' or 'Idx'; unit header contains '%' or 'W'
+            if "sm" in tokens or "Idx" in tokens:
+                col_idx = _parse_dmon_headers(line)
+            continue
+        fields = line.split()
+        if len(fields) < 5 or not col_idx:
+            continue
+        nums: list[float] = []
+        for f in fields:
+            try:
+                nums.append(float(f))
+            except ValueError:
+                nums.append(float("nan"))
+        data_rows.append(nums)
+
+    if not data_rows or not col_idx:
+        return {}
+
+    def _vals(col: str) -> list[float]:
+        idx = col_idx.get(col)
+        if idx is None:
+            return []
+        return [
+            r[idx]
+            for r in data_rows
+            if idx < len(r) and math.isfinite(r[idx])
+        ]
+
+    result: dict = {}
+
+    sm = _vals("sm")
+    if sm:
+        result["gpu_util_mean"] = round(sum(sm) / len(sm), 1)
+        result["gpu_util_max"] = round(max(sm), 1)
+
+    fb = _vals("fb")
+    if fb:
+        result["gpu_mem_used_mean"] = round(sum(fb) / len(fb), 1)
+        result["gpu_mem_used_max"] = round(max(fb), 1)
+
+    pwr = _vals("pwr")
+    if pwr:
+        result["gpu_power_mean"] = round(sum(pwr) / len(pwr), 1)
+
+    return result
+
+
+def parse_run_metrics(workdir: str) -> dict:
+    """Read sacct and GPU metric files from a run's workdir and merge them."""
+    wd = Path(workdir)
+    result: dict = {}
+
+    result.update(parse_sacct_log(str(wd / "slurm_metrics.log")))
+    result.update(parse_gpu_metrics_log(str(wd / "gpu_metrics.log")))
+
+    job_id_file = wd / "slurm_job_id"
+    if job_id_file.exists():
+        result["job_id"] = job_id_file.read_text().strip()
+
+    return result
+
+
+def parse_logs(
+    run_info: list[dict],
+    label_map: dict[str, str],
+    gpu_map: dict[str, int],
+) -> list[dict]:
+    """Parse Slurm metric files and return one record per (run, init_time).
+
+    Parameters
+    ----------
+    run_info  : list of dicts with keys 'workdir', 'run_id', 'init_time'.
+    label_map : {run_id: human-readable label}.
+    gpu_map   : {run_id: n_gpu}.
+    """
+    records: list[dict] = []
+
+    for spec in run_info:
+        workdir = spec["workdir"]
+        run_id = spec["run_id"]
+        init_time_str = spec["init_time"]
+
+        wd = Path(workdir)
+        if not wd.exists():
+            LOG.warning("Workdir not found, skipping: %s", workdir)
+            continue
+
+        label = label_map.get(run_id, run_id)
+        n_gpu = int(gpu_map.get(run_id, 1))
+        model_type = run_id.split("-")[0]
+
+        try:
+            raw = parse_run_metrics(workdir)
+        except Exception as exc:
+            LOG.warning("Failed to parse metrics for %s: %s", workdir, exc)
+            continue
+
+        if not raw:
+            LOG.warning("No metrics found for %s, skipping", workdir)
+            continue
+
+        wall_s = raw.get("wall_time_s")
+        gpu_hours = round(wall_s / 3600 * n_gpu, 4) if wall_s is not None else None
+
+        try:
+            init_iso = datetime.strptime(init_time_str, "%Y%m%d%H%M").isoformat()
+        except ValueError:
+            init_iso = init_time_str
+
+        records.append(
+            {
+                "source": label,
+                "run_id": run_id,
+                "model_type": model_type,
+                "init_time": init_iso,
+                "n_gpu": n_gpu,
+                "gpu_hours": gpu_hours,
+                **raw,
+            }
+        )
+
+    LOG.info("Parsed %d run specs → %d records", len(run_info), len(records))
+    return records
+
+
+def melt_for_dashboard(records: list[dict]) -> tuple[str, list[str], list[str]]:
+    """Convert wide-format system metrics records to long format for Vega-Lite.
+
+    Returns (json_string, sorted_source_list, sorted_model_type_list).
+    """
+    import json
+
+    long_records = []
+    for r in records:
+        base = {
+            k: r.get(k)
+            for k in ("source", "model_type", "init_time", "n_gpu", "job_id")
+        }
+        for col, label in SYSMETRICS_COLS.items():
+            if r.get(col) is not None:
+                long_records.append({**base, "metric": label, "value": r[col]})
+
+    sources = sorted({r["source"] for r in records})
+    model_types = sorted({r.get("model_type", "unknown") for r in records})
+    return json.dumps(long_records), sources, model_types
diff --git a/tests/unit/test_parse_inference_logs.py b/tests/unit/test_parse_inference_logs.py
new file mode 100644
index 00000000..9c96baa7
--- /dev/null
+++ b/tests/unit/test_parse_inference_logs.py
@@ -0,0 +1,205 @@
+import json
+
+import pytest
+
+from diagnostics import melt_for_dashboard, parse_logs
+from diagnostics import parse_gpu_metrics_log, parse_sacct_log
+
+SACCT_CONTENT = """\
+JobID|JobName|Elapsed|CPUTime|MaxRSS|MaxVMSize|AveRSS|MaxDiskRead|MaxDiskWrite
+12345678|run_with_metrics.sh|00:05:23|02:08:48|0|0|0|4320K|2100K
+12345678.0|run_with_metrics.sh|00:05:23|02:08:48|2048K|5120K|1024K|4320K|2100K
+12345678.batch|batch|00:00:01|00:00:24|512K|1024K|256K|0|0
+"""
+
+DMON_CONTENT = """\
+# gpu   Date        Time        Idx   sm   mem   enc   dec   pwr  mclk  pclk pviol tviol    fb  bar1 sbecc dbecc   pci gtemp mtemp
+# Devicems                           %     %     %     %    W   MHz   MHz      %     % MiB   MiB                       C     C
+20250602 12:34:56    0   85    70     0     0   250  1215  1530     0     0  8192 10240     0     0     0    65    50
+20250602 12:35:01    0   90    75     0     0   260  1215  1530     0     0  8300 10240     0     0     0    66    51
+"""
+
+
+def test_parse_sacct_wall_time(tmp_path):
+    log_file = tmp_path / "slurm_metrics.log"
+    log_file.write_text(SACCT_CONTENT)
+
+    result = parse_sacct_log(str(log_file))
+
+    assert result["wall_time_s"] == pytest.approx(5 * 60 + 23)
+
+
+def test_parse_sacct_max_rss(tmp_path):
+    log_file = tmp_path / "slurm_metrics.log"
+    log_file.write_text(SACCT_CONTENT)
+
+    result = parse_sacct_log(str(log_file))
+
+    # 2048K = 2.0 MB; 512K = 0.5 MB; parent row is 0 → max is 2.0
+    assert result["max_rss_mb"] == pytest.approx(2.0, rel=1e-3)
+
+
+def test_parse_sacct_missing_file(tmp_path):
+    result = parse_sacct_log(str(tmp_path / "does_not_exist.log"))
+    assert result == {}
+
+
+def test_parse_sacct_empty_file(tmp_path):
+    f = tmp_path / "slurm_metrics.log"
+    f.write_text("")
+    assert parse_sacct_log(str(f)) == {}
+
+
+def test_parse_gpu_metrics_utilisation(tmp_path):
+    log_file = tmp_path / "gpu_metrics.log"
+    log_file.write_text(DMON_CONTENT)
+
+    result = parse_gpu_metrics_log(str(log_file))
+
+    assert result["gpu_util_mean"] == pytest.approx((85 + 90) / 2, rel=1e-3)
+    assert result["gpu_util_max"] == pytest.approx(90.0)
+
+
+def test_parse_gpu_metrics_memory(tmp_path):
+    log_file = tmp_path / "gpu_metrics.log"
+    log_file.write_text(DMON_CONTENT)
+
+    result = parse_gpu_metrics_log(str(log_file))
+
+    assert result["gpu_mem_used_mean"] == pytest.approx((8192 + 8300) / 2, rel=1e-3)
+    assert result["gpu_mem_used_max"] == pytest.approx(8300.0)
+
+
+def test_parse_gpu_metrics_power(tmp_path):
+    log_file = tmp_path / "gpu_metrics.log"
+    log_file.write_text(DMON_CONTENT)
+
+    result = parse_gpu_metrics_log(str(log_file))
+
+    assert result["gpu_power_mean"] == pytest.approx((250 + 260) / 2, rel=1e-3)
+
+
+def test_parse_gpu_metrics_missing_file(tmp_path):
+    assert parse_gpu_metrics_log(str(tmp_path / "does_not_exist.log")) == {}
+
+
+def test_parse_logs_reads_slurm_and_gpu_files(tmp_path):
+    workdir = tmp_path / "data" / "runs" / "forecaster-abc" / "202503010000"
+    workdir.mkdir(parents=True)
+    (workdir / "slurm_metrics.log").write_text(SACCT_CONTENT)
+    (workdir / "gpu_metrics.log").write_text(DMON_CONTENT)
+    (workdir / "slurm_job_id").write_text("12345678\n")
+
+    records = parse_logs(
+        run_info=[
+            {
+                "workdir": str(workdir),
+                "run_id": "forecaster-abc",
+                "init_time": "202503010000",
+            }
+        ],
+        label_map={"forecaster-abc": "My Model"},
+        gpu_map={"forecaster-abc": 2},
+    )
+
+    assert len(records) == 1
+    r = records[0]
+    assert r["source"] == "My Model"
+    assert r["run_id"] == "forecaster-abc"
+    assert r["model_type"] == "forecaster"
+    assert r["init_time"] == "2025-03-01T00:00:00"
+    assert r["n_gpu"] == 2
+    assert r["job_id"] == "12345678"
+    assert r["wall_time_s"] == pytest.approx(323.0)
+    assert r["gpu_hours"] == pytest.approx(323.0 / 3600 * 2, rel=1e-3)
+    assert "gpu_util_mean" in r
+    assert "max_rss_mb" in r
+
+
+def test_parse_logs_missing_workdir_is_skipped(tmp_path):
+    records = parse_logs(
+        run_info=[
+            {
+                "workdir": str(tmp_path / "does_not_exist"),
+                "run_id": "forecaster-abc",
+                "init_time": "202503010000",
+            }
+        ],
+        label_map={},
+        gpu_map={},
+    )
+    assert records == []
+
+
+def test_parse_logs_no_metrics_files_is_skipped(tmp_path):
+    workdir = tmp_path / "empty_run"
+    workdir.mkdir()
+    records = parse_logs(
+        run_info=[{"workdir": str(workdir), "run_id": "x", "init_time": "202503010000"}],
+        label_map={},
+        gpu_map={},
+    )
+    assert records == []
+
+
+def test_parse_logs_model_type_from_run_id_prefix(tmp_path):
+    for prefix, expected_type in [
+        ("forecaster-c304", "forecaster"),
+        ("interpolator-tmp-d5aa", "interpolator"),
+    ]:
+        workdir = tmp_path / prefix / "202503010000"
+        workdir.mkdir(parents=True)
+        (workdir / "slurm_metrics.log").write_text(SACCT_CONTENT)
+
+        records = parse_logs(
+            run_info=[{"workdir": str(workdir), "run_id": prefix, "init_time": "202503010000"}],
+            label_map={},
+            gpu_map={},
+        )
+        assert records[0]["model_type"] == expected_type
+
+
+def test_parse_logs_fallback_label_is_run_id(tmp_path):
+    workdir = tmp_path / "env-abc" / "202503020000"
+    workdir.mkdir(parents=True)
+    (workdir / "slurm_metrics.log").write_text(SACCT_CONTENT)
+
+    records = parse_logs(
+        run_info=[{"workdir": str(workdir), "run_id": "env-abc", "init_time": "202503020000"}],
+        label_map={},
+        gpu_map={},
+    )
+    assert records[0]["source"] == "env-abc"
+
+
+def test_melt_for_dashboard_exposes_model_type_and_distribution_metrics():
+    records = [
+        {
+            "source": "ModelA",
+            "model_type": "forecaster",
+            "init_time": "2025-03-01T00:00:00",
+            "n_gpu": 1,
+            "job_id": "111",
+            "wall_time_s": 60.0,
+            "gpu_hours": 1 / 60,
+        },
+        {
+            "source": "ModelA",
+            "model_type": "interpolator",
+            "init_time": "2025-03-02T00:00:00",
+            "n_gpu": 1,
+            "job_id": "222",
+            "wall_time_s": 120.0,
+            "gpu_hours": 2 / 60,
+        },
+    ]
+    data_json, sources, model_types = melt_for_dashboard(records)
+    rows = json.loads(data_json)
+
+    assert sources == ["ModelA"]
+    assert model_types == ["forecaster", "interpolator"]
+    # only wall_time_s and gpu_hours are present in the test records
+    metrics_present = {r["metric"] for r in rows}
+    assert metrics_present == {"Wall Time (s)", "GPU Hours"}
+    # model_type must be present in every row
+    assert all("model_type" in r for r in rows)
diff --git a/workflow/rules/inference.smk b/workflow/rules/inference.smk
index d2b8ef1e..0790dd4a 100644
--- a/workflow/rules/inference.smk
+++ b/workflow/rules/inference.smk
@@ -308,6 +308,28 @@ rule inference_execute:
 
             cd {params.workdir}
 
+            METRICS_DIR={params.workdir}
+
+            # Write wrapper script that collects GPU metrics alongside inference.
+            # It runs as the srun payload so it executes on the compute node where
+            # the GPU lives. nvidia-smi is a system binary, available outside the
+            # squashfs venv. Task 0 owns metric collection to avoid conflicts in
+            # multi-task jobs. METRICS_DIR and INFERENCE_CMD_ARGS are propagated
+            # via Slurm's default --export=ALL env forwarding.
+            cat > "$METRICS_DIR/run_with_metrics.sh" << 'RUN_METRICS_EOF'
+            #!/bin/bash
+            set -euo pipefail
+            if [ "${{SLURM_PROCID:-0}}" = "0" ]; then
+                echo "$SLURM_JOB_ID" > "$METRICS_DIR/slurm_job_id"
+                nvidia-smi dmon -s pucvmet -d 5 -o DT \
+                    > "$METRICS_DIR/gpu_metrics.log" 2>/dev/null &
+                DMON_PID=$!
+                trap 'kill $DMON_PID 2>/dev/null; wait $DMON_PID 2>/dev/null' EXIT INT TERM
+            fi
+            anemoi-inference run config.yaml $INFERENCE_CMD_ARGS
+            RUN_METRICS_EOF
+            chmod +x "$METRICS_DIR/run_with_metrics.sh"
+
             squashfs-mount {params.image_path}:/user-environment -- bash -c '
                 source /user-environment/bin/activate
 
@@ -322,6 +344,31 @@ rule inference_execute:
                     CMD_ARGS+=(runner.parallel.cluster=slurm)
                 fi
 
+                export METRICS_DIR={params.workdir}
+                export INFERENCE_CMD_ARGS="${{CMD_ARGS[*]}}"
+
+                srun \
+                    --unbuffered \
+                    --partition={resources.slurm_partition} \
+                    --cpus-per-task={resources.cpus_per_task} \
+                    --mem-per-cpu={resources.mem_mb_per_cpu} \
+                    --time={resources.runtime} \
+                    --gres={resources.gres} \
+                    --ntasks={resources.ntasks} \
+                    bash "$METRICS_DIR/run_with_metrics.sh"
+            '
+
+            # Post-job: collect Slurm CPU/memory accounting once sacct catches up
+            if [ -f "$METRICS_DIR/slurm_job_id" ]; then
+                SLURM_JOB=$(cat "$METRICS_DIR/slurm_job_id")
+                sleep 5
+                sacct -j "$SLURM_JOB" \
+                    --parsable2 \
+                    --format=JobID,JobName,Elapsed,CPUTime,MaxRSS,MaxVMSize,AveRSS,MaxDiskRead,MaxDiskWrite \
+                    > "$METRICS_DIR/slurm_metrics.log" 2>/dev/null || true
+            fi
+
+        ) > {log} 2>&1
                 srun \
                     --unbuffered \
                     --partition={resources.slurm_partition} \
diff --git a/workflow/rules/report.smk b/workflow/rules/report.smk
index dd8ec121..d2ebed84 100644
--- a/workflow/rules/report.smk
+++ b/workflow/rules/report.smk
@@ -19,6 +19,62 @@ def make_header_text():
     return text
 
 
+def _candidate_gpu(run_cfg: dict) -> int:
+    """Return the GPU count for a run, defaulting to 1."""
+    ir = run_cfg.get("inference_resources")
+    if ir is None:
+        return 1
+    if isinstance(ir, dict):
+        return int(ir.get("gpu", 1) or 1)
+    return int(getattr(ir, "gpu", 1) or 1)
+
+
+rule collect_system_metrics:
+    input:
+        okfiles=[
+            OUT_ROOT / f"logs/inference_execute/{run_id}-{t.strftime('%Y%m%d%H%M')}.ok"
+            for run_id in RUN_CONFIGS
+            for t in REFTIMES
+        ],
+    output:
+        OUT_ROOT / "results/{experiment}/system_metrics.json",
+    localrule: True
+    params:
+        run_info=[
+            {
+                "workdir": str(
+                    (
+                        OUT_ROOT / f"data/runs/{run_id}/{t.strftime('%Y%m%d%H%M')}"
+                    ).resolve()
+                ),
+                "run_id": run_id,
+                "init_time": t.strftime("%Y%m%d%H%M"),
+            }
+            for run_id in RUN_CONFIGS
+            for t in REFTIMES
+        ],
+        label_map={
+            run_id: run_cfg.get("label", run_id)
+            for run_id, run_cfg in RUN_CONFIGS.items()
+        },
+        gpu_map={
+            run_id: _candidate_gpu(run_cfg) for run_id, run_cfg in RUN_CONFIGS.items()
+        },
+    run:
+        import json
+        from pathlib import Path
+        from diagnostics import parse_logs
+
+        records = parse_logs(
+            run_info=params.run_info,
+            label_map=params.label_map,
+            gpu_map=params.gpu_map,
+        )
+        out_path = Path(str(output[0]))
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(json.dumps(records, indent=2))
+
+
 rule report_experiment_dashboard:
     input:
         "src/verification/__init__.py",
@@ -27,6 +83,7 @@ rule report_experiment_dashboard:
         template="resources/report/dashboard/template.html.jinja2",
         js_script="resources/report/dashboard/script.js",
         configfile={workflow.configfiles[0]},
+        sysmetrics=OUT_ROOT / "results/{experiment}/system_metrics.json",
     output:
         report(
             directory(OUT_ROOT / "results/{experiment}/dashboard"),
@@ -48,6 +105,7 @@ rule report_experiment_dashboard:
             --header_text "{params.header_text}" \
             --configfile "{input.configfile}" \
             --stratification {params.stratification} \
+            --sysmetrics_file "{input.sysmetrics}" \
             --output {output} >{log} 2>&1
         """
 
diff --git a/workflow/scripts/parse_inference_logs.py b/workflow/scripts/parse_inference_logs.py
new file mode 100644
index 00000000..389df9a2
--- /dev/null
+++ b/workflow/scripts/parse_inference_logs.py
@@ -0,0 +1,47 @@
+"""CLI wrapper: parse anemoi-inference logs and write system metrics JSON."""
+
+import argparse
+import json
+import logging
+from pathlib import Path
+
+from diagnostics import parse_logs
+
+LOG = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+def main(args: argparse.Namespace) -> None:
+    records = parse_logs(
+        log_files=args.logs,
+        label_map=json.loads(args.label_map),
+        gpu_map=json.loads(args.gpu_map),
+        log_dir=args.log_dir,
+    )
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with open(out, "w") as fh:
+        json.dump(records, fh, indent=2)
+    LOG.info("Saved system metrics to %s", args.output)
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Parse inference logs for system metrics.")
+    p.add_argument("--logs", nargs="+", required=True, help="Inference log file paths.")
+    p.add_argument(
+        "--label_map", required=True, help="JSON dict mapping run_id → source label."
+    )
+    p.add_argument(
+        "--gpu_map",
+        default="{}",
+        help="JSON dict mapping run_id → GPU count (default: 1).",
+    )
+    p.add_argument(
+        "--log_dir",
+        required=True,
+        help="Root of inference_execute logs; used to extract run_id from file path.",
+    )
+    p.add_argument("--output", required=True, help="Output JSON file path.")
+    main(p.parse_args())
diff --git a/workflow/scripts/report_experiment_dashboard.py b/workflow/scripts/report_experiment_dashboard.py
index 414eb146..bdd46595 100644
--- a/workflow/scripts/report_experiment_dashboard.py
+++ b/workflow/scripts/report_experiment_dashboard.py
@@ -8,6 +8,8 @@
 import jinja2
 import xarray as xr
 
+from diagnostics import melt_for_dashboard
+
 _sys.path.append(str(Path(__file__).parent))
 from verification_plot_metrics import _ensure_unique_lead_time, _select_best_sources
 from verification import decode_metric
@@ -18,6 +20,21 @@
 )
 
 
+def _load_sysmetrics(sysmetrics_file: Path) -> tuple[str, list[str], list[str]]:
+    """Load system metrics JSON and melt to long format for Vega-Lite."""
+    if not sysmetrics_file or not sysmetrics_file.is_file():
+        return "[]", [], []
+    with open(sysmetrics_file) as fh:
+        records = _json.load(fh)
+    sysmetrics_json, sources, model_types = melt_for_dashboard(records)
+    LOG.info(
+        "Loaded system metrics for %d source(s), %d model type(s)",
+        len(sources),
+        len(model_types),
+    )
+    return sysmetrics_json, sources, model_types
+
+
 def program_summary_log(args):
     """Log a welcome message with the script and template information."""
     LOG.info("=" * 80)
@@ -115,6 +132,11 @@ def _sanitize(v):
     json_size = len(df_json.encode("utf-8"))
     LOG.info("Size of embedded JSON data: %d bytes", json_size)
 
+    # load system metrics
+    sysmetrics_json, sysmetrics_sources, sysmetrics_model_types = _load_sysmetrics(
+        args.sysmetrics_file
+    )
+
     # read script
     with open(args.script, "r") as f:
         js_src = f.read()
@@ -138,6 +160,9 @@ def _sanitize(v):
         configfile_content=open(args.configfile, "r").read()
         if args.configfile.is_file()
         else "",
+        sysmetrics_data=sysmetrics_json,
+        sysmetrics_sources=sysmetrics_sources,
+        sysmetrics_model_types=sysmetrics_model_types,
     )
     LOG.info("Size of generated HTML: %d bytes", len(html.encode("utf-8")))
 
@@ -186,6 +211,12 @@ def _sanitize(v):
         type=Path,
         help="Path to config file for the evalml run.",
     )
+    parser.add_argument(
+        "--sysmetrics_file",
+        type=Path,
+        default=None,
+        help="Path to system metrics JSON produced by parse_inference_logs.py.",
+    )
     parser.add_argument(
         "--output",
         type=Path,