diff --git a/.github/workflows/deploy-practice.yml b/.github/workflows/deploy-practice.yml
index 2d89a95..636354a 100644
--- a/.github/workflows/deploy-practice.yml
+++ b/.github/workflows/deploy-practice.yml
@@ -5,6 +5,9 @@ on:
     branches: [main]
     paths:
       - 'practice/**'
+      - 'certifications/**/practice-questions/**'
+      - 'certifications/**/mock-exam/**'
+      - 'certifications/**/mock-exam-2/**'
       - '.github/workflows/deploy-practice.yml'
   workflow_dispatch:
 
@@ -29,6 +32,15 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Rebuild question banks from current cert markdown
+        # Source of truth is certifications/**/{practice-questions,mock-exam,mock-exam-2}/*.md.
+        # We regenerate practice/data/*.json on every deploy so the live site
+        # always reflects the latest committed cert content, even if the
+        # author forgot to re-run build.py locally before pushing.
+        # build.py uses Python 3 stdlib only — no setup-python step needed
+        # because ubuntu-latest ships with python3 pre-installed.
+        run: python3 practice/build.py
+
       - name: Setup Pages
         uses: actions/configure-pages@v5
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f68f6e6..9398cb9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,55 @@ Notable changes to the Databricks Certification Study Guide.
 
 The format is loosely based on [Keep a Changelog](https://keepachangelog.com/). Dates use ISO 8601. Each section is grouped under the date the change shipped, with the Databricks exam-guide version each affected certification tracks.
 
+## [2026.05.21-24] — Mock exams in practice quiz + auto-rebuild on source edits (931 q / 18 banks)
+
+### Added
+
+- **12 mock exam banks** in the practice quiz — each cert now has two full-length, exam-feel mock banks alongside its topic-organised practice bank:
+
+  | Cert | Practice | Mock 1 | Mock 2 |
+  | :--- | :---: | :---: | :---: |
+  | Data Engineer Associate | 85 | 45 | 45 |
+  | Data Engineer Professional | 73 | 63 | 60 |
+  | Data Analyst Associate | 57 | 45 | 45 |
+  | ML Associate | 46 | 43 | 44 |
+  | ML Professional | 57 | 45 | 45 |
+  | GenAI Engineer Associate | 46 | 45 | 42 |
+  | **Total** | **364** | **286** | **281** |
+
+  Grand total: **931 questions across 18 banks**.
+
+- **Grouped bank picker** in the quiz UI: practice and mock banks render under labelled section headings ("Practice questions — drill by topic" and "Mock exams — full-length, exam-feel sets") so the user can choose intent before picking a cert. Two-column grid on screens ≥ 700 px wide.
+
+### Changed — `practice/build.py`
+
+- New `build_mock(cert, exam_n)` function parses `certifications/<cert>/resources/mock-exam{,-2}/questions.md`. Pre-scans the file linearly to map each `## Question N` heading to the most recent `## <Domain> (Questions X-Y)` domain section, then reuses the existing `parse_questions()` and overlays the per-question domain. Output JSON includes `kind: "mock"` and `sourceCert: <cert>` fields for downstream tooling.
+- New `--kind {practice,mock,all}` flag (default `all`) lets you build just one kind. `--cert <id>` still filters to a single cert across both kinds.
+
+### Changed — auto-rebuild + auto-deploy from cert markdown edits
+
+`.github/workflows/deploy-practice.yml` now:
+
+- Triggers on push to `main` whenever ANY of these change:
+  - `practice/**`
+  - `certifications/**/practice-questions/**`
+  - `certifications/**/mock-exam/**`
+  - `certifications/**/mock-exam-2/**`
+  - the workflow file itself
+- Runs `python3 practice/build.py` as a step before uploading the Pages artifact so the live JSON is always fresh from current cert markdown — no need to run `build.py` locally and re-commit before pushing.
+
+The committed `practice/data/*.json` files stay (for local dev convenience and quick PR diff review) but are no longer the source of truth at deploy time. Edit a question, push, the live site reflects it within ~1 min.
+
+### Changed — UI cache versioning
+
+`APP_VERSION` bumped to `"4"`. `<script src="app.js?v=4">` and `<link href="styles.css?v=4">` in `index.html`. JSON fetches pass through `bustedUrl()` to inherit the same version query so browsers don't serve stale banks after a deploy.
+
+### Verification
+
+- `python3 practice/build.py --check` → **18 banks / 931 questions** parsed cleanly
+- Practice = 364 q (unchanged from previous PR); Mock = 567 q across 12 new bank files
+- 4 mock-exam questions skipped due to multi-line-code-fence choices that the parser doesn't handle (same edge case as the practice banks; documented in `practice/README.md`)
+
 ## [2026.05.21-23] — Practice quiz polish: all 6 banks + theme + reset + branding + CI Node 24
 
 ### Added — all 6 certifications now have a question bank (364 questions total)
diff --git a/README.md b/README.md
index 017fcdf..1fd02c4 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ tags:
 > **These are the exam notes I built while preparing for the Databricks certification series.** Cheat sheets, practice questions, mock exams, and end-to-end worked examples — now open-sourced under MIT so the next person doesn't have to start from scratch. Every certification section maps to the current official Databricks exam guide for that credential. If it helped you, ⭐ the repo and pass it on.
 
 > [!tip]
-> **▶ [Try the practice quiz live](https://kengio.github.io/databricks-certification-study-guide/)** — adaptive multiple-choice quiz, **364 questions across all 6 cert tracks**, runs in your browser, progress saved locally. No install, no signup. Light/dark/auto theme + accessible reset.
+> **▶ [Try the practice quiz live](https://kengio.github.io/databricks-certification-study-guide/)** — adaptive multiple-choice quiz, **931 questions across 18 banks** (6 practice + 12 mock exams, all 6 cert tracks). Runs in your browser, progress saved locally. No install, no signup. Light/dark/auto theme + accessible reset.
 
 > [!info]
 > **Read in another language**: 🇹🇭 [ภาษาไทย](./i18n/th/README.md) (in progress) · For other languages and the translation policy, see [`TRANSLATING.md`](./TRANSLATING.md) and [`i18n/README.md`](./i18n/README.md).
@@ -411,7 +411,7 @@ This guide ships as a living resource. The roadmap below is what's planned for t
 - ✅ **Renewal guide** for candidates whose 2-year validity expires in 2027–2028 — complete (see [`shared/appendix/renewal-guide.md`](./shared/appendix/renewal-guide.md))
 - ✅ **Translation scaffolding** — Thai in-tree, other languages via fork model — complete (see [`TRANSLATING.md`](./TRANSLATING.md) + [`i18n/`](./i18n/README.md))
 - ✅ **Spaced-repetition deck (Anki)** — markdown-source decks + stdlib-only builder, two starter decks (Delta Lake 27 cards, Unity Catalog 22 cards) — complete (see [`anki/README.md`](./anki/README.md))
-- ✅ **Adaptive practice questions** — static-only web quiz with localStorage progress tracking + adaptive selector across **all 6 cert banks (364 questions)**. **Live at [kengio.github.io/databricks-certification-study-guide](https://kengio.github.io/databricks-certification-study-guide/)** — complete (see [`practice/README.md`](./practice/README.md))
+- ✅ **Adaptive practice questions** — static-only web quiz with localStorage progress tracking + adaptive selector. **18 banks / 931 questions** (6 practice topic banks + 12 mock exams, all 6 cert tracks). **Live at [kengio.github.io/databricks-certification-study-guide](https://kengio.github.io/databricks-certification-study-guide/)** — complete (see [`practice/README.md`](./practice/README.md))
 
 Legend: ✅ done · 🔄 in progress / next up · ⏳ planned · 🌱 ideas being explored
 
diff --git a/practice/README.md b/practice/README.md
index a2dea68..8b743df 100644
--- a/practice/README.md
+++ b/practice/README.md
@@ -21,16 +21,33 @@ A browser-based quiz for the practice-question markdown files in this repo. Trac
 
 ## Available banks
 
-All six certifications now have a question bank — **364 questions total**.
+**18 banks · 931 questions total** — every cert has practice questions plus two full-length mock exams.
 
-| Bank | Source files | Questions |
+### Practice questions (6 banks · 364 questions)
+
+Topic-organised question sets sourced from each cert's `practice-questions/` folder. Best for drilling a specific domain.
+
+| Bank | Source | Q |
+| :--- | :--- | :---: |
+| Data Engineer Associate | `certifications/data-engineer-associate/resources/practice-questions/` | 85 |
+| Data Engineer Professional | `certifications/data-engineer-professional/resources/practice-questions/` | 73 |
+| Data Analyst Associate | `certifications/data-analyst-associate/resources/practice-questions/` | 57 |
+| ML Associate | `certifications/ml-associate/resources/practice-questions/` | 46 |
+| ML Professional | `certifications/ml-professional/resources/practice-questions/` | 57 |
+| GenAI Engineer Associate | `certifications/genai-engineer-associate/resources/practice-questions/` | 46 |
+
+### Mock exams (12 banks · 567 questions)
+
+Full-length exam-feel sets sourced from each cert's `mock-exam/` and `mock-exam-2/` folders. Each is a single `questions.md` covering every domain. Best for end-to-end timing practice.
+
+| Cert | Mock 1 | Mock 2 |
 | :--- | :---: | :---: |
-| Data Engineer Associate | 5 markdown files in `certifications/data-engineer-associate/resources/practice-questions/` | 85 |
-| Data Engineer Professional | 8 markdown files | 73 |
-| Data Analyst Associate | 5 markdown files | 57 |
-| ML Associate | 4 markdown files | 46 |
-| ML Professional | 4 markdown files | 57 |
-| GenAI Engineer Associate | 4 markdown files | 46 |
+| Data Engineer Associate | 45 | 45 |
+| Data Engineer Professional | 63 | 60 |
+| Data Analyst Associate | 45 | 45 |
+| ML Associate | 43 | 44 |
+| ML Professional | 45 | 45 |
+| GenAI Engineer Associate | 45 | 42 |
 
 ## How to run
 
@@ -57,11 +74,21 @@ python3 -m http.server 8080 --directory practice
 
 ### Deploy (for fork maintainers)
 
-The deploy is driven by [`.github/workflows/deploy-practice.yml`](../.github/workflows/deploy-practice.yml). On every push to `main` that touches `practice/**`, the workflow:
+The deploy is driven by [`.github/workflows/deploy-practice.yml`](../.github/workflows/deploy-practice.yml). It runs on every push to `main` that touches **any of**:
+
+- `practice/**` (the quiz app itself)
+- `certifications/**/practice-questions/**` (source markdown for practice banks)
+- `certifications/**/mock-exam/**` or `mock-exam-2/**` (source markdown for mock banks)
+- `.github/workflows/deploy-practice.yml`
+
+The workflow:
 
 1. Checks out the repo
-2. Uploads `practice/` as a Pages artifact (with `.nojekyll` so HTML/JS pass through unmodified)
-3. Deploys via `actions/deploy-pages@v4`
+2. **Re-runs `python3 practice/build.py`** so `practice/data/*.json` is rebuilt fresh from current cert markdown — even if the author forgot to regenerate locally
+3. Uploads `practice/` as a Pages artifact (with `.nojekyll` so HTML/JS pass through unmodified)
+4. Deploys via `actions/deploy-pages@v4`
+
+**This means**: edit a question in `certifications/<cert>/resources/practice-questions/*.md` (or any mock-exam file), commit, push to `main`, and the live site updates within ~1 min. No need to run `build.py` locally before pushing — the committed JSON is just a convenience for local dev / quick PR review, not the source of truth at deploy time.
 
 **First-time setup** (only needed once per fork):
 
diff --git a/practice/app.js b/practice/app.js
index d93ec62..4b08514 100644
--- a/practice/app.js
+++ b/practice/app.js
@@ -26,21 +26,53 @@
 
   // Bump on every deploy that changes app.js / data/*.json. Appended to
   // bank-JSON fetch URLs so browsers don't serve stale banks after a deploy.
-  const APP_VERSION = "3";
+  const APP_VERSION = "35";
 
+  // Per-cert confetti palette. Pulled from the same gradients used on
+  // the cert picker cards (--gradient in styles.css) so the burst feels
+  // tied to "the cert you're studying", not a generic celebration. White
+  // is always included as a contrast accent.
+  const CERT_PALETTES = {
+    "data-engineer-associate":    ["#FF4F2C", "#FFAB1F", "#FFD27A", "#FF7A4F", "#FFFFFF"],
+    "data-engineer-professional": ["#6366F1", "#4F46E5", "#8B5CF6", "#A78BFA", "#FFFFFF"],
+    "data-analyst-associate":     ["#10B981", "#14B8A6", "#34D399", "#5EEAD4", "#FFFFFF"],
+    "ml-associate":               ["#A855F7", "#EC4899", "#C084FC", "#F472B6", "#FFFFFF"],
+    "ml-professional":            ["#F59E0B", "#DC2626", "#FBBF24", "#FB923C", "#FFFFFF"],
+    "genai-engineer-associate":   ["#06B6D4", "#3B82F6", "#22D3EE", "#60A5FA", "#FFFFFF"],
+  };
+
+  // Title patterns that are placeholder fallbacks (mock-exam questions whose
+  // source heading is `## Question N *(Difficulty)*` with no real title text).
+  // We suppress these in the post-submit "Topic" line so it doesn't read
+  // "Topic: Question 5" — useless context.
+  const FALLBACK_TITLE_RE = /^Question \d+(\.\d+)?$/i;
+
+  // Bank groups render as labelled sections in the picker.
+  const CERTS = [
+    "data-engineer-associate",
+    "data-engineer-professional",
+    "data-analyst-associate",
+    "ml-associate",
+    "ml-professional",
+    "genai-engineer-associate",
+  ];
   const KNOWN_BANKS = [
-    { cert: "data-engineer-associate", file: "data/data-engineer-associate.json" },
-    { cert: "data-engineer-professional", file: "data/data-engineer-professional.json" },
-    { cert: "data-analyst-associate", file: "data/data-analyst-associate.json" },
-    { cert: "ml-associate", file: "data/ml-associate.json" },
-    { cert: "ml-professional", file: "data/ml-professional.json" },
-    { cert: "genai-engineer-associate", file: "data/genai-engineer-associate.json" },
+    ...CERTS.map(c => ({ cert: c, file: `data/${c}.json`, group: "practice" })),
+    ...CERTS.map(c => ({ cert: `${c}-mock-1`, file: `data/${c}-mock-1.json`, group: "mock" })),
+    ...CERTS.map(c => ({ cert: `${c}-mock-2`, file: `data/${c}-mock-2.json`, group: "mock" })),
   ];
+  const GROUP_LABELS = {
+    practice: "Practice questions — drill by topic, adaptive selector",
+    mock: "Mock exams — full-length, exam-feel sets",
+  };
 
   const STORAGE_PREFIX = "dbx-practice-";
+  const SESSION_HISTORY_PREFIX = "dbx-practice-sessions-";   // per-bank completed-session log
+  const SESSION_HISTORY_CAP = 50;                             // ring-buffer cap per bank
   const THEME_KEY = "dbx-practice-theme";
+  const TIMER_KEY = "dbx-practice-timer-minutes";
+  const PASS_THRESHOLD = 70;                                  // % to pass a Databricks mock exam
   const THEMES = ["auto", "light", "dark"];
-  const THEME_ICONS = { auto: "🖥️", light: "☀️", dark: "🌙" };
   const STATE = {
     bank: null,
     history: {},
@@ -55,6 +87,19 @@
       difficulty: "",
     },
     sequentialIndex: 0,
+    certBanks: null,
+    streak: 0,
+    bestStreak: 0,     // highest streak achieved this session — for the summary card
+    timerMinutes: 0,   // 0 = no timer; >0 = exam timer total length in minutes
+    timerEnd: null,    // absolute epoch ms when the timer expires, or null
+    timerExpired: false,
+    sessionStart: null,    // epoch ms when this session of answering began
+    sessionElapsed: null,  // frozen elapsed-ms snapshot at completion time
+    summarySaved: false,   // guard so the completed-session record is written exactly once
+    timerPaused: false,    // true while the user has the timer on hold
+    pausedRemainingMs: null,  // ms left on the exam timer when pause started
+    totalPausedMs: 0,      // accumulated pause time (subtracted from elapsed for summary)
+    pauseStart: null,      // epoch ms when the current pause began
   };
 
   // --- DOM helpers ---------------------------------------------------------
@@ -88,9 +133,34 @@
   const clear = (node) => { while (node.firstChild) node.removeChild(node.firstChild); };
 
   function show(sectionId) {
-    for (const id of ["setup", "quiz", "stats", "settings"]) {
+    for (const id of ["setup", "quiz", "stats", "settings", "summary"]) {
       $("#" + id).hidden = id !== sectionId;
     }
+    // Sticky bottom actionbar + masthead quiz-meta-strip belong to the quiz
+    // section only; hide them everywhere else.
+    const inQuiz = sectionId === "quiz";
+    const actionbar = $("#actionbar");
+    const metaStrip = $("#quiz-meta-strip");
+    if (actionbar) actionbar.hidden = !inQuiz;
+    if (metaStrip) metaStrip.hidden = !inQuiz;
+    document.body.classList.toggle("quiz-active", inQuiz);
+    syncActionbarHeight();
+  }
+
+  // Keep `--actionbar-h` CSS var in sync with the actionbar's actual
+  // rendered height. The actionbar wraps onto multiple rows when content
+  // doesn't fit; if we hard-coded padding-bottom on main, the last
+  // explanation line would get hidden under the bar.
+  function syncActionbarHeight() {
+    const ab = $("#actionbar");
+    if (!ab || ab.hidden) {
+      document.body.style.removeProperty("--actionbar-h");
+      return;
+    }
+    const h = ab.getBoundingClientRect().height;
+    if (h > 0) {
+      document.body.style.setProperty("--actionbar-h", h + "px");
+    }
   }
 
   // --- Safe markdown → DOM rendering --------------------------------------
@@ -123,15 +193,15 @@
 
   const FENCE_OPEN_RE = /^\s*```(\w*)\s*$/;
   const FENCE_CLOSE_RE = /^\s*```\s*$/;
+  const PRISM_KNOWN_LANGS = new Set(["python", "sql", "scala", "javascript", "json", "bash"]);
 
   function renderMarkdown(s) {
     const frag = document.createDocumentFragment();
     const lines = s.split("\n");
     let buffer = [];
+    const pendingHighlights = [];  // <code> nodes to syntax-highlight after insertion
 
     const flushParagraphs = () => {
-      // `buffer` is a slab of lines; split it into paragraphs by blank lines
-      // and render each as a <p> with inline formatting + <br> for newlines.
       let para = [];
       const emit = () => {
         if (para.length === 0) return;
@@ -156,17 +226,25 @@
       const fence = lines[i].match(FENCE_OPEN_RE);
       if (fence) {
         flushParagraphs();
+        const lang = (fence[1] || "").toLowerCase();
         const codeLines = [];
         i++;
         while (i < lines.length && !FENCE_CLOSE_RE.test(lines[i])) {
           codeLines.push(lines[i]);
           i++;
         }
-        // Skip the closing fence (if present)
-        if (i < lines.length) i++;
+        if (i < lines.length) i++;  // skip closing fence
+
         const code = el("code");
         code.textContent = codeLines.join("\n");
+        if (lang && PRISM_KNOWN_LANGS.has(lang)) {
+          code.className = "language-" + lang;
+          pendingHighlights.push(code);
+        }
         const pre = el("pre");
+        if (lang && PRISM_KNOWN_LANGS.has(lang)) {
+          pre.className = "language-" + lang;
+        }
         pre.appendChild(code);
         frag.appendChild(pre);
         continue;
@@ -175,6 +253,16 @@
       i++;
     }
     flushParagraphs();
+
+    // Run Prism.highlightElement after each code block is in the fragment.
+    // Prism reads textContent on the node, so the node needs to exist (it does,
+    // inside the fragment) but doesn't need to be in the live DOM yet.
+    if (window.Prism && pendingHighlights.length) {
+      for (const code of pendingHighlights) {
+        try { window.Prism.highlightElement(code); }
+        catch (_) { /* Prism failure shouldn't break the quiz */ }
+      }
+    }
     return frag;
   }
 
@@ -190,15 +278,29 @@
     return file + (file.includes("?") ? "&" : "?") + "v=" + APP_VERSION;
   }
 
-  async function probeBanks() {
-    const available = [];
-    for (const b of KNOWN_BANKS) {
+  async function loadAllBankMetadata() {
+    // Fetch every known bank's JSON in parallel; group by sourceCert.
+    // Returns Map<certId, [{bank, data}, ...]> preserving CERTS order.
+    const results = await Promise.all(KNOWN_BANKS.map(async (b) => {
       try {
-        const res = await fetch(bustedUrl(b.file), { method: "HEAD", cache: "no-cache" });
-        if (res.ok) available.push(b);
-      } catch (_) { /* file missing — skip */ }
+        const res = await fetch(bustedUrl(b.file), { cache: "no-cache" });
+        if (!res.ok) return null;
+        const data = await res.json();
+        return { bank: b, data };
+      } catch (_) { return null; }
+    }));
+    const byCert = new Map();
+    for (const c of CERTS) byCert.set(c, []);
+    for (const r of results) {
+      if (!r) continue;
+      const sourceCert = r.data.sourceCert || r.data.cert;
+      if (byCert.has(sourceCert)) byCert.get(sourceCert).push(r);
     }
-    return available;
+    // Drop certs with no available banks
+    for (const c of CERTS) {
+      if (byCert.get(c).length === 0) byCert.delete(c);
+    }
+    return byCert;
   }
 
   async function loadBank(certInfo) {
@@ -207,33 +309,130 @@
     const data = await res.json();
     STATE.bank = data;
     STATE.history = loadHistory(data.cert);
+    // Fresh session bookkeeping every time we enter a bank — needed for
+    // the summary screen (elapsed time + average per Q + best streak).
+    STATE.sessionCorrect = 0;
+    STATE.sessionTotal = 0;
+    STATE.seenThisSession.clear();
+    STATE.streak = 0;
+    STATE.bestStreak = 0;
+    STATE.sessionStart = null;
+    STATE.sessionElapsed = null;
+    STATE.summarySaved = false;
+    if (STATE.timerMinutes > 0) {
+      startTimer(STATE.timerMinutes);    // also sets sessionStart
+      updateClockAndTimer();
+    }
     populateSettings();
     renderQuiz();
     show("quiz");
   }
 
-  function renderSetup(available) {
+  function bankTypeLabel(item) {
+    if (item.data.kind === "mock") {
+      const m = item.data.certTitle.match(/—\s*(Mock Exam \d+)/i);
+      return m ? m[1] : "Mock Exam";
+    }
+    return "Practice questions";
+  }
+
+  function bankTypeSubtitle(item) {
+    return item.data.kind === "mock"
+      ? "full-length · all domains"
+      : "drill by topic · adaptive";
+  }
+
+  // --- Step 1: certification picker ----------------------------------------
+
+  function renderCertPicker(certBanks) {
     const setup = $("#setup");
     clear(setup);
-    setup.appendChild(el("h2", {}, "Pick a question bank"));
-    if (available.length === 0) {
+
+    setup.appendChild(el("p", { className: "eyebrow" }, "Practice quiz"));
+    setup.appendChild(el("h2", {}, "Pick a certification"));
+    setup.appendChild(el("p", { className: "lead" },
+      "Drill by topic, take a full-length mock exam, or resume where you left off. " +
+      "Progress is stored locally — nothing leaves your browser."));
+
+    if (certBanks.size === 0) {
       const p = el("p", {}, "No JSON banks found under practice/data/. Run ");
       p.appendChild(el("code", {}, "python3 practice/build.py"));
       p.appendChild(document.createTextNode(" first."));
       setup.appendChild(p);
       return;
     }
+
+    const list = el("div", { className: "cert-list" });
+    for (const [certKey, items] of certBanks) {
+      // Use the practice bank for cert metadata; fall back to first available
+      const practice = items.find(it => it.data.kind !== "mock") || items[0];
+      const title = practice.data.certTitle.replace(/\s*—\s*Mock Exam \d+$/i, "");
+      const blueprint = practice.data.blueprintVersion;
+      const totalQ = items.reduce((sum, it) => sum + it.data.questions.length, 0);
+      const bankCount = items.length;
+      const mockCount = items.filter(it => it.data.kind === "mock").length;
+
+      // data-cert is the key: it activates the per-cert gradient defined
+      // in styles.css (.cert-card[data-cert="..."] { --gradient: ... }).
+      // Without this, every card defaulted to the orange/yellow fallback.
+      const card = el("button", { type: "button", className: "cert-card",
+                                  dataset: { cert: certKey },
+                                  onclick: () => renderBankPicker(certKey, items) });
+      card.appendChild(el("span", { className: "cert-card-arrow",
+                                    "aria-hidden": "true" }, "→"));
+      card.appendChild(el("strong", {}, title));
+
+      // Big-numeral stat: the headline number is "total questions",
+      // which is the metric the user actually cares about at this step.
+      const stats = el("div", { className: "cert-card-stats" });
+      stats.appendChild(el("span", { className: "stat-num" }, String(totalQ)));
+      stats.appendChild(el("span", { className: "stat-label" },
+        `questions across\n${bankCount} bank${bankCount !== 1 ? "s" : ""}`));
+      card.appendChild(stats);
+
+      card.appendChild(el("div", { className: "cert-card-meta" },
+        mockCount > 0
+          ? `Practice + ${mockCount} mock exam${mockCount !== 1 ? "s" : ""}`
+          : "Practice bank"));
+      card.appendChild(el("div", { className: "cert-card-blueprint" },
+        `Blueprint ${blueprint}`));
+      list.appendChild(card);
+    }
+    setup.appendChild(list);
+  }
+
+  // --- Step 2: bank picker (per cert) --------------------------------------
+
+  function renderBankPicker(certKey, items) {
+    const setup = $("#setup");
+    clear(setup);
+
+    const practice = items.find(it => it.data.kind !== "mock") || items[0];
+    const title = practice.data.certTitle.replace(/\s*—\s*Mock Exam \d+$/i, "");
+
+    setup.appendChild(el("button", { type: "button", className: "back-button",
+                                     onclick: () => renderCertPicker(STATE.certBanks) },
+      "← All certifications"));
+    setup.appendChild(el("h2", {}, title));
+    setup.appendChild(el("p", { className: "cert-subtitle" },
+      `Blueprint ${practice.data.blueprintVersion}`));
+
+    // Sort items: practice first, then mock-1, then mock-2
+    const sorted = [...items].sort((a, b) => {
+      const order = it => it.data.kind === "mock" ? (it.data.cert.endsWith("-mock-2") ? 2 : 1) : 0;
+      return order(a) - order(b);
+    });
+
     const list = el("div", { className: "bank-list" });
-    for (const b of available) {
-      const button = el("button", { type: "button", className: "bank-card",
-                                    onclick: () => loadBank(b) }, b.cert);
-      fetch(bustedUrl(b.file), { cache: "no-cache" }).then(r => r.json()).then(d => {
-        clear(button);
-        button.appendChild(el("strong", {}, d.certTitle || d.cert));
-        button.appendChild(el("div", { className: "bank-meta" },
-          `${d.questions.length} questions · ${d.domains.length} domains · blueprint ${d.blueprintVersion}`));
-      }).catch(() => { /* keep fallback text */ });
-      list.appendChild(button);
+    for (const it of sorted) {
+      const card = el("button", { type: "button", className: "bank-card",
+                                  onclick: () => loadBank(it.bank) });
+      card.appendChild(el("strong", {}, bankTypeLabel(it)));
+      card.appendChild(el("div", { className: "bank-meta" },
+        `${it.data.questions.length} questions · ${it.data.domains.length} domains`));
+      card.appendChild(el("div", { className: "bank-purpose" },
+        bankTypeSubtitle(it)));
+      list.appendChild(card);
     }
     setup.appendChild(list);
   }
@@ -329,6 +528,14 @@
   // --- Rendering -----------------------------------------------------------
 
   function renderQuiz() {
+    // Bank-complete short-circuit: if the user has visited every question
+    // in the (filtered) bank and answered at least one, show the summary
+    // screen instead of looping back to the start.
+    if (isSessionComplete()) {
+      renderSummary();
+      show("summary");
+      return;
+    }
     const q = pickNext();
     if (!q) {
       $("#quiz-question").textContent = "No questions match your filters.";
@@ -337,10 +544,33 @@
     }
     STATE.currentQ = q;
     STATE.currentChoice = null;
+    // Defensive: blur any leftover focus from the previous question so
+    // a residual :focus-within / :hover style doesn't carry over to a
+    // choice in the new question (which would look like a stuck selection).
+    if (document.activeElement
+        && document.activeElement !== document.body
+        && typeof document.activeElement.blur === "function") {
+      try { document.activeElement.blur(); } catch (_) { /* no-op */ }
+    }
+    // Re-trigger the slide-in animation on every render. The Q-header
+    // (counter + difficulty) animates alongside the card so the whole
+    // row reads as one unit arriving from the right.
+    for (const sel of [".question-header", ".question-card"]) {
+      const node = document.querySelector(sel);
+      if (!node) continue;
+      node.classList.remove("slide-in");
+      void node.offsetWidth;   // force reflow so animation restarts
+      node.classList.add("slide-in");
+    }
 
     $("#quiz-cert").textContent = STATE.bank.certTitle;
     $("#quiz-counter").textContent =
       `Q${STATE.seenThisSession.size} this session · ${STATE.sessionCorrect}/${STATE.sessionTotal} correct`;
+    // Faded "Q.N" watermark in the card's top-right (decoration only).
+    const watermark = $("#quiz-watermark");
+    if (watermark) {
+      watermark.textContent = "Q." + STATE.seenThisSession.size;
+    }
     const domain = STATE.bank.domains.find(d => d.id === q.domain);
     $("#quiz-domain").textContent = domain ? domain.name : q.domain;
     const diff = $("#quiz-difficulty");
@@ -359,25 +589,29 @@
     const choices = $("#quiz-choices");
     clear(choices);
     for (const letter of ["A", "B", "C", "D"]) {
+      const num = LETTER_TO_NUM[letter];
       const radio = el("input", { type: "radio", name: "choice", value: letter,
                                    onchange: () => {
                                      STATE.currentChoice = letter;
                                      $("#btn-submit").disabled = false;
                                    } });
-      const choiceTextSpan = el("span");
+      const choiceTextSpan = el("span", { className: "choice-text" });
       choiceTextSpan.appendChild(renderInlineToFragment(q.choices[letter]));
       const label = el("label", { dataset: { letter } },
         radio,
-        el("span", { className: "choice-letter" }, letter + ")"),
-        document.createTextNode(" "),
+        el("span", { className: "choice-letter" }, num),
         choiceTextSpan);
       choices.appendChild(label);
     }
 
     $("#btn-submit").hidden = false;
     $("#btn-submit").disabled = true;
+    $("#btn-skip").hidden = false;
     $("#btn-next").hidden = true;
     $("#quiz-feedback").hidden = true;
+    const preHint = $("#kbd-hint-pre"), postHint = $("#kbd-hint-post");
+    if (preHint) preHint.hidden = false;
+    if (postHint) postHint.hidden = true;
     updateSessionBar();
   }
 
@@ -396,35 +630,154 @@
       `Bank: ${attempted} / ${total} attempted · ${correctAll} currently correct on most-recent attempt`;
   }
 
+  function showStreakToast(n) {
+    const existing = document.querySelector(".streak-toast");
+    if (existing) existing.remove();
+    const toast = el("div", { className: "streak-toast" },
+      el("span", { className: "streak-num" }, String(n)),
+      "in a row · keep going");
+    document.body.appendChild(toast);
+    // Force reflow then trigger animation
+    void toast.offsetWidth;
+    toast.classList.add("show");
+    setTimeout(() => toast.remove(), 1800);
+  }
+
+  function showFloatPlus(label) {
+    const plus = el("span", { className: "float-plus" }, "+1");
+    label.style.position = label.style.position || "relative";
+    label.appendChild(plus);
+    setTimeout(() => plus.remove(), 1200);
+  }
+
+  // Zero-dependency confetti burst — 40 particles in random colors, each
+  // following a parabolic arc with rotation. Origin is the centre of the
+  // chosen correct-answer label so the burst feels like it comes from that
+  // row. Auto-skipped when prefers-reduced-motion: reduce is set.
+  function fireConfetti(originEl) {
+    if (window.matchMedia
+        && window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+      return;
+    }
+    const rect = originEl.getBoundingClientRect();
+    const ox = rect.left + rect.width / 2;
+    const oy = rect.top + rect.height / 2;
+
+    // Pick the palette for the cert the user is currently studying so
+    // the burst reads as "the cert's colours celebrating", not a
+    // generic candy-mix.
+    const sourceCert = (STATE.bank && (STATE.bank.sourceCert || STATE.bank.cert)) || "";
+    const baseCert = sourceCert.replace(/-mock-\d+$/i, "");
+    const colors = CERT_PALETTES[baseCert] || [
+      "#FF4F2C", "#FFAB1F", "#10B981", "#14B8A6",
+      "#3B82F6", "#6366F1", "#A855F7", "#EC4899",
+      "#F59E0B", "#FFFFFF",
+    ];
+    const N = 40;
+    const container = document.createElement("div");
+    container.className = "confetti-container";
+
+    for (let i = 0; i < N; i++) {
+      const p = document.createElement("span");
+      p.className = "confetti-particle";
+
+      // Mostly-upward initial direction with wide horizontal spread
+      const angle = -Math.PI / 2 + (Math.random() - 0.5) * Math.PI * 1.3;
+      const speed = 160 + Math.random() * 200;
+      const dx = Math.cos(angle) * speed;
+      const dy = Math.sin(angle) * speed;
+      // Midpoint of parabola (apex)
+      const midDx = dx * 0.65;
+      const midDy = dy * 0.85;
+      // Final position: initial horizontal + gravity fall
+      const endDx = dx;
+      const endDy = dy + 380 + Math.random() * 220;
+      const rot = (Math.random() - 0.5) * 720;
+
+      p.style.left = ox + "px";
+      p.style.top = oy + "px";
+      p.style.background = colors[Math.floor(Math.random() * colors.length)];
+      // Vary particle shape so it doesn't all look identical
+      if (Math.random() < 0.3) {
+        p.style.borderRadius = "50%";
+        p.style.width = "8px"; p.style.height = "8px";
+      }
+      p.style.setProperty("--mid-dx", midDx + "px");
+      p.style.setProperty("--mid-dy", midDy + "px");
+      p.style.setProperty("--end-dx", endDx + "px");
+      p.style.setProperty("--end-dy", endDy + "px");
+      p.style.setProperty("--rot", rot + "deg");
+      p.style.animationDelay = (Math.random() * 80) + "ms";
+
+      container.appendChild(p);
+    }
+
+    document.body.appendChild(container);
+    setTimeout(() => container.remove(), 2000);
+  }
+
   function submitAnswer() {
     if (!STATE.currentChoice) return;
     const q = STATE.currentQ;
     const correct = STATE.currentChoice === q.correctAnswer;
     recordAttempt(q.id, correct);
     STATE.sessionTotal++;
-    if (correct) STATE.sessionCorrect++;
+    if (correct) {
+      STATE.sessionCorrect++;
+      STATE.streak++;
+      if (STATE.streak > STATE.bestStreak) STATE.bestStreak = STATE.streak;
+    } else {
+      STATE.streak = 0;
+    }
 
+    let correctLabel = null;
     for (const label of $("#quiz-choices").children) {
       const letter = label.dataset.letter;
       const radio = label.querySelector("input");
       radio.disabled = true;
       label.classList.add("disabled");
-      if (letter === q.correctAnswer) label.classList.add("correct");
-      else if (letter === STATE.currentChoice && !correct) label.classList.add("incorrect");
+      if (letter === q.correctAnswer) {
+        label.classList.add("correct");
+        correctLabel = label;
+      } else if (letter === STATE.currentChoice && !correct) {
+        label.classList.add("incorrect");
+      }
+    }
+
+    // Card-level flash + optional rewards
+    const card = document.querySelector(".question-card");
+    if (card) {
+      card.classList.remove("flash-correct", "flash-incorrect");
+      void card.offsetWidth;  // restart animation
+      card.classList.add(correct ? "flash-correct" : "flash-incorrect");
+      setTimeout(() => card.classList.remove("flash-correct", "flash-incorrect"), 700);
+    }
+    if (correct && correctLabel) {
+      showFloatPlus(correctLabel);
+      fireConfetti(correctLabel);
+      // Toast at 3, 5, 7, 10, every 5 thereafter
+      if (STATE.streak === 3 || STATE.streak === 5 || STATE.streak === 7
+          || STATE.streak === 10 || (STATE.streak > 10 && STATE.streak % 5 === 0)) {
+        showStreakToast(STATE.streak);
+      }
     }
 
     const fb = $("#quiz-feedback");
     fb.hidden = false;
     fb.className = correct ? "correct" : "incorrect";
     clear(fb);
+    const correctNum = LETTER_TO_NUM[q.correctAnswer] || q.correctAnswer;
     fb.appendChild(el("h4", {},
-      correct ? "✓ Correct" : `✗ Incorrect — correct answer: ${q.correctAnswer}`));
-    if (q.title) {
+      correct ? "✓ Correct" : `✗ Incorrect · Correct answer: ${correctNum}`));
+    // Suppress the Topic line when the title is a placeholder fallback
+    // ("Question 5") — the running head already shows the domain, which is
+    // the meaningful context for mock-exam questions.
+    if (q.title && !FALLBACK_TITLE_RE.test(q.title)) {
       fb.appendChild(el("p", { className: "fb-topic" },
-        el("strong", {}, "Topic: "), q.title));
+        "Topic — ", q.title));
     }
     if (q.shortAnswer) {
-      const p = el("p");
+      const p = el("p", { className: "fb-short" });
       p.appendChild(renderInlineToFragment(q.shortAnswer));
       fb.appendChild(p);
     }
@@ -433,10 +786,23 @@
     }
 
     $("#btn-submit").hidden = true;
+    $("#btn-skip").hidden = true;
     $("#btn-next").hidden = false;
+    const preHint = $("#kbd-hint-pre"), postHint = $("#kbd-hint-post");
+    if (preHint) preHint.hidden = true;
+    if (postHint) postHint.hidden = false;
     updateSessionBar();
   }
 
+  // Skip — moves to the next question without recording an attempt.
+  // The question is added to seenThisSession so it doesn't immediately repeat,
+  // but in adaptive mode it'll come back in a future session.
+  function skipQuestion() {
+    // Don't double-fire if already past submit
+    if ($("#btn-next").hidden === false) return;
+    renderQuiz();
+  }
+
   // --- Stats view ----------------------------------------------------------
 
   function renderStats() {
@@ -501,6 +867,31 @@
       }
       c.appendChild(ul);
     }
+
+    // Past attempts on this bank — clickable rows reopen each summary
+    const past = loadSessionHistory(STATE.bank.cert).slice().reverse();
+    if (past.length > 0) {
+      const headRow = el("div", { className: "stats-history-head" });
+      headRow.appendChild(el("h3", { style: "margin:2rem 0 0.75rem" },
+        `Past attempts (${past.length})`));
+      headRow.appendChild(el("button", { type: "button", className: "link danger",
+        onclick: () => clearSessionHistoryConfirm(STATE.bank.cert) }, "Clear history"));
+      c.appendChild(headRow);
+      c.appendChild(renderAttemptList(past));
+    }
+  }
+
+  async function clearSessionHistoryConfirm(certKey) {
+    const ok = await customConfirm({
+      title: "Clear attempt history?",
+      message: `This removes every saved completed-session record for this bank. Your in-progress per-question history isn't affected.`,
+      confirmLabel: "Clear history",
+      cancelLabel: "Cancel",
+      danger: true,
+    });
+    if (!ok) return;
+    clearSessionHistoryForCert(certKey);
+    renderStats();
   }
 
   function exportProgress() {
@@ -518,8 +909,15 @@
     URL.revokeObjectURL(url);
   }
 
-  function resetHistory() {
-    if (!confirm(`Reset all progress for "${STATE.bank.certTitle}"? This can't be undone.`)) return;
+  async function resetHistory() {
+    const ok = await customConfirm({
+      title: "Reset all progress?",
+      message: `This erases your saved attempts and accuracy for “${STATE.bank.certTitle}”. This can't be undone — but the questions themselves stay available.`,
+      confirmLabel: "Reset progress",
+      cancelLabel: "Cancel",
+      danger: true,
+    });
+    if (!ok) return;
     STATE.history = {};
     STATE.seenThisSession.clear();
     STATE.sessionCorrect = 0;
@@ -528,6 +926,550 @@
     renderStats();
   }
 
+  // --- Session summary + history ------------------------------------------
+  //
+  // When the user has visited every question in the (filtered) bank and
+  // answered at least one, renderQuiz redirects to the summary screen
+  // instead of looping back. The summary screen:
+  //   • shows overall score + per-domain breakdown + weak-area callout
+  //   • includes time stats ONLY when a timer was running
+  //   • persists a record of the completed attempt to localStorage so the
+  //     user can compare attempts over time
+  //   • lets the user export the attempt as a printable HTML report or CSV
+  //
+  // Each bank keeps its own ring buffer of completed sessions under
+  // `dbx-practice-sessions-<cert>` (cap = SESSION_HISTORY_CAP).
+
+  function isSessionComplete() {
+    const total = filteredQuestions().length;
+    if (total === 0) return false;
+    return STATE.seenThisSession.size >= total && STATE.sessionTotal > 0;
+  }
+
+  function loadSessionHistory(certKey) {
+    try {
+      const raw = localStorage.getItem(SESSION_HISTORY_PREFIX + certKey);
+      if (!raw) return [];
+      const arr = JSON.parse(raw);
+      return Array.isArray(arr) ? arr : [];
+    } catch (_) { return []; }
+  }
+
+  function saveSessionRecord(record) {
+    try {
+      const list = loadSessionHistory(record.cert);
+      list.push(record);
+      while (list.length > SESSION_HISTORY_CAP) list.shift();
+      localStorage.setItem(SESSION_HISTORY_PREFIX + record.cert, JSON.stringify(list));
+    } catch (e) { console.warn("Failed to save session record:", e); }
+  }
+
+  function clearSessionHistoryForCert(certKey) {
+    try { localStorage.removeItem(SESSION_HISTORY_PREFIX + certKey); }
+    catch (_) { /* ignore */ }
+  }
+
+  function buildSessionRecord() {
+    const pct = STATE.sessionTotal === 0 ? 0
+              : Math.round((STATE.sessionCorrect / STATE.sessionTotal) * 100);
+    const isMock = STATE.bank.kind === "mock";
+    const domains = STATE.bank.domains.map(d => {
+      const qs = STATE.bank.questions.filter(q => q.domain === d.id);
+      const answered = qs.filter(q =>
+        STATE.seenThisSession.has(q.id)
+        && (STATE.history[q.id]?.attempts.length || 0) > 0);
+      const correct = answered.filter(q => {
+        const last = STATE.history[q.id].attempts.slice(-1)[0];
+        return last && last.correct;
+      });
+      return {
+        id: d.id,
+        name: d.name,
+        total: answered.length,
+        correct: correct.length,
+        pct: answered.length === 0 ? null
+           : Math.round((correct.length / answered.length) * 100),
+      };
+    });
+    return {
+      id: Date.now(),
+      ts: Date.now(),
+      cert: STATE.bank.cert,
+      certTitle: STATE.bank.certTitle,
+      isMock,
+      total: STATE.sessionTotal,
+      correct: STATE.sessionCorrect,
+      pct,
+      durationMs: STATE.sessionElapsed,
+      avgPerQMs: STATE.sessionElapsed && STATE.sessionTotal > 0
+                ? Math.round(STATE.sessionElapsed / STATE.sessionTotal) : null,
+      bestStreak: STATE.bestStreak,
+      passed: isMock ? pct >= PASS_THRESHOLD : null,
+      threshold: isMock ? PASS_THRESHOLD : null,
+      domains,
+    };
+  }
+
+  function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0) return "—";
+    const totalSec = Math.round(ms / 1000);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor((totalSec % 3600) / 60);
+    const s = totalSec % 60;
+    if (h > 0) {
+      return h + ":" + String(m).padStart(2, "0") + ":" + String(s).padStart(2, "0");
+    }
+    return String(m).padStart(2, "0") + ":" + String(s).padStart(2, "0");
+  }
+
+  function formatDateTime(ts) {
+    const d = new Date(ts);
+    const date = d.toLocaleDateString(undefined, {
+      year: "numeric", month: "short", day: "2-digit",
+    });
+    const time = d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12: false });
+    return { date, time, full: date + " · " + time };
+  }
+
+  // Toneband for a percentage. Used for verdict text + meter colors.
+  function toneFor(pct) {
+    if (pct == null) return "muted";
+    if (pct >= 90) return "great";
+    if (pct >= 80) return "good";
+    if (pct >= PASS_THRESHOLD) return "good";
+    if (pct >= 60) return "warn";
+    if (pct >= 40) return "warn";
+    return "weak";
+  }
+
+  function getVerdict(record) {
+    const pct = record.pct;
+    if (record.isMock) {
+      return {
+        title: record.passed ? "PASS" : "BELOW PASSING",
+        sub: `Passing threshold: ${record.threshold}%`,
+        tone: record.passed ? "good" : "weak",
+      };
+    }
+    if (pct === 100) return { title: "Perfect score", sub: "Every question correct", tone: "great" };
+    if (pct >= 90)   return { title: "Excellent",      sub: "Mastery level",          tone: "great" };
+    if (pct >= 80)   return { title: "Great work",     sub: "Strong understanding",   tone: "good"  };
+    if (pct >= 70)   return { title: "Solid",          sub: "Above the typical bar",  tone: "good"  };
+    if (pct >= 60)   return { title: "Getting close",  sub: "Review your weak areas", tone: "warn"  };
+    if (pct >= 40)   return { title: "Keep practicing", sub: "Focus on the gaps below", tone: "warn"  };
+    return                  { title: "More practice needed", sub: "Start with the weakest module", tone: "weak"  };
+  }
+
+  // Weak areas = domains attempted with pct strictly below 70% (the
+  // Databricks passing line), sorted by pct ascending so the most
+  // urgent gap is first. "Not attempted" domains are excluded.
+  function getWeakDomains(domains) {
+    return domains
+      .filter(d => d.pct != null && d.pct < PASS_THRESHOLD)
+      .sort((a, b) => a.pct - b.pct);
+  }
+
+  function metricBlock(label, value, sub) {
+    const node = el("div", { className: "summary-metric" });
+    node.appendChild(el("div", { className: "summary-metric-label" }, label));
+    node.appendChild(el("div", { className: "summary-metric-value" }, value));
+    if (sub) node.appendChild(el("div", { className: "summary-metric-sub" }, sub));
+    return node;
+  }
+
+  // record:    a session record. If omitted, builds from current STATE +
+  //            persists it (live mode).
+  // opts.past: true → render in "viewing past attempt" mode (different
+  //            action buttons; no confetti).
+  function renderSummary(record, opts) {
+    opts = opts || {};
+    let data;
+    if (record) {
+      data = record;
+    } else {
+      // Freeze elapsed time at completion. Subtract paused time so the
+      // figure reflects effort, not wall-clock.
+      if (STATE.sessionElapsed == null && STATE.sessionStart != null) {
+        STATE.sessionElapsed = Math.max(0,
+          Date.now() - STATE.sessionStart - (STATE.totalPausedMs || 0));
+      }
+      data = buildSessionRecord();
+      if (!STATE.summarySaved) {
+        saveSessionRecord(data);
+        STATE.summarySaved = true;
+      }
+      // Stop the running timer — the session is over
+      STATE.timerEnd = null;
+      STATE.timerPaused = false;
+      const ov = $("#pause-overlay");
+      if (ov) ov.hidden = true;
+      document.body.classList.remove("timer-paused");
+      updateClockAndTimer();
+    }
+    const isPast = !!opts.past;
+
+    const summary = $("#summary");
+    clear(summary);
+
+    summary.appendChild(el("p", { className: "eyebrow" },
+      isPast ? "Past attempt" : "Session complete"));
+    summary.appendChild(el("h2", {}, data.certTitle));
+    const ts = formatDateTime(data.ts);
+    summary.appendChild(el("p", { className: "summary-timestamp" }, ts.full));
+
+    // ---- Hero: big number + verdict ----
+    const hero = el("div", { className: "summary-hero", dataset: { tone: toneFor(data.pct) } });
+    const numWrap = el("div", { className: "summary-num-wrap" });
+    numWrap.appendChild(el("span", { className: "summary-num" }, String(data.pct)));
+    numWrap.appendChild(el("span", { className: "summary-num-pct" }, "%"));
+    hero.appendChild(numWrap);
+
+    const heroMeta = el("div", { className: "summary-hero-meta" });
+    heroMeta.appendChild(el("div", { className: "summary-fraction" },
+      `${data.correct} / ${data.total} correct`));
+    const verdict = getVerdict(data);
+    heroMeta.appendChild(el("div", { className: "summary-verdict",
+                                      dataset: { tone: verdict.tone } },
+      verdict.title));
+    heroMeta.appendChild(el("div", { className: "summary-verdict-sub" }, verdict.sub));
+    hero.appendChild(heroMeta);
+    summary.appendChild(hero);
+
+    // ---- Weak-area callout ----
+    const weak = getWeakDomains(data.domains);
+    if (weak.length > 0) {
+      const callout = el("div", { className: "summary-callout weak" });
+      callout.appendChild(el("div", { className: "summary-callout-title" },
+        weak.length === 1 ? "Focus next on this module"
+                          : `Focus next on these ${weak.length} modules`));
+      const ul = el("ul", { className: "summary-callout-list" });
+      for (const d of weak.slice(0, 4)) {
+        ul.appendChild(el("li", {},
+          el("span", { className: "wk-name" }, d.name),
+          el("span", { className: "wk-pct" }, `${d.correct}/${d.total} · ${d.pct}%`)));
+      }
+      callout.appendChild(ul);
+      summary.appendChild(callout);
+    }
+
+    // ---- Per-domain breakdown ----
+    summary.appendChild(el("h3", { className: "summary-section-title" }, "By module"));
+    const domainList = el("div", { className: "summary-domains" });
+    for (const d of data.domains) {
+      const row = el("div", { className: "summary-domain-row" });
+      const head = el("div", { className: "summary-domain-head" });
+      head.appendChild(el("span", { className: "summary-domain-name" }, d.name));
+      head.appendChild(el("span", { className: "summary-domain-stat" },
+        d.total === 0 ? "Not attempted" : `${d.correct}/${d.total} · ${d.pct}%`));
+      row.appendChild(head);
+
+      const meter = el("div", { className: "summary-meter" });
+      if (d.total > 0) {
+        meter.appendChild(el("div", { className: "summary-meter-fill",
+                                       dataset: { tone: toneFor(d.pct) },
+                                       style: `width: ${d.pct}%` }));
+      }
+      row.appendChild(meter);
+      domainList.appendChild(row);
+    }
+    summary.appendChild(domainList);
+
+    // ---- Stats grid (time only when timer was used; best streak always) ----
+    const gridItems = [];
+    if (data.durationMs != null) {
+      gridItems.push(metricBlock("Total time", formatDuration(data.durationMs)));
+      gridItems.push(metricBlock("Average / question", formatDuration(data.avgPerQMs)));
+    }
+    if (data.bestStreak > 0) {
+      gridItems.push(metricBlock("Best streak", String(data.bestStreak), "correct in a row"));
+    }
+    if (gridItems.length > 0) {
+      summary.appendChild(el("h3", { className: "summary-section-title" },
+        data.durationMs != null ? "Time & streak" : "Streak"));
+      const grid = el("div", { className: "summary-stats-grid" });
+      gridItems.forEach(node => grid.appendChild(node));
+      summary.appendChild(grid);
+    }
+
+    // ---- Past attempts (only on live summary; comparing to history) ----
+    if (!isPast) {
+      const history = loadSessionHistory(data.cert);
+      // Don't include the just-saved record (it's already the hero)
+      const previous = history.filter(r => r.id !== data.id).slice(-6).reverse();
+      if (previous.length > 0) {
+        summary.appendChild(el("h3", { className: "summary-section-title" }, "Past attempts"));
+        summary.appendChild(renderAttemptList(previous, { compact: true }));
+      }
+    }
+
+    // ---- Actions ----
+    const actions = el("div", { className: "summary-actions" });
+    if (isPast) {
+      actions.appendChild(el("button", { type: "button", className: "primary",
+        onclick: () => { renderStats(); show("stats"); } }, "← Back to history"));
+    } else {
+      actions.appendChild(el("button", { type: "button", className: "primary",
+        onclick: () => {
+          resetSessionState();
+          if (STATE.timerMinutes > 0) startTimer(STATE.timerMinutes);
+          renderQuiz();
+          show("quiz");
+        }
+      }, "Try again"));
+    }
+    actions.appendChild(el("button", { type: "button", className: "ghost",
+      onclick: () => { renderStats(); show("stats"); } }, "Detailed stats"));
+    actions.appendChild(el("button", { type: "button", className: "ghost",
+      onclick: () => goToBankPickerForCurrentCert() }, "Switch bank"));
+    summary.appendChild(actions);
+
+    // ---- Export bar ----
+    const exportBar = el("div", { className: "summary-export" });
+    exportBar.appendChild(el("span", { className: "summary-export-label" },
+      "Export this summary —"));
+    exportBar.appendChild(el("button", { type: "button", className: "link",
+      onclick: () => exportSummaryAsHTML(data) }, "HTML"));
+    exportBar.appendChild(el("button", { type: "button", className: "link",
+      onclick: () => exportSummaryAsCSV(data) }, "CSV"));
+    summary.appendChild(exportBar);
+
+    // ---- Confetti on high scores (live summaries only) ----
+    if (!isPast && data.pct >= 80) {
+      setTimeout(() => {
+        const num = summary.querySelector(".summary-num-wrap");
+        if (num) fireConfetti(num);
+      }, 280);
+    }
+
+    // Scroll to top so the hero is in view
+    window.scrollTo({ top: 0, behavior: "smooth" });
+  }
+
+  // --- Attempt history list (rendered into summary + stats) ---------------
+
+  function renderAttemptList(records, opts) {
+    opts = opts || {};
+    const list = el("div", { className: "attempt-list" });
+    for (const r of records) {
+      const ts = formatDateTime(r.ts);
+      // Rich aria-label so screen readers announce the full row context in
+      // one phrase instead of reading each cell separately ("85 percent")
+      // → ("View attempt from 21 May 2026 at 14:35, scored 85 percent,
+      //    38 of 45 correct, took 24 minutes 15 seconds, passed").
+      const parts = [
+        `View attempt from ${ts.date} at ${ts.time}`,
+        `scored ${r.pct} percent`,
+        `${r.correct} of ${r.total} correct`,
+      ];
+      if (r.durationMs != null) parts.push(`took ${formatDuration(r.durationMs)}`);
+      if (r.isMock) parts.push(r.passed ? "passed" : "below passing threshold");
+      const row = el("button", { type: "button", className: "attempt-row",
+                                  "aria-label": parts.join(", "),
+                                  onclick: () => { renderSummary(r, { past: true }); show("summary"); } });
+      row.appendChild(el("span", { className: "attempt-when" },
+        el("span", { className: "attempt-date" }, ts.date),
+        el("span", { className: "attempt-time" }, ts.time)));
+      row.appendChild(el("span", { className: "attempt-pct", dataset: { tone: toneFor(r.pct) } },
+        r.pct + "%"));
+      row.appendChild(el("span", { className: "attempt-fraction" },
+        `${r.correct}/${r.total}`));
+      if (r.durationMs != null) {
+        row.appendChild(el("span", { className: "attempt-duration" },
+          formatDuration(r.durationMs)));
+      } else {
+        row.appendChild(el("span", { className: "attempt-duration muted" }, "—"));
+      }
+      if (r.isMock) {
+        row.appendChild(el("span", { className: "attempt-verdict",
+                                      dataset: { tone: r.passed ? "good" : "weak" } },
+          r.passed ? "PASS" : "BELOW"));
+      } else if (!opts.compact) {
+        row.appendChild(el("span", { className: "attempt-verdict muted" }, "practice"));
+      } else {
+        row.appendChild(el("span"));
+      }
+      row.appendChild(el("span", { className: "attempt-arrow", "aria-hidden": "true" }, "→"));
+      list.appendChild(row);
+    }
+    return list;
+  }
+
+  // --- Export: HTML + CSV --------------------------------------------------
+
+  function downloadBlob(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+
+  // Plain-text escape for embedding inside an HTML export. NOT used for
+  // building DOM nodes anywhere — only for writing the standalone HTML file.
+  function escapeHtml(s) {
+    return String(s == null ? "" : s)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#39;");
+  }
+
+  function exportSummaryAsHTML(record) {
+    const ts = formatDateTime(record.ts);
+    const verdict = getVerdict(record);
+    const weak = getWeakDomains(record.domains);
+    const safeName = record.cert.replace(/[^a-z0-9-]/gi, "");
+    const stamp = new Date(record.ts).toISOString().replace(/[:.]/g, "-").slice(0, 16);
+
+    const domainRowsHtml = record.domains.map(d => {
+      const pct = d.total === 0 ? "—" : d.pct + "%";
+      const stat = d.total === 0 ? "Not attempted" : `${d.correct}/${d.total} · ${pct}`;
+      const width = d.total === 0 ? 0 : d.pct;
+      const tone = toneFor(d.pct);
+      return `
+        <tr>
+          <td class="dn">${escapeHtml(d.name)}</td>
+          <td class="ds">${escapeHtml(stat)}</td>
+          <td class="db"><div class="bar"><div class="bf tone-${tone}" style="width:${width}%"></div></div></td>
+        </tr>`;
+    }).join("");
+
+    const weakHtml = weak.length === 0 ? "" : `
+      <div class="callout">
+        <h3>Focus areas</h3>
+        <ul>${weak.slice(0, 4).map(d =>
+          `<li><strong>${escapeHtml(d.name)}</strong> — ${d.correct}/${d.total} · ${d.pct}%</li>`).join("")}</ul>
+      </div>`;
+
+    const timeRowsHtml = record.durationMs == null ? "" : `
+      <tr><th>Total time</th><td>${escapeHtml(formatDuration(record.durationMs))}</td></tr>
+      <tr><th>Average / question</th><td>${escapeHtml(formatDuration(record.avgPerQMs))}</td></tr>`;
+    const streakRow = record.bestStreak > 0
+      ? `<tr><th>Best streak</th><td>${record.bestStreak} correct in a row</td></tr>` : "";
+
+    const passLine = record.isMock
+      ? `<p class="threshold">Passing threshold: ${record.threshold}%</p>` : "";
+
+    const html = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<title>${escapeHtml(record.certTitle)} — ${escapeHtml(ts.full)}</title>
+<style>
+  :root { --fg:#18181B; --muted:#52525B; --hairline:#E5E5E2; --bg:#FAFAF7; --surface:#fff;
+          --good:#14532D; --warn:#92400E; --weak:#991B1B; --great:#065F46; }
+  * { box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+         background: var(--bg); color: var(--fg); margin: 0; padding: 2.5rem 1.5rem; font-size: 15px; line-height: 1.55; }
+  main { max-width: 720px; margin: 0 auto; }
+  .eyebrow { font-family: ui-monospace, "SF Mono", Menlo, monospace; font-size: 11px; font-weight: 600;
+             letter-spacing: 0.12em; text-transform: uppercase; color: var(--weak); margin: 0 0 0.6rem; }
+  h1 { font-size: 2rem; font-weight: 600; letter-spacing: -0.02em; margin: 0 0 0.3rem; line-height: 1.1; }
+  .when { color: var(--muted); font-family: ui-monospace, "SF Mono", Menlo, monospace; font-size: 12px; letter-spacing: 0.04em; margin: 0 0 2rem; }
+  .hero { background: var(--surface); border: 1px solid var(--hairline); border-radius: 12px;
+          padding: 2rem; display: flex; align-items: center; gap: 2rem; margin-bottom: 1.5rem; }
+  .hero .pct { font-size: 5rem; font-weight: 600; line-height: 1; letter-spacing: -0.04em; font-variant-numeric: tabular-nums; }
+  .hero .pct.tone-great { color: var(--great); } .hero .pct.tone-good { color: var(--good); }
+  .hero .pct.tone-warn { color: var(--warn); }   .hero .pct.tone-weak { color: var(--weak); }
+  .hero .pct::after { content: "%"; font-size: 1.5rem; color: var(--muted); font-weight: 500; margin-left: 0.1em; }
+  .hero .meta .fraction { font-size: 1.25rem; font-weight: 500; margin-bottom: 0.4rem; }
+  .hero .meta .verdict { font-family: ui-monospace, "SF Mono", Menlo, monospace; font-size: 0.85rem; font-weight: 600;
+                          letter-spacing: 0.08em; text-transform: uppercase; }
+  .hero .meta .verdict.tone-good { color: var(--good); } .hero .meta .verdict.tone-weak { color: var(--weak); }
+  .hero .meta .verdict.tone-great { color: var(--great); } .hero .meta .verdict.tone-warn { color: var(--warn); }
+  .threshold { font-family: ui-monospace, "SF Mono", Menlo, monospace; color: var(--muted); font-size: 0.8rem; margin: 0.3rem 0 0; }
+  .callout { background: rgba(185,28,28,0.06); border: 1px solid rgba(185,28,28,0.25); border-radius: 10px; padding: 1rem 1.25rem; margin-bottom: 1.5rem; }
+  .callout h3 { margin: 0 0 0.5rem; font-size: 0.9rem; color: var(--weak); font-weight: 600; letter-spacing: -0.005em; }
+  .callout ul { margin: 0; padding-left: 1.1rem; } .callout li { margin: 0.2rem 0; }
+  h2 { font-size: 0.85rem; font-family: ui-monospace, "SF Mono", Menlo, monospace; font-weight: 600;
+       letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted); margin: 2rem 0 0.85rem; }
+  table.domains { width: 100%; border-collapse: collapse; background: var(--surface); border: 1px solid var(--hairline); border-radius: 10px; overflow: hidden; }
+  table.domains td { padding: 0.7rem 0.9rem; border-top: 1px solid var(--hairline); vertical-align: middle; }
+  table.domains tr:first-child td { border-top: 0; }
+  td.dn { font-weight: 500; width: 40%; } td.ds { color: var(--muted); font-family: ui-monospace, monospace; font-size: 0.82rem; width: 22%; }
+  td.db { width: 38%; }
+  .bar { background: var(--hairline); height: 6px; border-radius: 99px; overflow: hidden; }
+  .bf { height: 100%; border-radius: 99px; }
+  .bf.tone-great { background: var(--great); } .bf.tone-good { background: var(--good); }
+  .bf.tone-warn  { background: var(--warn);  } .bf.tone-weak { background: var(--weak); }
+  table.stats { width: 100%; border-collapse: collapse; background: var(--surface); border: 1px solid var(--hairline); border-radius: 10px; overflow: hidden; }
+  table.stats th, table.stats td { padding: 0.7rem 0.9rem; text-align: left; border-top: 1px solid var(--hairline); }
+  table.stats tr:first-child th, table.stats tr:first-child td { border-top: 0; }
+  table.stats th { font-weight: 500; color: var(--muted); font-size: 0.85rem; width: 40%; }
+  table.stats td { font-variant-numeric: tabular-nums; }
+  .footer { margin-top: 3rem; padding-top: 1.5rem; border-top: 1px solid var(--hairline); color: var(--muted); font-size: 0.75rem; font-family: ui-monospace, monospace; }
+  @media print { body { padding: 1rem; } .hero, table.domains, table.stats { box-shadow: none; } }
+</style></head>
+<body><main>
+  <p class="eyebrow">${record.isMock ? "Mock exam" : "Practice"} · attempt summary</p>
+  <h1>${escapeHtml(record.certTitle)}</h1>
+  <p class="when">Completed ${escapeHtml(ts.full)}</p>
+
+  <div class="hero">
+    <div class="pct tone-${toneFor(record.pct)}">${record.pct}</div>
+    <div class="meta">
+      <div class="fraction">${record.correct} / ${record.total} correct</div>
+      <div class="verdict tone-${verdict.tone}">${escapeHtml(verdict.title)}</div>
+      ${passLine}
+    </div>
+  </div>
+
+  ${weakHtml}
+
+  <h2>By module</h2>
+  <table class="domains"><tbody>${domainRowsHtml}</tbody></table>
+
+  ${timeRowsHtml || streakRow ? `<h2>Stats</h2><table class="stats"><tbody>${timeRowsHtml}${streakRow}</tbody></table>` : ""}
+
+  <p class="footer">Exported from Databricks Certification Practice — a study aid, not the official exam.</p>
+</main></body></html>`;
+
+    downloadBlob(new Blob([html], { type: "text/html;charset=utf-8" }),
+      `dbx-${safeName}-${stamp}.html`);
+  }
+
+  function exportSummaryAsCSV(record) {
+    const ts = formatDateTime(record.ts);
+    const safeName = record.cert.replace(/[^a-z0-9-]/gi, "");
+    const stamp = new Date(record.ts).toISOString().replace(/[:.]/g, "-").slice(0, 16);
+
+    const q = (v) => {
+      const s = String(v == null ? "" : v);
+      return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+    };
+    const rows = [];
+    rows.push(["Field", "Value"].join(","));
+    rows.push(["Certification", record.certTitle].map(q).join(","));
+    rows.push(["Type", record.isMock ? "Mock exam" : "Practice"].map(q).join(","));
+    rows.push(["Completed", ts.full].map(q).join(","));
+    rows.push(["Score (%)", record.pct].map(q).join(","));
+    rows.push(["Correct", record.correct].map(q).join(","));
+    rows.push(["Total questions", record.total].map(q).join(","));
+    if (record.isMock) {
+      rows.push(["Passing threshold (%)", record.threshold].map(q).join(","));
+      rows.push(["Verdict", record.passed ? "PASS" : "BELOW PASSING"].map(q).join(","));
+    }
+    if (record.durationMs != null) {
+      rows.push(["Total time", formatDuration(record.durationMs)].map(q).join(","));
+      rows.push(["Average per question", formatDuration(record.avgPerQMs)].map(q).join(","));
+    }
+    if (record.bestStreak > 0) {
+      rows.push(["Best streak", record.bestStreak].map(q).join(","));
+    }
+    rows.push("");
+    rows.push(["Module", "Correct", "Total", "Percentage"].join(","));
+    for (const d of record.domains) {
+      rows.push([
+        d.name,
+        d.correct,
+        d.total,
+        d.total === 0 ? "" : d.pct,
+      ].map(q).join(","));
+    }
+    downloadBlob(new Blob([rows.join("\n")], { type: "text/csv;charset=utf-8" }),
+      `dbx-${safeName}-${stamp}.csv`);
+  }
+
   // --- Settings ------------------------------------------------------------
 
   function populateSettings() {
@@ -541,18 +1483,327 @@
     $("#setting-mode").value = STATE.settings.mode;
     $("#setting-domain").value = STATE.settings.domain;
     $("#setting-difficulty").value = STATE.settings.difficulty;
+    $("#setting-timer").value = String(STATE.timerMinutes || 0);
   }
 
   function applySettings() {
     STATE.settings.mode = $("#setting-mode").value;
     STATE.settings.domain = $("#setting-domain").value;
     STATE.settings.difficulty = $("#setting-difficulty").value;
+    const tmin = parseInt($("#setting-timer").value, 10) || 0;
+    if (tmin !== STATE.timerMinutes || tmin > 0) {
+      saveTimerMinutes(tmin);
+      startTimer(tmin);
+      updateClockAndTimer();
+    }
     STATE.sequentialIndex = 0;
     STATE.seenThisSession.clear();
     renderQuiz();
     show("quiz");
   }
 
+  // --- Clock + timer -------------------------------------------------------
+
+  function loadTimerMinutes() {
+    try {
+      const v = parseInt(localStorage.getItem(TIMER_KEY) || "0", 10);
+      return Number.isFinite(v) && v >= 0 ? v : 0;
+    } catch (_) { return 0; }
+  }
+
+  function saveTimerMinutes(min) {
+    try { localStorage.setItem(TIMER_KEY, String(min)); } catch (_) { /* no-op */ }
+  }
+
+  function startTimer(minutes) {
+    STATE.timerMinutes = minutes;
+    STATE.timerExpired = false;
+    STATE.timerEnd = minutes > 0 ? Date.now() + minutes * 60 * 1000 : null;
+    // Session clock is only meaningful when there's an exam timer running.
+    // In free-practice mode we deliberately don't track time — see the
+    // summary screen, which hides the time stats when sessionStart is null.
+    STATE.sessionStart = minutes > 0 ? Date.now() : null;
+    STATE.sessionElapsed = null;
+    STATE.timerPaused = false;
+    STATE.pausedRemainingMs = null;
+    STATE.totalPausedMs = 0;
+    STATE.pauseStart = null;
+  }
+
+  // --- Pause / resume the exam timer --------------------------------------
+  //
+  // Pausing freezes the countdown, blurs the screen behind a Resume overlay
+  // so the user can step away without losing their seat, and accumulates
+  // the off-clock time in STATE.totalPausedMs so the summary's "Total time"
+  // accurately reflects effort (not wall-clock).
+
+  function pauseTimer() {
+    if (STATE.timerPaused || !STATE.timerEnd || STATE.timerExpired) return;
+    STATE.pausedRemainingMs = Math.max(0, STATE.timerEnd - Date.now());
+    STATE.pauseStart = Date.now();
+    STATE.timerPaused = true;
+    STATE.timerEnd = null;
+    const ov = $("#pause-overlay");
+    if (ov) ov.hidden = false;
+    document.body.classList.add("timer-paused");
+    updateClockAndTimer();
+    // Move focus to the Resume button so Enter/Space resumes immediately.
+    const r = $("#btn-resume");
+    if (r) setTimeout(() => r.focus({ preventScroll: true }), 0);
+  }
+
+  function resumeTimer() {
+    if (!STATE.timerPaused) return;
+    const remain = STATE.pausedRemainingMs || 0;
+    STATE.totalPausedMs += STATE.pauseStart ? (Date.now() - STATE.pauseStart) : 0;
+    STATE.pauseStart = null;
+    STATE.pausedRemainingMs = null;
+    STATE.timerPaused = false;
+    STATE.timerEnd = remain > 0 ? Date.now() + remain : null;
+    const ov = $("#pause-overlay");
+    if (ov) ov.hidden = true;
+    document.body.classList.remove("timer-paused");
+    updateClockAndTimer();
+  }
+
+  function toggleTimerPause() {
+    if (STATE.timerPaused) resumeTimer();
+    else pauseTimer();
+  }
+
+  function hasActiveSession() {
+    // A completed session that's already been written to history isn't
+    // "active" anymore — the user is on the summary screen and shouldn't
+    // be asked to confirm leaving. Likewise an expired timer means the
+    // exam is over.
+    if (STATE.summarySaved) return false;
+    if (STATE.timerExpired) return false;
+    return STATE.sessionTotal > 0 || STATE.timerEnd != null || STATE.timerPaused;
+  }
+
+  function resetSessionState() {
+    STATE.sessionCorrect = 0;
+    STATE.sessionTotal = 0;
+    STATE.seenThisSession.clear();
+    STATE.streak = 0;
+    STATE.bestStreak = 0;
+    STATE.timerEnd = null;
+    STATE.timerExpired = false;
+    STATE.sessionStart = null;
+    STATE.sessionElapsed = null;
+    STATE.summarySaved = false;
+    STATE.timerPaused = false;
+    STATE.pausedRemainingMs = null;
+    STATE.totalPausedMs = 0;
+    STATE.pauseStart = null;
+    const ov = $("#pause-overlay");
+    if (ov) ov.hidden = true;
+    document.body.classList.remove("timer-paused");
+    updateClockAndTimer();
+  }
+
+  async function confirmLeaveExam(destination) {
+    if (hasActiveSession()) {
+      const ok = await customConfirm({
+        title: STATE.timerEnd ? "Stop timed exam?" : "Leave this session?",
+        message: STATE.timerEnd
+          ? "Your timer will reset and the session-level stats will be cleared. Your long-term saved history isn't affected."
+          : "Your session-level stats (correct/total) will reset. Your long-term saved history isn't affected.",
+        confirmLabel: STATE.timerEnd ? "Stop & leave" : "Leave",
+        cancelLabel: "Keep going",
+        danger: true,
+      });
+      if (!ok) return false;
+    }
+    resetSessionState();
+    destination();
+    return true;
+  }
+
+  function goToCertPicker() {
+    if (STATE.certBanks) {
+      renderCertPicker(STATE.certBanks);
+      show("setup");
+    } else {
+      location.reload();
+    }
+  }
+
+  function goToBankPickerForCurrentCert() {
+    if (!STATE.bank || !STATE.certBanks) { goToCertPicker(); return; }
+    const sourceCert = STATE.bank.sourceCert || STATE.bank.cert;
+    const items = STATE.certBanks.get(sourceCert);
+    if (items) {
+      renderBankPicker(sourceCert, items);
+      show("setup");
+    } else {
+      goToCertPicker();
+    }
+  }
+
+  function confirmBackToCertPicker() {
+    confirmLeaveExam(goToCertPicker);
+  }
+  function confirmBackToBankPicker() {
+    confirmLeaveExam(goToBankPickerForCurrentCert);
+  }
+
+  function showTimerExpiredToast() {
+    const existing = document.querySelector(".streak-toast");
+    if (existing) existing.remove();
+    const toast = el("div", { className: "streak-toast" },
+      el("span", { className: "streak-num",
+                   style: "background:var(--negative);color:#fff" }, "Time's up"),
+      " · review your stats or keep going");
+    document.body.appendChild(toast);
+    void toast.offsetWidth;
+    toast.classList.add("show");
+    setTimeout(() => toast.remove(), 3200);
+  }
+
+  function updateClockAndTimer() {
+    // Wall clock
+    const clockEl = $("#quiz-clock");
+    if (clockEl) {
+      const now = new Date();
+      clockEl.textContent = now.toLocaleTimeString([], {
+        hour: "2-digit", minute: "2-digit", hour12: false,
+      });
+    }
+    // Timer
+    const timerEl = $("#quiz-timer");
+    if (!timerEl) return;
+    const valueEl = timerEl.querySelector(".timer-value");
+    const setValue = (text) => { if (valueEl) valueEl.textContent = text; };
+    if (STATE.timerExpired) {
+      setValue("00:00");
+      timerEl.classList.add("expired");
+      timerEl.classList.remove("warning", "paused");
+      timerEl.hidden = false;
+      return;
+    }
+    if (STATE.timerPaused) {
+      const remain = STATE.pausedRemainingMs || 0;
+      const m = Math.floor(remain / 60000);
+      const s = Math.floor((remain % 60000) / 1000);
+      setValue(String(m).padStart(2, "0") + ":" + String(s).padStart(2, "0"));
+      timerEl.classList.add("paused");
+      timerEl.classList.remove("warning", "expired");
+      timerEl.hidden = false;
+      return;
+    }
+    if (!STATE.timerEnd) {
+      timerEl.hidden = true;
+      timerEl.classList.remove("warning", "expired", "paused");
+      return;
+    }
+    const remainMs = Math.max(0, STATE.timerEnd - Date.now());
+    const totalSec = Math.floor(remainMs / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    setValue(String(m).padStart(2, "0") + ":" + String(s).padStart(2, "0"));
+    timerEl.hidden = false;
+    timerEl.classList.remove("paused");
+    timerEl.classList.toggle("warning",
+      remainMs > 0 && remainMs <= 5 * 60 * 1000);
+    if (remainMs === 0) {
+      STATE.timerExpired = true;
+      timerEl.classList.add("expired");
+      timerEl.classList.remove("warning");
+      showTimerExpiredToast();
+    }
+  }
+
+  // --- Custom confirm modal -----------------------------------------------
+  //
+  // Replaces window.confirm() with a theme-aware dialog. Returns a Promise
+  // that resolves to true (confirmed) or false (cancelled, ESC, or
+  // backdrop-click). Focus is trapped between the two buttons and restored
+  // to the trigger element when the dialog closes.
+  //
+  // Usage:
+  //   const ok = await customConfirm({ title, message, confirmLabel,
+  //                                    cancelLabel, danger });
+
+  function customConfirm({
+    title = "Confirm",
+    message = "",
+    confirmLabel = "Confirm",
+    cancelLabel = "Cancel",
+    danger = false,
+  } = {}) {
+    return new Promise((resolve) => {
+      const backdrop = $("#modal-backdrop");
+      const dialog   = backdrop.querySelector(".modal");
+      const titleEl  = $("#modal-title");
+      const msgEl    = $("#modal-message");
+      const okBtn    = $("#modal-confirm");
+      const cancelBtn = $("#modal-cancel");
+
+      titleEl.textContent  = title;
+      msgEl.textContent    = message;
+      okBtn.textContent    = confirmLabel;
+      cancelBtn.textContent = cancelLabel;
+      okBtn.classList.toggle("danger", !!danger);
+
+      const prevFocus = document.activeElement;
+
+      const cleanup = (result) => {
+        backdrop.hidden = true;
+        okBtn.removeEventListener("click", onOk);
+        cancelBtn.removeEventListener("click", onCancel);
+        backdrop.removeEventListener("mousedown", onBackdropDown);
+        document.removeEventListener("keydown", onKey, true);
+        if (prevFocus && typeof prevFocus.focus === "function"
+            && document.body.contains(prevFocus)) {
+          try { prevFocus.focus({ preventScroll: true }); } catch (_) { /* no-op */ }
+        }
+        resolve(result);
+      };
+      const onOk     = () => cleanup(true);
+      const onCancel = () => cleanup(false);
+      // Use mousedown (not click) on backdrop so a drag-release outside the
+      // dialog doesn't fire onCancel mid-text-selection.
+      const onBackdropDown = (e) => { if (e.target === backdrop) cleanup(false); };
+      const onKey = (e) => {
+        if (e.key === "Escape") {
+          e.preventDefault(); e.stopPropagation();
+          cleanup(false);
+        } else if (e.key === "Enter") {
+          // Enter activates whichever button is focused; default = Confirm
+          if (document.activeElement === cancelBtn) return;
+          e.preventDefault(); e.stopPropagation();
+          cleanup(true);
+        } else if (e.key === "Tab") {
+          // Trap focus between Cancel and Confirm
+          const next = e.shiftKey
+            ? (document.activeElement === cancelBtn ? okBtn : cancelBtn)
+            : (document.activeElement === okBtn     ? cancelBtn : okBtn);
+          e.preventDefault();
+          next.focus({ preventScroll: true });
+        }
+      };
+
+      okBtn.addEventListener("click", onOk);
+      cancelBtn.addEventListener("click", onCancel);
+      backdrop.addEventListener("mousedown", onBackdropDown);
+      // Capture phase so modal swallows keys before the global quiz handler
+      document.addEventListener("keydown", onKey, true);
+
+      backdrop.hidden = false;
+      // Defer focus so the appear animation doesn't snap; preventScroll so
+      // the page doesn't jump.
+      setTimeout(() => okBtn.focus({ preventScroll: true }), 0);
+    });
+  }
+
+  // Is a confirmation modal currently visible? Used to gate global quiz
+  // keyboard shortcuts so they don't leak through to the underlying screen.
+  function modalIsOpen() {
+    const m = document.getElementById("modal-backdrop");
+    return !!(m && !m.hidden);
+  }
+
   // --- Theme toggle --------------------------------------------------------
 
   function loadTheme() {
@@ -564,8 +1815,10 @@
 
   function applyTheme(theme) {
     document.documentElement.setAttribute("data-theme", theme);
-    const iconNode = $("#btn-theme-icon");
-    if (iconNode) iconNode.textContent = THEME_ICONS[theme];
+    const labelNode = $("#btn-theme-label");
+    if (labelNode) {
+      labelNode.textContent = theme.charAt(0).toUpperCase() + theme.slice(1);
+    }
   }
 
   function cycleTheme() {
@@ -577,11 +1830,115 @@
 
   // --- Init ----------------------------------------------------------------
 
+  // UI shows 1-4 but data uses A-D (matches source markdown). These maps
+  // bridge the two consistently throughout the quiz UI + keyboard handler.
+  const NUM_TO_LETTER = { "1": "A", "2": "B", "3": "C", "4": "D" };
+  const LETTER_TO_NUM = { "A": "1", "B": "2", "C": "3", "D": "4" };
+
+  function handleKeydown(ev) {
+    // Only react when the quiz section is visible
+    if ($("#quiz").hidden) return;
+    // Don't process quiz shortcuts while a confirm modal is up — the
+    // modal owns its own keyboard handler (ESC/Enter/Tab) registered
+    // in capture phase, but a "1"/"2"/etc keypress would otherwise
+    // bubble through and select an answer in the background quiz.
+    if (modalIsOpen()) return;
+    // P key toggles pause — works whether the bar is paused or not.
+    if ((ev.key === "p" || ev.key === "P") && STATE.timerMinutes > 0
+        && !ev.ctrlKey && !ev.metaKey && !ev.altKey) {
+      ev.preventDefault();
+      toggleTimerPause();
+      return;
+    }
+    // Esc + Enter + Space resume from a paused state; ignore all other
+    // shortcuts while the screen is on hold.
+    if (STATE.timerPaused) {
+      if (ev.key === "Escape" || ev.key === "Enter" || ev.key === " ") {
+        ev.preventDefault();
+        resumeTimer();
+      }
+      return;
+    }
+    // Ignore when the user is typing in a real input. Radios + checkboxes
+    // are explicitly NOT excluded — we still want Space/Enter/arrows to work
+    // when focus is on a choice's radio (which is normal after ↑/↓ or click).
+    if (ev.target.matches
+        && ev.target.matches("input:not([type=radio]):not([type=checkbox]), textarea, select")) {
+      return;
+    }
+    // Ignore when a modifier key is held (let browser shortcuts pass through)
+    if (ev.ctrlKey || ev.metaKey || ev.altKey) return;
+
+    const key = ev.key.toLowerCase();
+    // Choice keys: 1/2/3/4 (primary) + a/b/c/d (alias)
+    const letter = NUM_TO_LETTER[key]
+                 || { "a": "A", "b": "B", "c": "C", "d": "D" }[key];
+
+    if (letter) {
+      // After submit (btn-next visible): ignore choice keys
+      const submitted = !$("#btn-next").hidden;
+      if (submitted) return;
+      const radio = document.querySelector(
+        `fieldset#quiz-choices input[value="${letter}"]`);
+      if (radio && !radio.disabled) {
+        radio.checked = true;
+        radio.dispatchEvent(new Event("change", { bubbles: true }));
+        ev.preventDefault();
+      }
+      return;
+    }
+    const submitted = !$("#btn-next").hidden;
+
+    // ↑ / ↓ — cycle through choices (only meaningful before submit).
+    // Move both `checked` AND keyboard focus so the visible focus ring on
+    // the choice label stays in sync with which radio is selected.
+    if ((ev.key === "ArrowUp" || ev.key === "ArrowDown") && !submitted) {
+      const letters = ["A", "B", "C", "D"];
+      const currentIdx = letters.indexOf(STATE.currentChoice);
+      const delta = ev.key === "ArrowDown" ? 1 : -1;
+      const nextIdx = currentIdx === -1
+        ? (ev.key === "ArrowDown" ? 0 : 3)        // no selection → top/bottom
+        : (currentIdx + delta + 4) % 4;            // wrap around
+      const radio = document.querySelector(
+        `fieldset#quiz-choices input[value="${letters[nextIdx]}"]`);
+      if (radio && !radio.disabled) {
+        radio.checked = true;
+        radio.focus({ preventScroll: false });   // <-- this is the fix
+        radio.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      ev.preventDefault();
+      return;
+    }
+
+    // Enter / Space — primary action (submit before answer, next after)
+    if (ev.key === "Enter" || ev.key === " ") {
+      if (submitted) {
+        $("#btn-next").click();
+      } else if (!$("#btn-submit").disabled && !$("#btn-submit").hidden) {
+        $("#btn-submit").click();
+      }
+      ev.preventDefault();
+      return;
+    }
+    // Right arrow / N — explicitly next, only after submit
+    if ((ev.key === "ArrowRight" || key === "n") && submitted) {
+      $("#btn-next").click();
+      ev.preventDefault();
+      return;
+    }
+    // S — skip, only before submit
+    if (key === "s" && !submitted) {
+      skipQuestion();
+      ev.preventDefault();
+    }
+  }
+
   function init() {
     // Apply persisted theme before anything renders so there's no flash
     applyTheme(loadTheme());
 
     $("#btn-submit").addEventListener("click", submitAnswer);
+    $("#btn-skip").addEventListener("click", skipQuestion);
     $("#btn-next").addEventListener("click", renderQuiz);
     $("#btn-stats").addEventListener("click", () => { renderStats(); show("stats"); });
     $("#btn-stats-back").addEventListener("click", () => show("quiz"));
@@ -590,11 +1947,61 @@
     $("#btn-reset-top").addEventListener("click", resetHistory);
     $("#btn-settings").addEventListener("click", () => show("settings"));
     $("#btn-settings-cancel").addEventListener("click", () => show("quiz"));
+    const cancel2 = $("#btn-settings-cancel-2");
+    if (cancel2) cancel2.addEventListener("click", () => show("quiz"));
     $("#btn-settings-apply").addEventListener("click", applySettings);
-    $("#btn-exit").addEventListener("click", () => location.reload());
+    $("#btn-exit").addEventListener("click", () => {
+      if (STATE.certBanks) renderCertPicker(STATE.certBanks);
+      else location.reload();
+      show("setup");
+    });
+
+    // Masthead links:
+    //   DBX Practice brand → step 1 (all certifications)
+    //   cert name (e.g. "DATA ENGINEER ASSOCIATE") → step 2 (bank
+    //     picker for that specific cert)
+    // Both confirm() before leaving an in-progress session/timer.
+    const brandLink = $("#brand-link");
+    if (brandLink) brandLink.addEventListener("click", confirmBackToCertPicker);
+    const certLink = $("#quiz-cert");
+    if (certLink) certLink.addEventListener("click", confirmBackToBankPicker);
     $("#btn-theme").addEventListener("click", cycleTheme);
 
-    probeBanks().then(renderSetup);
+    // Timer pill → pause when active; pause overlay button → resume.
+    const timerBtn = $("#quiz-timer");
+    if (timerBtn) timerBtn.addEventListener("click", () => {
+      if (!STATE.timerEnd && !STATE.timerPaused) return;  // no-op when no exam timer
+      if (STATE.timerExpired) return;
+      toggleTimerPause();
+    });
+    const resumeBtn = $("#btn-resume");
+    if (resumeBtn) resumeBtn.addEventListener("click", resumeTimer);
+    const pauseBackdrop = $("#pause-overlay");
+    if (pauseBackdrop) pauseBackdrop.addEventListener("mousedown", (e) => {
+      if (e.target === pauseBackdrop) resumeTimer();
+    });
+
+    document.addEventListener("keydown", handleKeydown);
+
+    // Load timer preference + start the clock interval. The clock pill
+    // updates every second whether a timer is active or not.
+    STATE.timerMinutes = loadTimerMinutes();
+    updateClockAndTimer();
+    setInterval(updateClockAndTimer, 1000);
+
+    // Observe actionbar height — content wrapping (kbd hint long/short,
+    // viewport resize, etc.) changes how many rows the actionbar uses.
+    const actionbar = $("#actionbar");
+    if (actionbar && typeof ResizeObserver !== "undefined") {
+      const ro = new ResizeObserver(() => syncActionbarHeight());
+      ro.observe(actionbar);
+    }
+    window.addEventListener("resize", syncActionbarHeight);
+
+    loadAllBankMetadata().then(certBanks => {
+      STATE.certBanks = certBanks;
+      renderCertPicker(certBanks);
+    });
   }
 
   if (document.readyState === "loading") {
diff --git a/practice/build.py b/practice/build.py
index fc7650f..bfcf3da 100644
--- a/practice/build.py
+++ b/practice/build.py
@@ -204,6 +204,114 @@ def parse_questions(md_path: Path, domain_id: str) -> list[dict]:
     return questions
 
 
+# Section heading inside a mock-exam questions.md, e.g.
+#   "## Databricks Lakehouse Platform (Questions 1–11)"
+DOMAIN_SECTION_RE = re.compile(
+    r"^## (.+?)\s*\(Questions?\s+[\d\-–—]+\)\s*$")
+# Lightweight Q-heading detector for the mock pre-scan
+SIMPLE_Q_HEADING_RE = re.compile(r"^## Question (\d+)(?:\.\d+)?")
+
+
+def slugify(name: str) -> str:
+    s = re.sub(r"[^\w\s-]", "", name).strip().lower()
+    return re.sub(r"[-\s]+", "-", s) or "section"
+
+
+def build_mock(cert: str, exam_n: int, check_only: bool = False) -> dict:
+    """Build a mock-exam bank for `cert` exam number `exam_n` (1 or 2).
+
+    Mock-exam files contain all questions in one `questions.md`, with
+    intra-file H2 section headings demarcating domains, e.g.
+
+        ## Databricks Lakehouse Platform (Questions 1–11)
+        ## Question 1 *(Medium)*
+        ...
+
+    We first scan the file linearly to build a qnum→domain map, then reuse
+    parse_questions() and overlay the per-question domain from the map.
+    """
+    folder = "mock-exam" if exam_n == 1 else f"mock-exam-{exam_n}"
+    md_path = CERTS_DIR / cert / "resources" / folder / "questions.md"
+    bank_id = f"{cert}-mock-{exam_n}"
+    cert_title_base, blueprint = CERT_TITLES.get(cert, (cert, ""))
+    cert_title = f"{cert_title_base} — Mock Exam {exam_n}"
+
+    if not md_path.exists():
+        return {"cert": bank_id, "questions": []}
+
+    text = md_path.read_text(encoding="utf-8")
+    if text.startswith("---"):
+        end = text.find("\n---", 3)
+        if end != -1:
+            text = text[end + 4:]
+
+    # Pre-scan for domain boundaries
+    current_domain_id = "general"
+    current_domain_name = "General"
+    domain_order: list[tuple[str, str]] = []
+    qnum_to_domain: dict[str, str] = {}
+    for line in text.splitlines():
+        d_match = DOMAIN_SECTION_RE.match(line)
+        if d_match:
+            current_domain_name = d_match.group(1).strip()
+            current_domain_id = slugify(current_domain_name)
+            if not any(d[0] == current_domain_id for d in domain_order):
+                domain_order.append((current_domain_id, current_domain_name))
+            continue
+        q_match = SIMPLE_Q_HEADING_RE.match(line)
+        if q_match:
+            qnum_to_domain[q_match.group(1)] = current_domain_id
+
+    # Reuse the standard question parser, then overlay per-question domain
+    raw_questions = parse_questions(md_path, "mock")
+    for q in raw_questions:
+        # Original id is "questions-q005" — rewrite to include cert + mock #
+        original_qnum = q["id"].rsplit("-q", 1)[-1]
+        try:
+            qnum_int = str(int(original_qnum))
+        except ValueError:
+            qnum_int = original_qnum
+        q["id"] = f"{bank_id}-q{original_qnum}"
+        q["domain"] = qnum_to_domain.get(qnum_int, "general")
+
+    domains: list[dict] = []
+    for did, dname in domain_order:
+        count = sum(1 for q in raw_questions if q["domain"] == did)
+        if count > 0:
+            domains.append({
+                "id": did,
+                "name": dname,
+                "sourceFile": str(md_path.relative_to(ROOT)),
+                "questionCount": count,
+            })
+
+    bank = {
+        "cert": bank_id,
+        "certTitle": cert_title,
+        "blueprintVersion": blueprint,
+        "generated": date.today().isoformat(),
+        "domains": domains,
+        "questions": raw_questions,
+        "kind": "mock",
+        "sourceCert": cert,
+    }
+
+    if not check_only:
+        if not raw_questions:
+            print(f"  {bank_id}: 0 questions")
+            return bank
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        out_path = DATA_DIR / f"{bank_id}.json"
+        out_path.write_text(json.dumps(bank, indent=2, ensure_ascii=False) + "\n",
+                            encoding="utf-8")
+        print(f"  {bank_id}: {len(raw_questions)} questions across {len(domains)} domains "
+              f"→ {out_path.relative_to(ROOT)}")
+    else:
+        print(f"  {bank_id}: {len(raw_questions)} questions across {len(domains)} domains (ok)")
+
+    return bank
+
+
 def build_cert(cert: str, check_only: bool = False) -> dict:
     cert_dir = CERTS_DIR / cert / "resources" / "practice-questions"
     if not cert_dir.exists():
@@ -263,20 +371,35 @@ def main() -> int:
     parser.add_argument("--cert", help="Build only this cert (e.g., data-engineer-associate)")
     parser.add_argument("--check", action="store_true",
                         help="Parse-only; don't write JSON. Non-zero exit if any parse fails.")
+    parser.add_argument("--kind", choices=["practice", "mock", "all"], default="all",
+                        help="Which question banks to build: practice-questions, mock exams, or both (default).")
     args = parser.parse_args()
 
     targets = [args.cert] if args.cert else sorted(CERT_TITLES.keys())
 
     total_qs = 0
-    total_certs = 0
-    for cert in targets:
-        bank = build_cert(cert, check_only=args.check)
-        n = len(bank.get("questions", []))
-        if n:
-            total_qs += n
-            total_certs += 1
-
-    print(f"\n{'Checked' if args.check else 'Built'} {total_certs} cert bank(s), "
+    total_banks = 0
+
+    if args.kind in ("practice", "all"):
+        print("Practice question banks:")
+        for cert in targets:
+            bank = build_cert(cert, check_only=args.check)
+            n = len(bank.get("questions", []))
+            if n:
+                total_qs += n
+                total_banks += 1
+
+    if args.kind in ("mock", "all"):
+        print("\nMock exam banks:")
+        for cert in targets:
+            for exam_n in (1, 2):
+                bank = build_mock(cert, exam_n, check_only=args.check)
+                n = len(bank.get("questions", []))
+                if n:
+                    total_qs += n
+                    total_banks += 1
+
+    print(f"\n{'Checked' if args.check else 'Built'} {total_banks} bank(s), "
           f"{total_qs} question(s) total")
     if not args.check:
         print(f"Output: {DATA_DIR}")
diff --git a/practice/data/data-analyst-associate-mock-1.json b/practice/data/data-analyst-associate-mock-1.json
new file mode 100644
index 0000000..ecf132c
--- /dev/null
+++ b/practice/data/data-analyst-associate-mock-1.json
@@ -0,0 +1,762 @@
+{
+  "cert": "data-analyst-associate-mock-1",
+  "certTitle": "Data Analyst Associate — Mock Exam 1",
+  "blueprintVersion": "Oct 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-sql",
+      "name": "Databricks SQL",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam/questions.md",
+      "questionCount": 10
+    },
+    {
+      "id": "data-management",
+      "name": "Data Management",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "sql-queries",
+      "name": "SQL Queries",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "dashboards-visualization",
+      "name": "Dashboards & Visualization",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam/questions.md",
+      "questionCount": 8
+    },
+    {
+      "id": "analytics-applications",
+      "name": "Analytics Applications",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam/questions.md",
+      "questionCount": 5
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-analyst-associate-mock-1-q001",
+      "domain": "databricks-sql",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "Which SQL warehouse type provides near-instant startup with no cold start delay?",
+      "choices": {
+        "A": "Classic",
+        "B": "Pro",
+        "C": "Serverless",
+        "D": "All warehouse types have instant startup"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Serverless SQL warehouses provide near-instant startup because Databricks manages the compute\ninfrastructure in advance. Classic and Pro warehouses require 2–5 minutes to provision cluster\nnodes before queries can run.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q002",
+      "domain": "databricks-sql",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A team needs 8 concurrent analyst sessions without queue buildup. Which warehouse configuration supports this best?",
+      "choices": {
+        "A": "Classic — single cluster with extra memory",
+        "B": "Pro — multi-cluster auto-scaling up to 10 clusters",
+        "C": "X-Large Classic — larger size reduces queuing",
+        "D": "Assign personal clusters to each analyst"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Pro SQL warehouses support multi-cluster scaling. When one cluster reaches capacity, additional\nclusters spin up automatically (up to the configured maximum of 10). Classic warehouses are\nsingle-cluster only — every session queues behind others when that cluster is at capacity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q003",
+      "domain": "databricks-sql",
+      "title": "Question 3",
+      "difficulty": "easy",
+      "question": "What does the SQL warehouse auto-stop feature do?",
+      "choices": {
+        "A": "Stops all running queries after the configured timeout",
+        "B": "Shuts down warehouse compute when idle for the configured duration (default 120 minutes)",
+        "C": "Stops only Serverless warehouse queries",
+        "D": "Prevents a warehouse from starting if another is already running"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Auto-stop conserves cost by terminating warehouse compute when no queries have run for the\nidle timeout period. The default is 120 minutes. Running queries are never stopped by auto-stop\n— it only triggers when the warehouse is idle.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q004",
+      "domain": "databricks-sql",
+      "title": "Question 4",
+      "difficulty": "easy",
+      "question": "An analyst needs to connect Power BI Desktop to a Databricks SQL warehouse. Which connection protocol should they use?",
+      "choices": {
+        "A": "Delta Sharing",
+        "B": "ODBC or JDBC driver provided by Databricks",
+        "C": "REST API with JSON output",
+        "D": "Direct cloud storage access (S3/ADLS)"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks provides ODBC and JDBC drivers compatible with standard BI tools including Power BI,\nTableau, and Excel. Delta Sharing is for cross-organization data sharing, not BI tool connectivity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q005",
+      "domain": "databricks-sql",
+      "title": "Question 5",
+      "difficulty": "easy",
+      "question": "Row-level security via Unity Catalog row access policies is available on which SQL warehouse types?",
+      "choices": {
+        "A": "Classic and Pro",
+        "B": "Pro and Serverless",
+        "C": "Classic only",
+        "D": "All warehouse types equally"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Row-level security (implemented through Unity Catalog row access policies) requires Pro or\nServerless SQL warehouses. Classic warehouses do not support Unity Catalog's fine-grained\naccess controls such as row filters and column masks.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q006",
+      "domain": "databricks-sql",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "Which Databricks SQL feature helps identify the most expensive queries by cost and duration?",
+      "choices": {
+        "A": "Delta transaction log",
+        "B": "Query History — shows runtime, bytes scanned, and user",
+        "C": "Cluster event logs",
+        "D": "MLflow experiment tracking"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL Query History tracks all queries with execution time, bytes scanned, queue time,\nand the user who ran them. Admins can filter by warehouse, user, and time range to identify\nexpensive or slow queries.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q007",
+      "domain": "databricks-sql",
+      "title": "Question 7",
+      "difficulty": "easy",
+      "question": "Partner Connect in Databricks is used to:",
+      "choices": {
+        "A": "Connect multiple Databricks workspaces to each other",
+        "B": "Establish pre-built integrations with partner tools like dbt, Fivetran, and Tableau with automated credential setup",
+        "C": "Share data with external organizations via Delta Sharing",
+        "D": "Connect to on-premises databases over a VPN"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Partner Connect provides one-click integration setup for certified Databricks partner tools. It\nautomatically creates service principals, generates access tokens, and configures the partner\ntool's connection — eliminating manual credential management.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q008",
+      "domain": "databricks-sql",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "A Serverless SQL warehouse has been idle for 10 minutes with no active queries. What happens next?",
+      "choices": {
+        "A": "It continues running indefinitely until manually stopped",
+        "B": "It automatically scales down and stops, then restarts near-instantly on the next query",
+        "C": "It generates a timeout error for the next submitted query",
+        "D": "It must be restarted manually from the SQL Warehouses UI"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Serverless warehouses auto-stop when idle (default 10 minutes for Serverless vs 120 for\nClassic/Pro). Because compute is managed by Databricks, Serverless warehouses restart\nnear-instantly on the next query — there is no cold-start wait as with Classic/Pro.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q009",
+      "domain": "databricks-sql",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "Which SQL warehouse size is most appropriate for a single analyst running exploratory queries on 10 GB of data?",
+      "choices": {
+        "A": "4X-Large — maximum performance ensures fast results",
+        "B": "X-Small or Small — cost-efficient for single-user exploratory work",
+        "C": "X-Large — minimum recommended size for any analytical query",
+        "D": "Size does not affect query performance for Delta tables"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "X-Small or Small warehouses are cost-efficient for individual analysts running exploratory queries\non moderate data sizes. Larger warehouse sizes are justified for complex queries on very large\ndatasets (100+ GB) or for supporting many concurrent users.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q010",
+      "domain": "databricks-sql",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "A SQL query in Databricks SQL reads from a Delta table. The identical query runs again 30 seconds later with no data changes in between. What happens?",
+      "choices": {
+        "A": "The query re-executes fully on the warehouse",
+        "B": "Results are returned from the query result cache, bypassing warehouse compute",
+        "C": "The second query fails due to a caching conflict",
+        "D": "Query caching only activates after a minimum of 5 minutes between runs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL maintains a query result cache. When the same query runs within the cache TTL\nand the underlying Delta table version has not changed, results are returned from cache\ninstantly — no compute is used. The cache is automatically invalidated when the table is written to.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q011",
+      "domain": "data-management",
+      "title": "Question 11",
+      "difficulty": "easy",
+      "question": "What is the Unity Catalog three-level namespace?",
+      "choices": {
+        "A": "workspace.database.table",
+        "B": "catalog.schema.table",
+        "C": "metastore.catalog.table",
+        "D": "environment.schema.table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog uses `catalog.schema.table`. Schemas in Unity Catalog are equivalent to databases\nin the legacy two-level Hive metastore. The metastore is the top-level container that holds\ncatalogs, but it is not part of the object-reference namespace.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q012",
+      "domain": "data-management",
+      "title": "Question 12",
+      "difficulty": "easy",
+      "question": "A managed Delta table is dropped with `DROP TABLE`. What happens to the underlying data files?",
+      "choices": {
+        "A": "Files remain in DBFS and must be deleted manually",
+        "B": "Files are moved to a recycle bin and retained for 30 days",
+        "C": "Files are permanently deleted along with the table metadata",
+        "D": "Files are archived in cloud storage for 90 days"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Dropping a managed table removes both the table definition from the metastore AND the\nunderlying data files from cloud storage. This operation is irreversible without a backup.\nExternal tables behave differently — only their metadata is removed, leaving files intact.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q013",
+      "domain": "data-management",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "Which GRANT statement gives a user the ability to read data from a Delta table in Unity Catalog?",
+      "choices": {
+        "A": "`GRANT READ ON TABLE catalog.schema.table TO user`",
+        "B": "`GRANT VIEW ON TABLE catalog.schema.table TO user`",
+        "C": "`GRANT SELECT ON TABLE catalog.schema.table TO user`",
+        "D": "`GRANT ACCESS ON TABLE catalog.schema.table TO user`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`SELECT` is the correct privilege name for read access in Unity Catalog. `READ`, `VIEW`, and\n`ACCESS` are not valid Unity Catalog privilege names. Users also typically need `USE CATALOG`\nand `USE SCHEMA` on the parent objects to resolve the table.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q014",
+      "domain": "data-management",
+      "title": "Question 14",
+      "difficulty": "easy",
+      "question": "A data engineer appends data with new columns to an existing Delta table. Which write option enables schema evolution?",
+      "choices": {
+        "A": "`.option(\"autoSchema\", \"true\")`",
+        "B": "`.option(\"mergeSchema\", \"true\")`",
+        "C": "`.option(\"allowNewColumns\", \"true\")`",
+        "D": "No option is needed — Delta always accepts new columns"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mergeSchema=true` (or `spark.databricks.delta.schema.autoMerge.enabled = true` globally)\nenables schema evolution during writes. New columns in the incoming DataFrame are added to the\nDelta table schema automatically. Without this option, a write containing extra columns raises a\nschema mismatch error.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q015",
+      "domain": "data-management",
+      "title": "Question 15",
+      "difficulty": "easy",
+      "question": "An external table pointing to `gs://bucket/data/` is dropped with `DROP TABLE`. What happens to the files in GCS?",
+      "choices": {
+        "A": "Files are deleted from GCS immediately",
+        "B": "Files remain in GCS — only the table metadata entry is removed",
+        "C": "Files are moved to a Databricks-managed DBFS location",
+        "D": "Files are archived by Databricks for 30 days"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "External tables do not own their data. `DROP TABLE` on an external table removes only the\ncatalog metadata entry (table definition). The actual data files in the external storage location\nare completely unaffected.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q016",
+      "domain": "data-management",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "In Unity Catalog, what does `USE CATALOG my_catalog` accomplish?",
+      "choices": {
+        "A": "Creates a new catalog named `my_catalog`",
+        "B": "Sets `my_catalog` as the default catalog for the current session",
+        "C": "Grants the current user access to `my_catalog`",
+        "D": "Lists all objects in `my_catalog`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`USE CATALOG` sets the session's default catalog. Subsequent queries that use two-level names\n(`schema.table`) or single-level names (`table`) resolve against this default catalog. It does\nnot create, grant access to, or list objects in the catalog.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q017",
+      "domain": "data-management",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "Which statement correctly describes Delta Lake ACID transactions?",
+      "choices": {
+        "A": "Delta Lake transactions are eventually consistent, not fully ACID",
+        "B": "Delta tables support Atomicity, Consistency, Isolation, and Durability for all read and write operations",
+        "C": "ACID guarantees apply only to batch writes, not streaming writes",
+        "D": "ACID compliance requires a Unity Catalog metastore to be attached"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake's transaction log (`_delta_log`) provides full ACID guarantees for all operations —\nbatch, streaming, and concurrent reads/writes. This is a core differentiator from plain\nParquet/CSV data lakes, which have no transactional guarantees.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q018",
+      "domain": "data-management",
+      "title": "Question 18",
+      "difficulty": "easy",
+      "question": "What does `SHOW GRANTS ON TABLE catalog.schema.table` return?",
+      "choices": {
+        "A": "The table's schema — column names and data types",
+        "B": "All privileges granted on the table and the principals they are granted to",
+        "C": "The table's storage location and file format",
+        "D": "Recent data access history for the table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`SHOW GRANTS ON <object>` lists all Unity Catalog privileges granted on that specific object:\nthe privilege type (e.g., SELECT, MODIFY), the principal (user, group, or service principal),\nand the grantor. It is the primary tool for auditing object-level permissions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q019",
+      "domain": "data-management",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "A data engineer runs:\n\n```sql\nALTER TABLE t SET TBLPROPERTIES (\n  'delta.deletedFileRetentionDuration' = 'interval 30 days'\n);\n```\n\nWhat does this configure?",
+      "choices": {
+        "A": "VACUUM will retain deleted data files for at least 30 days before removing them",
+        "B": "The table itself expires and is deleted after 30 days",
+        "C": "Deleted data rows are retained for 30 days and can be restored",
+        "D": "The Delta transaction log is compacted and retained for 30 days"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`delta.deletedFileRetentionDuration` sets the minimum file retention period for VACUUM.\nVACUUM will not delete files newer than this threshold, enabling time travel queries up to\n30 days into the past. The default is 7 days.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q020",
+      "domain": "sql-queries",
+      "title": "Question 20",
+      "difficulty": "easy",
+      "question": "Which window function returns the value from the next row in the result set?",
+      "choices": {
+        "A": "`LAG(col, 1)`",
+        "B": "`LEAD(col, 1)`",
+        "C": "`NEXT(col)`",
+        "D": "`OFFSET(col, -1)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`LEAD(column, offset)` returns the value from `offset` rows ahead of the current row within\nthe partition. `LAG` looks backward (previous rows). `NEXT` and `OFFSET` are not valid\nDatabricks SQL window functions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q021",
+      "domain": "sql-queries",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "When two rows have the same value, which function produces gaps in the sequence of rank numbers?",
+      "choices": {
+        "A": "`ROW_NUMBER()` — ties produce gaps",
+        "B": "`RANK()` — tied rows receive the same rank; the next rank skips",
+        "C": "`DENSE_RANK()` — always produces gaps between all ranks",
+        "D": "Both `RANK()` and `ROW_NUMBER()` produce gaps for ties"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`RANK()` gives tied rows the same rank number and then skips the next rank value (e.g., 1, 1,\n3). `ROW_NUMBER()` assigns unique sequential numbers regardless of ties — no gaps, no\nduplicates. `DENSE_RANK()` gives tied rows the same rank but never skips (e.g., 1, 1, 2).",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q022",
+      "domain": "sql-queries",
+      "title": "Question 22",
+      "difficulty": "hard",
+      "question": "A query uses `SUM(revenue) OVER (PARTITION BY region)` with no `ORDER BY` clause. What does each row receive?",
+      "choices": {
+        "A": "A running total that accumulates within the region",
+        "B": "The total sum for the entire region — the same value for every row in that region",
+        "C": "NULL — `ORDER BY` is required for all window functions",
+        "D": "Each row's individual `revenue` value unchanged"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Without `ORDER BY` in the window specification, `SUM() OVER (PARTITION BY ...)` computes the\naggregate over the entire partition and returns that single value for every row in the partition.\nAdding `ORDER BY` changes the frame to a running (cumulative) sum from the first row to the\ncurrent row.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q023",
+      "domain": "sql-queries",
+      "title": "Question 23",
+      "difficulty": "easy",
+      "question": "Which JOIN type returns rows from the left table only when no match exists in the right table?",
+      "choices": {
+        "A": "LEFT JOIN",
+        "B": "LEFT JOIN with `WHERE right_key IS NULL` — this is the only way",
+        "C": "LEFT ANTI JOIN",
+        "D": "EXCEPT"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`LEFT ANTI JOIN` explicitly returns left-table rows where no matching right-table row exists.\nIt is semantically equivalent to `LEFT JOIN ... WHERE right_key IS NULL` but more readable and\nsometimes more efficient. `EXCEPT` operates on full-row set differences, not join conditions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q024",
+      "domain": "sql-queries",
+      "title": "Question 24",
+      "difficulty": "hard",
+      "question": "An analyst writes `WHERE ROW_NUMBER() OVER (PARTITION BY id ORDER BY date DESC) = 1`. The query fails. What is the correct approach?",
+      "choices": {
+        "A": "Use `HAVING` instead of `WHERE`",
+        "B": "Wrap in a CTE and filter on the window result in the outer query, or use `QUALIFY`",
+        "C": "Use the `FILTER` keyword directly after the window function",
+        "D": "Add `GROUP BY` before the `WHERE` clause"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Window functions are evaluated after `WHERE` is applied, so you cannot filter on window\nfunction results in `WHERE`. Two correct approaches:",
+      "explanation": "- Wrap in a CTE: `WITH cte AS (SELECT *, ROW_NUMBER() OVER (...) AS rn FROM t) SELECT * FROM cte WHERE rn = 1`\n- Use `QUALIFY`: `SELECT * FROM t QUALIFY ROW_NUMBER() OVER (...) = 1`"
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q025",
+      "domain": "sql-queries",
+      "title": "Question 25",
+      "difficulty": "medium",
+      "question": "Which function flattens a nested array `[[1, 2], [3, 4]]` into `[1, 2, 3, 4]`?",
+      "choices": {
+        "A": "`EXPLODE(array_col)`",
+        "B": "`FLATTEN(array_col)`",
+        "C": "`COLLECT_LIST(array_col)`",
+        "D": "`ARRAY_UNION(array_col)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`FLATTEN` merges a nested array-of-arrays into a single-level array. `EXPLODE` creates one\nrow per element of the outer array — it does not merge inner arrays. `COLLECT_LIST` and\n`ARRAY_UNION` are aggregation functions, not array transformation functions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q026",
+      "domain": "sql-queries",
+      "title": "Question 26",
+      "difficulty": "easy",
+      "question": "What is the difference between `COLLECT_LIST(product)` and `COLLECT_SET(product)`?",
+      "choices": {
+        "A": "`COLLECT_LIST` preserves insertion order; `COLLECT_SET` sorts alphabetically",
+        "B": "`COLLECT_LIST` includes duplicate values; `COLLECT_SET` returns only unique values",
+        "C": "They are identical — both return all values in the group",
+        "D": "`COLLECT_SET` is faster; `COLLECT_LIST` is used for large datasets only"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`COLLECT_LIST` aggregates all values including duplicates into an array.\n`COLLECT_SET` returns only distinct values. Neither guarantees a specific ordering of\nelements in the resulting array.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q027",
+      "domain": "sql-queries",
+      "title": "Question 27",
+      "difficulty": "easy",
+      "question": "A CTE is defined as `WITH sales AS (SELECT ...)`. How many times can `sales` be referenced in the main query body?",
+      "choices": {
+        "A": "Once only — CTEs are single-use",
+        "B": "Multiple times — CTEs can be referenced as many times as needed in the same query",
+        "C": "Only in the `FROM` clause, once",
+        "D": "CTEs cannot be reused — use subqueries for any reuse pattern"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "CTEs can be referenced multiple times within the same query body. This is a key advantage\nover inline subqueries for readability and avoiding repetition. A CTE defined in a `WITH`\nblock is scoped to the single query statement.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q028",
+      "domain": "sql-queries",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "Which of the following aggregate functions ignores NULL values?",
+      "choices": {
+        "A": "`COUNT(*)` only",
+        "B": "`SUM(column)`, `AVG(column)`, `MIN(column)`, `MAX(column)`, and `COUNT(column)`",
+        "C": "`COUNT(*)` ignores NULLs; all other aggregates treat NULLs as zero",
+        "D": "None — all aggregates in Databricks SQL include NULLs in their calculations"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`SUM`, `AVG`, `MIN`, `MAX`, and `COUNT(column)` all skip NULL values — NULLs are excluded\nfrom the calculation entirely. Only `COUNT(*)` counts NULLs because it counts rows, not\ncolumn values. NULLs are never treated as 0 in standard SQL aggregation.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q029",
+      "domain": "sql-queries",
+      "title": "Question 29",
+      "difficulty": "easy",
+      "question": "`DATEDIFF(end_date, start_date)` — what does this function return in Databricks SQL?",
+      "choices": {
+        "A": "The number of seconds between the two dates",
+        "B": "The number of calendar days from `start_date` to `end_date`",
+        "C": "The number of full months between the two dates",
+        "D": "A formatted string representing the interval"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`DATEDIFF(end, start)` in Databricks SQL returns the number of calendar days between the\ntwo dates as an integer. Note: the end date is the first argument and start date is the\nsecond — the reverse of some other SQL dialects.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q030",
+      "domain": "sql-queries",
+      "title": "Question 30",
+      "difficulty": "easy",
+      "question": "Which SQL expression returns the current timestamp in Databricks SQL?",
+      "choices": {
+        "A": "`GETDATE()`",
+        "B": "`SYSDATE()`",
+        "C": "`current_timestamp()`",
+        "D": "`NOW()` — only this form is valid"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`current_timestamp()` is the canonical Databricks SQL function for the current timestamp.\n`NOW()` is also accepted as a synonym. `GETDATE()` is SQL Server syntax and `SYSDATE()` is\nOracle syntax — neither is native to Databricks SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q031",
+      "domain": "sql-queries",
+      "title": "Question 31",
+      "difficulty": "medium",
+      "question": "Table A has 100 rows and table B has 50 rows. A `CROSS JOIN` is performed. How many rows are in the result?",
+      "choices": {
+        "A": "100 rows",
+        "B": "150 rows",
+        "C": "5,000 rows",
+        "D": "50 rows"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A `CROSS JOIN` produces the Cartesian product of both tables: every row in A is combined\nwith every row in B. 100 × 50 = 5,000 rows. Cross joins are intentional when you need\nall combinations (e.g., generating date-product combinations).",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q032",
+      "domain": "sql-queries",
+      "title": "Question 32",
+      "difficulty": "easy",
+      "question": "An analyst needs to filter rows where a window function result equals 1. Which SQL clause is designed for this purpose?",
+      "choices": {
+        "A": "`HAVING ROW_NUMBER() OVER (...) = 1`",
+        "B": "`WHERE ROW_NUMBER() OVER (...) = 1`",
+        "C": "`QUALIFY ROW_NUMBER() OVER (...) = 1`",
+        "D": "`FILTER ROW_NUMBER() OVER (...) = 1`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`QUALIFY` is the SQL clause specifically designed to filter on window function results. It\nevaluates after window functions are computed, allowing direct filtering on their output.\n`WHERE` and `HAVING` are evaluated before window functions — they cannot reference window\nfunction results. `FILTER` modifies aggregate functions, not window functions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q033",
+      "domain": "dashboards-visualization",
+      "title": "Question 33",
+      "difficulty": "easy",
+      "question": "Which dashboard widget is designed to display a single KPI value prominently, such as \"Total Revenue: $1.2M\"?",
+      "choices": {
+        "A": "Table widget",
+        "B": "Text widget",
+        "C": "Counter widget",
+        "D": "Pivot widget"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Counter widgets are purpose-built for displaying a single prominent metric value. They are\ntypically used for KPIs like total revenue, active user count, or daily order volume. A Text\nwidget displays static markdown; a Table widget shows tabular data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q034",
+      "domain": "dashboards-visualization",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "When is a pie chart the most appropriate visualization choice?",
+      "choices": {
+        "A": "When showing a metric trend over time",
+        "B": "When showing parts of a whole that sum to 100%, with fewer than 6 slices",
+        "C": "When comparing absolute values across many categories",
+        "D": "When one or more values are negative"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Pie charts work best for part-to-whole relationships with few categories (typically fewer than\n6). With more categories, slices become too small to distinguish. Pie charts are not appropriate\nfor time series, negative values, or comparisons where precise magnitude matters.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q035",
+      "domain": "dashboards-visualization",
+      "title": "Question 35",
+      "difficulty": "easy",
+      "question": "How is a refresh schedule configured on a Databricks SQL dashboard?",
+      "choices": {
+        "A": "In the dashboard settings, set the refresh interval and assign a SQL warehouse",
+        "B": "Create a Databricks Job that calls the dashboard API at the desired interval",
+        "C": "Enable auto-refresh in the notebook that provides the dashboard's data",
+        "D": "Dashboards cannot have refresh schedules — only individual queries can be scheduled"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Databricks SQL dashboards have a built-in schedule configuration. From the dashboard settings,\nset the interval (e.g., daily at 8 AM) and select which SQL warehouse will execute the\nunderlying queries. No external Job or notebook is required.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q036",
+      "domain": "dashboards-visualization",
+      "title": "Question 36",
+      "difficulty": "easy",
+      "question": "What is the `{{parameter_name}}` syntax used for in Databricks SQL queries?",
+      "choices": {
+        "A": "Variable substitution in Python notebook cells",
+        "B": "Query parameters — replaced with user-selected values at query runtime",
+        "C": "Column aliasing in SELECT statements",
+        "D": "Referencing the output of a previously run query"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Double curly braces `{{parameter_name}}` are Databricks SQL's query parameter (mustache)\nsyntax. When a query containing this syntax is added to a dashboard, a corresponding filter\nwidget is automatically created. The selected value is injected into the SQL at runtime.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q037",
+      "domain": "dashboards-visualization",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "A SQL alert has the condition `WHEN VALUE > 1000`. The query returns 850. Does the alert fire?",
+      "choices": {
+        "A": "Yes — 850 is close enough to 1000 to trigger",
+        "B": "No — 850 does not satisfy the condition `> 1000`",
+        "C": "Yes — the alert fires whenever the scheduled query runs, regardless of the returned value",
+        "D": "The alert returns an error because the threshold was not met"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The alert evaluates its threshold condition against the query result. Since 850 is not greater\nthan 1000, the condition is false and no notification is sent. The alert re-evaluates on its\nnext scheduled refresh.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q038",
+      "domain": "dashboards-visualization",
+      "title": "Question 38",
+      "difficulty": "easy",
+      "question": "Which notification destination is NOT natively supported by Databricks SQL alerts?",
+      "choices": {
+        "A": "Email",
+        "B": "Slack via webhook",
+        "C": "PagerDuty",
+        "D": "SMS text message"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Databricks SQL alerts natively support email, Slack (via webhook), PagerDuty, and custom\nwebhooks. SMS is not a built-in destination. SMS notifications could be achieved by routing\nthrough a custom webhook to an SMS gateway service.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q039",
+      "domain": "dashboards-visualization",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A Lakeview Dashboard is shared with a user with \"Can View\" permission. What can that user do?",
+      "choices": {
+        "A": "Edit the underlying query SQL",
+        "B": "View the dashboard, interact with filter widgets, and export data — but not modify queries or layout",
+        "C": "Create new visualization widgets on the dashboard",
+        "D": "Change the dashboard's refresh schedule"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "\"Can View\" permission allows a user to view the dashboard and interact with filter parameters.\nThey can also export data from individual visualizations. They cannot edit SQL queries, change\nthe layout, add widgets, or modify the refresh schedule.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q040",
+      "domain": "dashboards-visualization",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "An analyst creates a line chart with `date` on the X-axis and `revenue` on the Y-axis. They want separate lines per region. Which configuration achieves this?",
+      "choices": {
+        "A": "Set \"Group By\" or \"Series\" to the `region` column in the chart configuration",
+        "B": "Create a separate chart for each region manually",
+        "C": "Write a `PIVOT` in the underlying SQL to create one column per region",
+        "D": "Set the chart color scheme to map colors by `revenue` value"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Databricks SQL chart visualizations have a \"Group By\" or \"Series\" configuration option. Setting\nit to the `region` column automatically creates one line per distinct region value. This\napproach is more maintainable than pivoting in SQL, as new regions appear automatically.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q041",
+      "domain": "analytics-applications",
+      "title": "Question 41",
+      "difficulty": "easy",
+      "question": "A dashboard filter passes a selected date to all underlying queries. Which SQL snippet correctly uses this parameter?",
+      "choices": {
+        "A": "`WHERE order_date = :selected_date`",
+        "B": "`WHERE order_date = {{selected_date}}`",
+        "C": "`WHERE order_date = @selected_date`",
+        "D": "`WHERE order_date = $selected_date`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`{{parameter_name}}` is the Databricks SQL parameter substitution syntax. The value selected\nin the dashboard filter widget is injected into the query at runtime. The colon (`:`) syntax\nis used in some other SQL tools but not Databricks SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q042",
+      "domain": "analytics-applications",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "An analyst needs a summary table refreshed nightly without manually running the query. What is the most appropriate approach?",
+      "choices": {
+        "A": "Open Databricks SQL each morning and run the query manually",
+        "B": "Schedule the query in Databricks SQL to run nightly at midnight using a SQL warehouse",
+        "C": "Write a Python script that runs on the analyst's laptop at midnight",
+        "D": "Use Lakeflow Declarative Pipelines — it is the only supported option for automated query execution"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL has built-in query scheduling. Configure a schedule (e.g., nightly at midnight),\nselect a SQL warehouse, and the platform runs the query automatically. No external scripts,\njobs, or Lakeflow Declarative Pipelines are required for simple scheduled query execution.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q043",
+      "domain": "analytics-applications",
+      "title": "Question 43",
+      "difficulty": "hard",
+      "question": "A sales dashboard shows different data per sales rep based on who is logged in. This behavior is implemented with:",
+      "choices": {
+        "A": "Separate dashboard copies for each sales rep",
+        "B": "A dashboard parameter pre-populated with the logged-in user's name",
+        "C": "A Unity Catalog row-level security policy on the underlying table",
+        "D": "A Python UDF in the dashboard query that filters by session user"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Unity Catalog row-level security policies automatically filter rows based on the current\nuser's identity at query time. The dashboard query returns data appropriate for the logged-in\nuser with no dashboard-level configuration needed. This is more secure than parameter-based\nfiltering, which a user could potentially bypass.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q044",
+      "domain": "analytics-applications",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "A query result cache serves stale data after an ETL pipeline writes new data to the underlying Delta table. What invalidates the cache?",
+      "choices": {
+        "A": "The 24-hour cache TTL expiring",
+        "B": "Writing to the underlying Delta table — cache invalidation is automatic",
+        "C": "Running a manual cache clear command on the warehouse",
+        "D": "Restarting the SQL warehouse"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL result cache tracks Delta table versions via the transaction log. When new data\nis written to a Delta table (a new transaction is logged), the cache for all queries touching\nthat table is automatically invalidated. The next query re-executes against fresh data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-1-q045",
+      "domain": "analytics-applications",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "Which approach is the documented and safest fit?",
+      "choices": {
+        "A": "Standard view: `CREATE VIEW gold.daily_revenue AS SELECT date, SUM(amount) ... GROUP BY date`",
+        "B": "Materialized view: `CREATE MATERIALIZED VIEW gold.daily_revenue AS ...` with an hourly refresh schedule",
+        "C": "Pin the dashboard to a Pro SQL Warehouse with result caching enabled",
+        "D": "Convert the orders table to bucketing on date"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Genie Spaces is the documented natural-language analytics surface for exactly this use case. UC permissions, including column masks and row filters, apply to every Genie-generated SQL query — so CS users physically cannot see PII columns they're not granted on, regardless of how Genie phrases the question. Option A reinvents Genie poorly. Option C duplicates data and creates a refresh / drift problem. Option D is a retrieval-augmentation pattern over *unstructured* data — vector search returns similar rows by embedding distance, which is the wrong tool for structured analytic queries (counts, aggregates, joins).",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-analyst-associate"
+}
diff --git a/practice/data/data-analyst-associate-mock-2.json b/practice/data/data-analyst-associate-mock-2.json
new file mode 100644
index 0000000..b2c906e
--- /dev/null
+++ b/practice/data/data-analyst-associate-mock-2.json
@@ -0,0 +1,762 @@
+{
+  "cert": "data-analyst-associate-mock-2",
+  "certTitle": "Data Analyst Associate — Mock Exam 2",
+  "blueprintVersion": "Oct 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-sql",
+      "name": "Databricks SQL",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 10
+    },
+    {
+      "id": "data-management",
+      "name": "Data Management",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "sql-queries",
+      "name": "SQL Queries",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "dashboards-visualization",
+      "name": "Dashboards & Visualization",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 8
+    },
+    {
+      "id": "analytics-applications",
+      "name": "Analytics Applications",
+      "sourceFile": "certifications/data-analyst-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 5
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-analyst-associate-mock-2-q001",
+      "domain": "databricks-sql",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "An analyst uses Python to programmatically query Databricks SQL and retrieve results as a DataFrame. Which connection method is most appropriate for this use case?",
+      "choices": {
+        "A": "ODBC driver — best for interactive desktop BI tools",
+        "B": "JDBC driver — best for Java-based applications",
+        "C": "Databricks SQL Connector for Python (`databricks-sql-connector`) via the Python driver",
+        "D": "Delta Sharing — enables programmatic data access"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The Databricks SQL Connector for Python (`databricks-sql-connector`) is the recommended driver\nfor Python applications querying Databricks SQL. It uses the Thrift protocol over HTTPS and\nreturns results as Python data structures compatible with pandas. ODBC and JDBC are typically\nused by BI tools and JVM-based apps, not Python scripts.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q002",
+      "domain": "databricks-sql",
+      "title": "Question 2",
+      "difficulty": "hard",
+      "question": "A Pro SQL warehouse is configured with `max clusters = 3`. When does a third cluster spin up?",
+      "choices": {
+        "A": "When the first query is submitted",
+        "B": "When both existing clusters are fully utilized and new queries are waiting in queue",
+        "C": "When the warehouse has been running for more than 1 hour",
+        "D": "When any query takes longer than 60 seconds"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-cluster scaling in Pro warehouses is demand-driven. A new cluster spins up only when\nexisting clusters are at capacity and queries are queuing. With `max clusters = 3`, the third\ncluster starts when both the first and second clusters are fully loaded. Clusters scale back\ndown when demand decreases.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q003",
+      "domain": "databricks-sql",
+      "title": "Question 3",
+      "difficulty": "easy",
+      "question": "What does Photon acceleration do in Databricks SQL?",
+      "choices": {
+        "A": "Compresses Delta table files to reduce storage costs",
+        "B": "Replaces the JVM-based Spark SQL engine with a native C++ vectorized execution engine for faster query performance",
+        "C": "Caches query results in memory for instant replay",
+        "D": "Accelerates only Python notebook cells, not SQL queries"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Photon is Databricks' native C++ vectorized query engine that replaces parts of the JVM-based\nSpark execution engine. It is optimized for analytical SQL workloads and significantly improves\nperformance for scans, aggregations, joins, and sort operations on large datasets. Photon is\nenabled by default on Serverless and Pro warehouses.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q004",
+      "domain": "databricks-sql",
+      "title": "Question 4",
+      "difficulty": "easy",
+      "question": "What does Databricks SQL query federation enable?",
+      "choices": {
+        "A": "Running the same query on multiple SQL warehouses simultaneously",
+        "B": "Querying external data sources (e.g., MySQL, PostgreSQL) directly from Databricks SQL without copying data",
+        "C": "Federating access control between multiple Unity Catalog metastores",
+        "D": "Sharing queries between different Databricks workspaces"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Query federation allows Databricks SQL to query external databases (MySQL, PostgreSQL,\nSnowflake, etc.) directly via a connection object defined in Unity Catalog. Data is not\ncopied into Databricks — queries push down to the source where possible and retrieve\nresults on demand.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q005",
+      "domain": "databricks-sql",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "A Serverless SQL warehouse is idle with no queries running. Does it incur compute charges during this idle period?",
+      "choices": {
+        "A": "Yes — Serverless warehouses charge continuously once started",
+        "B": "No — Serverless warehouses auto-stop when idle and billing pauses; charges resume only when queries run",
+        "C": "Yes — Serverless warehouses charge a reduced standby rate while idle",
+        "D": "No — Serverless warehouses are always free during idle periods regardless of configuration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Serverless SQL warehouses auto-stop when idle (default 10 minutes). Once stopped, no compute\ncharges accrue. Billing resumes only when the next query arrives and the warehouse wakes up.\nThis pay-per-use model is a primary cost advantage of Serverless over Classic/Pro warehouses,\nwhich charge for the full uptime even when idle.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q006",
+      "domain": "databricks-sql",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "Which Databricks workspace role is required to create a new SQL warehouse?",
+      "choices": {
+        "A": "Any authenticated user can create a SQL warehouse",
+        "B": "Users with the \"Can Use\" permission on an existing warehouse",
+        "C": "Workspace Admin or users explicitly granted the \"Create SQL warehouse\" entitlement",
+        "D": "Only the account admin can create SQL warehouses"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Creating a SQL warehouse requires either Workspace Admin privileges or the \"Create SQL\nwarehouse\" entitlement explicitly granted to the user by an admin. Regular workspace users\ncan use existing warehouses they have permission on, but cannot create new ones without\nthis entitlement.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q007",
+      "domain": "databricks-sql",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "What is the difference between Query Profile and `EXPLAIN` in Databricks SQL?",
+      "choices": {
+        "A": "They are identical — both show the query execution plan",
+        "B": "`EXPLAIN` shows the logical/physical query plan before execution; Query Profile shows actual runtime metrics (rows processed, time per stage) after execution",
+        "C": "Query Profile works only for streaming queries; `EXPLAIN` works for batch only",
+        "D": "`EXPLAIN` requires admin privileges; Query Profile is available to all users"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`EXPLAIN` outputs the query plan (logical, analyzed, optimized, or physical) before the query\nruns — it is a planning-time tool. Query Profile (available in Query History) shows actual\nruntime metrics after execution: rows read per node, execution time per stage, bytes shuffled,\nand skew information. Both are useful for optimization but serve different purposes.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q008",
+      "domain": "databricks-sql",
+      "title": "Question 8",
+      "difficulty": "easy",
+      "question": "How long are query results cached in Databricks SQL by default?",
+      "choices": {
+        "A": "5 minutes",
+        "B": "1 hour",
+        "C": "24 hours",
+        "D": "Until the SQL warehouse is restarted"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks SQL caches query results for up to 24 hours by default. The cache is invalidated\nearlier if the underlying Delta table is written to (a new transaction is logged). This ensures\nthat cached results are never served for tables with new data, regardless of the TTL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q009",
+      "domain": "databricks-sql",
+      "title": "Question 9",
+      "difficulty": "hard",
+      "question": "A SQL warehouse is configured with auto-stop set to 30 minutes. A long-running query has been executing for 25 minutes. What happens at the 30-minute mark?",
+      "choices": {
+        "A": "The warehouse stops and the query is terminated",
+        "B": "The auto-stop timer does not apply to active queries — the warehouse stops only after the query completes and the idle period begins",
+        "C": "The query is paused and resumed when the warehouse restarts",
+        "D": "The warehouse sends a warning but continues running for another 30 minutes"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Auto-stop only triggers when the warehouse is idle — no active queries running. If a query is\nin progress, the idle timer resets. The warehouse will not stop while queries are executing,\nregardless of the configured auto-stop duration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q010",
+      "domain": "databricks-sql",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "What is a key difference between Databricks SQL and running SQL in a Databricks notebook?",
+      "choices": {
+        "A": "Notebooks support Delta tables; Databricks SQL does not",
+        "B": "Databricks SQL provides a purpose-built interface with query history, dashboards, alerts, and scheduled queries — notebooks require custom code for these capabilities",
+        "C": "Notebooks use the Unity Catalog; Databricks SQL uses only the Hive metastore",
+        "D": "Databricks SQL only supports SELECT statements; notebooks support all SQL commands"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL is a purpose-built analytics interface with built-in query history, result\ncaching, dashboarding, alerting, and scheduled query execution. SQL in notebooks requires\ncustom code or Jobs to replicate these capabilities. Both interfaces support the same\nunderlying Delta tables and Unity Catalog.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q011",
+      "domain": "data-management",
+      "title": "Question 11",
+      "difficulty": "easy",
+      "question": "Which SQL command lists all tables visible in the current schema within Unity Catalog?",
+      "choices": {
+        "A": "`LIST TABLES`",
+        "B": "`SHOW TABLES`",
+        "C": "`DESCRIBE SCHEMA`",
+        "D": "`SELECT * FROM information_schema.tables LIMIT 10`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`SHOW TABLES` (optionally `SHOW TABLES IN schema_name`) lists all tables and views in the\ncurrent or specified schema. `DESCRIBE SCHEMA` shows schema metadata, not its table contents.\n`INFORMATION_SCHEMA.TABLES` also works but requires a full SELECT query.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q012",
+      "domain": "data-management",
+      "title": "Question 12",
+      "difficulty": "hard",
+      "question": "A data engineer wants to grant a user the ability to read only the `email` column in a table, not the `ssn` column. Which Unity Catalog feature enables this?",
+      "choices": {
+        "A": "Row-level security policy",
+        "B": "Column-level permissions via `GRANT SELECT (column_name) ON TABLE ...`",
+        "C": "Table clone with only the allowed columns",
+        "D": "A view that selects only `email`, with SELECT granted on the view"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog supports column-level permissions: `GRANT SELECT (email) ON TABLE t TO user`.\nThis restricts the user to only the specified columns. Selecting `ssn` in a query will fail\nwith a permission denied error. Creating a view (Option D) also works but requires maintaining\nan additional object.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q013",
+      "domain": "data-management",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "Which SQL syntax queries a Delta table as it existed at a specific version?",
+      "choices": {
+        "A": "`SELECT * FROM table AT VERSION = 5`",
+        "B": "`SELECT * FROM table VERSION AS OF 5`",
+        "C": "`SELECT * FROM table WHERE _version = 5`",
+        "D": "`SELECT * FROM table SNAPSHOT VERSION 5`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`VERSION AS OF <n>` is the Delta Lake time travel syntax for querying a specific version.\nThe equivalent timestamp syntax is `TIMESTAMP AS OF '<timestamp>'`. Both are standard\nDelta Lake time travel expressions supported in Databricks SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q014",
+      "domain": "data-management",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "In Unity Catalog, what does `GRANT USE SCHEMA ON SCHEMA catalog.schema TO user` allow the user to do?",
+      "choices": {
+        "A": "Create new tables in the schema",
+        "B": "Resolve and access objects within the schema — required before any table-level privilege takes effect",
+        "C": "Delete the schema and its contents",
+        "D": "Grant other users access to the schema"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`USE SCHEMA` is a prerequisite privilege in Unity Catalog. Without it, a user cannot resolve\nany objects within the schema even if they have SELECT on individual tables. `USE CATALOG`\non the parent catalog is also required. These privileges form a hierarchy: catalog → schema\n→ table.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q015",
+      "domain": "data-management",
+      "title": "Question 15",
+      "difficulty": "easy",
+      "question": "A schema named `analytics` does not yet exist. Which SQL statement creates it only if it is absent, without raising an error?",
+      "choices": {
+        "A": "`CREATE SCHEMA analytics IGNORE IF EXISTS`",
+        "B": "`CREATE SCHEMA IF NOT EXISTS analytics`",
+        "C": "`CREATE OR REPLACE SCHEMA analytics`",
+        "D": "`UPSERT SCHEMA analytics`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CREATE SCHEMA IF NOT EXISTS schema_name` creates the schema only if it does not already\nexist. Without `IF NOT EXISTS`, the command raises an error if the schema already exists.\n`CREATE OR REPLACE` is valid for views and functions, not schemas.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q016",
+      "domain": "data-management",
+      "title": "Question 16",
+      "difficulty": "medium",
+      "question": "What is the difference between a `SHALLOW CLONE` and a `DEEP CLONE` of a Delta table?",
+      "choices": {
+        "A": "Shallow clone copies all data files; deep clone copies only metadata",
+        "B": "Shallow clone copies only metadata and references the source data files; deep clone copies both metadata and all data files",
+        "C": "They are identical — both copy all data and metadata",
+        "D": "Shallow clone supports time travel; deep clone does not"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`SHALLOW CLONE` creates a new table with its own transaction log but references the original\ndata files — no data is physically copied. It is fast and storage-efficient but depends on the\nsource files remaining available. `DEEP CLONE` copies all data files and the transaction log,\ncreating a fully independent copy suitable for backup or migration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q017",
+      "domain": "data-management",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "When is `CONVERT TO DELTA` needed?",
+      "choices": {
+        "A": "When upgrading from Delta Lake version 1 to version 3",
+        "B": "When converting an existing Parquet table (or Parquet-based Hive table) to Delta format",
+        "C": "When migrating from Hive metastore to Unity Catalog",
+        "D": "When enabling Photon on a Delta table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CONVERT TO DELTA parquet.'/path/to/table'` converts an existing Parquet table to Delta\nformat in-place — it adds the Delta transaction log (`_delta_log`) without rewriting data\nfiles. This is the standard migration path for teams moving from plain Parquet to Delta Lake.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q018",
+      "domain": "data-management",
+      "title": "Question 18",
+      "difficulty": "medium",
+      "question": "What does \"attaching a workspace to a Unity Catalog metastore\" mean?",
+      "choices": {
+        "A": "Connecting the workspace's network to the metastore's VNet",
+        "B": "Linking the workspace so that it uses the specified metastore for all catalog, schema, and table metadata — enabling Unity Catalog governance",
+        "C": "Granting the workspace admin access to all catalogs in the metastore",
+        "D": "Copying the workspace's existing Hive metastore tables into Unity Catalog"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A Unity Catalog metastore is a regional metadata store. Attaching a workspace to a metastore\nmeans the workspace uses that metastore for all Unity Catalog objects. Multiple workspaces in\nthe same region can share a single metastore, enabling cross-workspace data governance and\nsharing through a unified catalog.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q019",
+      "domain": "data-management",
+      "title": "Question 19",
+      "difficulty": "easy",
+      "question": "What information is available in `INFORMATION_SCHEMA.COLUMNS` for a Unity Catalog schema?",
+      "choices": {
+        "A": "The current row count for each table",
+        "B": "Column names, data types, nullability, and ordinal position for all tables in the schema",
+        "C": "The access history for each column",
+        "D": "Column-level statistics used by the query optimizer"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`INFORMATION_SCHEMA.COLUMNS` is a standard SQL information schema view that lists all columns\nacross tables in the schema, including column name, data type, ordinal position, and whether\nthe column is nullable. It is the standard way to programmatically inspect table schemas in\nUnity Catalog.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q020",
+      "domain": "sql-queries",
+      "title": "Question 20",
+      "difficulty": "hard",
+      "question": "A window function uses the frame clause `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`. What does this compute?",
+      "choices": {
+        "A": "The aggregate over the entire partition, ignoring the current row's position",
+        "B": "A running (cumulative) aggregate from the first row of the partition to the current row",
+        "C": "The aggregate over a 30-day rolling window",
+        "D": "The aggregate between the first and last rows of the entire result set"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW` defines a frame that starts at the\nfirst row of the partition and ends at the current row. Combined with `SUM` or `COUNT`,\nthis produces a running (cumulative) total. `UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`\nwould span the entire partition.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q021",
+      "domain": "sql-queries",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "`NTILE(4) OVER (ORDER BY revenue DESC)` — what does this function do?",
+      "choices": {
+        "A": "Returns the top 4 rows by revenue",
+        "B": "Divides the result set into 4 equal-sized buckets and assigns each row a bucket number (1–4)",
+        "C": "Returns the revenue values at the 25th, 50th, 75th, and 100th percentiles",
+        "D": "Counts the number of distinct revenue values in each quartile"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`NTILE(n)` divides the ordered result set into `n` equal-sized buckets and assigns each row\na bucket number from 1 to n. With `NTILE(4)` ordered by `revenue DESC`, bucket 1 contains\nthe top quartile earners and bucket 4 contains the bottom quartile. Rows are distributed as\nevenly as possible across buckets.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q022",
+      "domain": "sql-queries",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "What does `LPAD('42', 6, '0')` return?",
+      "choices": {
+        "A": "`'420000'`",
+        "B": "`'000042'`",
+        "C": "`'42    '`",
+        "D": "`'42'`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`LPAD(string, target_length, pad_character)` left-pads the string to the target length using\nthe pad character. `LPAD('42', 6, '0')` produces `'000042'` — four zeros prepended to make\nthe total length 6. `RPAD` would pad on the right instead.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q023",
+      "domain": "sql-queries",
+      "title": "Question 23",
+      "difficulty": "hard",
+      "question": "Which operator tests for equality between two values including the case where both are NULL?",
+      "choices": {
+        "A": "`=`",
+        "B": "`IS NOT DISTINCT FROM`",
+        "C": "`<=>`",
+        "D": "Both B and C are correct"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Standard `=` returns NULL (not TRUE) when either operand is NULL, so `NULL = NULL` evaluates\nto NULL (not TRUE). Both `<=>` (null-safe equality, Spark SQL) and `IS NOT DISTINCT FROM`\n(standard SQL) return TRUE when both sides are NULL. In Databricks SQL, both syntaxes are\nsupported.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q024",
+      "domain": "sql-queries",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "What is the difference between `COALESCE(a, b, c)` and `IFNULL(a, b)`?",
+      "choices": {
+        "A": "They are identical — `IFNULL` is just an alias for `COALESCE`",
+        "B": "`COALESCE` accepts two or more arguments and returns the first non-NULL; `IFNULL` accepts exactly two arguments and returns the second if the first is NULL",
+        "C": "`IFNULL` is for numeric types only; `COALESCE` works on all types",
+        "D": "`COALESCE` short-circuits evaluation; `IFNULL` always evaluates all arguments"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`COALESCE(a, b, c, ...)` accepts two or more arguments and returns the first non-NULL value\nin the list. `IFNULL(a, b)` is a two-argument shorthand that returns `b` when `a` is NULL.\n`IFNULL(a, b)` is functionally equivalent to `COALESCE(a, b)`. `NVL` (Oracle-derived) is\nanother synonym for the two-argument form, also supported in Databricks SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q025",
+      "domain": "sql-queries",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "What does `SPLIT('hello,world,foo', ',')` return?",
+      "choices": {
+        "A": "The number of commas in the string",
+        "B": "An array: `['hello', 'world', 'foo']`",
+        "C": "A single string with commas removed: `'helloworldfoo'`",
+        "D": "Three separate rows: `'hello'`, `'world'`, `'foo'`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`SPLIT(string, delimiter)` returns an array of strings split by the delimiter. To convert the\narray into separate rows, use `EXPLODE(SPLIT(...))`. `SPLIT` alone returns a single array\nvalue in one row.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q026",
+      "domain": "sql-queries",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "`DATE_TRUNC('month', '2025-07-15')` — what does this return?",
+      "choices": {
+        "A": "`'2025-07-15'` — no change for a date value",
+        "B": "`'2025-07-01'` — truncates to the first day of the month",
+        "C": "`'2025-01-01'` — truncates to the first month of the year",
+        "D": "`'2025-07-31'` — rounds to the last day of the month"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`DATE_TRUNC(unit, date)` truncates a date or timestamp to the specified unit. Truncating to\n`'month'` sets the day to 1 and (for timestamps) clears time components. The result is\n`2025-07-01`. Common units: `'year'`, `'quarter'`, `'month'`, `'week'`, `'day'`, `'hour'`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q027",
+      "domain": "sql-queries",
+      "title": "Question 27",
+      "difficulty": "medium",
+      "question": "An analyst needs to count orders where `status = 'completed'` within a larger aggregation query. Which SQL expression achieves this without a subquery?",
+      "choices": {
+        "A": "`COUNT(*) FILTER (WHERE status = 'completed')`",
+        "B": "`SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END)`",
+        "C": "Both A and B are correct",
+        "D": "`COUNT_IF(status = 'completed')`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "All three approaches produce the same result. `SUM(CASE WHEN ...)` is the most portable\nacross SQL dialects. `FILTER (WHERE ...)` is ANSI SQL standard and supported in Databricks\nSQL. `COUNT_IF(condition)` is a Databricks-specific shorthand. All avoid subqueries and\nwork inline with other aggregations in the same `SELECT`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q028",
+      "domain": "sql-queries",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "An analyst uses a `CROSS JOIN` between a `products` table (500 rows) and a `dates` table (365 rows) to generate all product-date combinations. How many rows does the result contain?",
+      "choices": {
+        "A": "865 rows (500 + 365)",
+        "B": "182,500 rows (500 × 365)",
+        "C": "500 rows — the larger table determines row count",
+        "D": "365 rows — the smaller table determines row count"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A `CROSS JOIN` produces the Cartesian product of both tables: every row in `products` paired\nwith every row in `dates`. 500 × 365 = 182,500 rows. Generating all product-date combinations\nfor a sales grid or template table is a classic valid use case for `CROSS JOIN`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q029",
+      "domain": "sql-queries",
+      "title": "Question 29",
+      "difficulty": "hard",
+      "question": "A query uses `WHERE product_id NOT IN (SELECT product_id FROM returns)`. The `returns` table contains one NULL in `product_id`. What result does the main query return?",
+      "choices": {
+        "A": "All rows where `product_id` is not in the non-NULL values of `returns`",
+        "B": "Zero rows — `NOT IN` with a subquery containing NULL always returns an empty result",
+        "C": "An error — NULL values are not permitted in `NOT IN` subqueries",
+        "D": "The same result as using `NOT EXISTS`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "This is a classic SQL null-trap. `NOT IN` evaluates as `value != x AND value != y AND value != NULL`.\nSince any comparison with NULL returns UNKNOWN (not TRUE), the entire `NOT IN` condition\nbecomes UNKNOWN for every row — and only TRUE rows pass the WHERE filter. The result is zero\nrows. Use `NOT EXISTS` or filter NULLs from the subquery to avoid this behavior.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q030",
+      "domain": "sql-queries",
+      "title": "Question 30",
+      "difficulty": "easy",
+      "question": "What does the `INTERSECT` set operator return?",
+      "choices": {
+        "A": "All rows from both queries combined, with duplicates removed",
+        "B": "Only rows that appear in both query result sets",
+        "C": "Rows from the first query that do not appear in the second query",
+        "D": "All rows from both queries, including duplicates"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`INTERSECT` returns only rows that appear in both query results (the set intersection).\n`UNION` combines all rows (removing duplicates), `UNION ALL` combines with duplicates,\nand `EXCEPT` (or `MINUS`) returns rows in the first set not in the second.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q031",
+      "domain": "sql-queries",
+      "title": "Question 31",
+      "difficulty": "easy",
+      "question": "What does the `EXCEPT` set operator return?",
+      "choices": {
+        "A": "Rows that appear in either the first or second query, but not both",
+        "B": "Rows from the first query result that do not appear in the second query result",
+        "C": "Rows from the second query result that do not appear in the first query result",
+        "D": "The symmetric difference of both result sets"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`EXCEPT` returns rows present in the first query's result but absent from the second query's\nresult. It removes duplicates by default (use `EXCEPT ALL` to retain them). This is equivalent\nto a `LEFT ANTI JOIN` on the full set of columns.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q032",
+      "domain": "sql-queries",
+      "title": "Question 32",
+      "difficulty": "hard",
+      "question": "An analyst writes: `SELECT region, revenue, DENSE_RANK() OVER (ORDER BY revenue DESC) AS dr FROM sales QUALIFY dr <= 3`. What does this return?",
+      "choices": {
+        "A": "The top 3 revenue rows only",
+        "B": "All rows where the dense rank of revenue is 1, 2, or 3 — multiple rows per rank if tied",
+        "C": "An error — `QUALIFY` cannot be used with `DENSE_RANK()`",
+        "D": "The top 3 distinct revenue values with one row each"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`DENSE_RANK()` assigns the same rank to tied rows and never skips rank numbers. `QUALIFY dr <= 3`\nkeeps all rows where the dense rank is 1, 2, or 3. If three rows share rank 1, all three are\nreturned. This pattern is useful for returning the top-N ranked groups including all ties.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q033",
+      "domain": "dashboards-visualization",
+      "title": "Question 33",
+      "difficulty": "easy",
+      "question": "A Databricks SQL dashboard contains a Text widget with markdown content. What is the primary use case for a Text widget?",
+      "choices": {
+        "A": "Displaying a live query result in formatted text",
+        "B": "Adding static documentation, instructions, section headings, or context to a dashboard",
+        "C": "Showing the last refresh timestamp automatically",
+        "D": "Embedding an external URL in the dashboard"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Text widgets render static markdown content — headings, explanatory text, instructions, or\nlinks. They are used to add context and documentation to dashboards. Text widgets do not\nexecute queries or display live data. For a live single-metric display, use a Counter widget.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q034",
+      "domain": "dashboards-visualization",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "A dashboard has four permission levels. Which level allows a user to run queries and see updated results, but not change query SQL or dashboard layout?",
+      "choices": {
+        "A": "Can View",
+        "B": "Can Run",
+        "C": "Can Edit",
+        "D": "Owner"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "\"Can Run\" allows a user to trigger a dashboard refresh (re-execute underlying queries) and\nview the updated results. \"Can View\" shows the last cached results only — no refresh capability.\n\"Can Edit\" allows modifying queries and layout. \"Owner\" has full control including deletion.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q035",
+      "domain": "dashboards-visualization",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A single SQL query returns columns for `region`, `product`, and `revenue`. An analyst wants both a bar chart and a table visualization from this same query result. What should they do?",
+      "choices": {
+        "A": "Run the query twice and create one visualization from each run",
+        "B": "Add multiple visualizations to the same query — Databricks SQL allows multiple visualizations per query result",
+        "C": "Create two separate queries with identical SQL",
+        "D": "Use a UNION to combine the data for the chart and the table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "In Databricks SQL, a single query can have multiple visualizations attached to it. Each\nvisualization (bar chart, table, pie chart, counter, etc.) draws from the same query result.\nWhen the query refreshes, all visualizations update together. This avoids duplicating query\nlogic.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q036",
+      "domain": "dashboards-visualization",
+      "title": "Question 36",
+      "difficulty": "easy",
+      "question": "Which export options are available from a Databricks SQL dashboard visualization?",
+      "choices": {
+        "A": "PDF of the full dashboard page",
+        "B": "CSV download of the underlying query result for individual visualizations",
+        "C": "Excel (.xlsx) format only",
+        "D": "Both A and B are available"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Databricks SQL supports downloading individual visualization data as CSV (from the\nvisualization's kebab menu) and downloading a PDF snapshot of the full dashboard. This\nenables analysts to share static snapshots or extract data for external use.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q037",
+      "domain": "dashboards-visualization",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "When configuring a Databricks SQL alert, which field allows customizing the email subject line?",
+      "choices": {
+        "A": "Alerts do not support custom email subjects — a system-generated subject is always used",
+        "B": "The \"Custom subject\" field in the alert notification settings",
+        "C": "The alert name automatically becomes the email subject",
+        "D": "Email subjects can only be customized via a webhook integration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When configuring an alert's notification destinations, Databricks SQL provides a \"Custom\nsubject\" field for email notifications. This allows the alert creator to specify a descriptive\nsubject line such as \"ALERT: Revenue dropped below threshold\" instead of the default\nsystem-generated subject.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q038",
+      "domain": "dashboards-visualization",
+      "title": "Question 38",
+      "difficulty": "hard",
+      "question": "A dashboard is scheduled to refresh daily using Warehouse A. Warehouse A is then deleted by an admin. What happens to the scheduled refresh?",
+      "choices": {
+        "A": "The refresh fails and the dashboard owner receives an error notification",
+        "B": "The refresh automatically switches to the default warehouse",
+        "C": "The refresh runs on any available warehouse in the workspace",
+        "D": "The refresh silently fails with no notification until manually reconfigured"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The scheduled refresh fails because the assigned warehouse no longer exists. The dashboard\nowner receives a failure notification. The refresh does not automatically migrate to another\nwarehouse — an admin or owner must update the dashboard's refresh schedule to select a\nnew warehouse.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q039",
+      "domain": "dashboards-visualization",
+      "title": "Question 39",
+      "difficulty": "hard",
+      "question": "An analyst creates a bar chart and wants the bars for `revenue > 1,000,000` to appear in green and all others in gray. How is this achieved?",
+      "choices": {
+        "A": "This conditional coloring is not supported — all bars use a single color",
+        "B": "Use a `CASE WHEN` in SQL to add a category column, then use that column as the \"Color\" or \"Group By\" dimension in the chart",
+        "C": "Write a Python script to post-process the chart colors",
+        "D": "Use the chart's \"Threshold\" option to set color ranges"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "To achieve conditional coloring, add a computed category column in SQL:\n`CASE WHEN revenue > 1000000 THEN 'High' ELSE 'Normal' END AS revenue_tier`.\nSet the chart's \"Color\" or \"Group By\" to `revenue_tier` and assign colors per category\nin the chart configuration. This is the standard pattern for conditional visualization\nstyling in Databricks SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q040",
+      "domain": "dashboards-visualization",
+      "title": "Question 40",
+      "difficulty": "hard",
+      "question": "A team wants to schedule one dashboard to refresh every hour on a high-capacity warehouse during business hours and use a smaller warehouse for the nightly refresh to save cost. How can this be achieved?",
+      "choices": {
+        "A": "This is not possible — a dashboard can only have one schedule and one assigned warehouse",
+        "B": "Create two separate schedule entries on the dashboard, each with a different time window and a different assigned warehouse",
+        "C": "Use a Databricks Job with two tasks to swap the warehouse assignment before each run",
+        "D": "Configure warehouse auto-scaling to switch sizes based on time of day"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Databricks SQL dashboard scheduling supports only one active refresh schedule per dashboard,\nwith a single assigned warehouse. To use different warehouses at different times, you would\nneed to manage this through the Databricks REST API or Jobs — not through the dashboard\nscheduling UI directly. Awareness of this limitation is important for exam scenarios\ninvolving cost optimization and scheduling.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q041",
+      "domain": "analytics-applications",
+      "title": "Question 41",
+      "difficulty": "easy",
+      "question": "A dashboard filter needs to let users pick a date range (start date and end date). Does Databricks SQL support a native date range parameter type?",
+      "choices": {
+        "A": "No — date range must be implemented as two separate text parameters",
+        "B": "Yes — Databricks SQL supports a Date Range parameter type that provides a calendar picker with start and end date selection",
+        "C": "Yes — but only for Serverless SQL warehouses",
+        "D": "No — date ranges require a custom dropdown with hard-coded values"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL supports several parameter types including Text, Number, Dropdown List, Query\nDropdown, Date, Date and Time, and Date Range. The Date Range type renders a calendar picker\nwith start and end date selection and injects both values into the query using the\n`{{parameter_name.start}}` and `{{parameter_name.end}}` syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q042",
+      "domain": "analytics-applications",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "A query parameter `{{min_revenue}}` is used in a dashboard filter. The analyst wants new users to see data filtered to `100000` until they change the filter. How is this configured?",
+      "choices": {
+        "A": "Default values cannot be set — users must always select a value before the query runs",
+        "B": "Set a default value for the parameter in the query settings — this value is used when no user selection has been made",
+        "C": "Hard-code `100000` in the SQL and add `{{min_revenue}}` as a comment",
+        "D": "Use `COALESCE({{min_revenue}}, 100000)` in the SQL"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks SQL query parameters support default values configured in the query or dashboard\nparameter settings. When a user opens the dashboard without having selected a value, the\ndefault is used, ensuring the query runs immediately with sensible initial data rather than\nfailing or showing no filter.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q043",
+      "domain": "analytics-applications",
+      "title": "Question 43",
+      "difficulty": "medium",
+      "question": "An analyst shares a saved query with a colleague using \"Can View\" access. What can the colleague do with the query?",
+      "choices": {
+        "A": "Edit the SQL and save changes",
+        "B": "Run the query and view results, but not modify the SQL or save changes",
+        "C": "Share the query further with additional users",
+        "D": "Delete the query"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "\"Can View\" on a saved query allows the recipient to open and read the SQL, run the query,\nand view results. They cannot modify the SQL, rename, delete, or share the query further.\n\"Can Edit\" permission is required to make and save changes to the query.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q044",
+      "domain": "analytics-applications",
+      "title": "Question 44",
+      "difficulty": "hard",
+      "question": "A SQL alert monitors a query that returns no rows (an empty result). The alert condition is `WHEN VALUE > 0`. Does the alert fire?",
+      "choices": {
+        "A": "Yes — an empty result is treated as 0, which is not greater than 0, so no alert fires",
+        "B": "No — when the query returns no rows, the alert condition evaluates to UNKNOWN and does not fire",
+        "C": "Yes — an empty result always triggers an alert as an error condition",
+        "D": "The alert raises an error and sends an error notification"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When a monitored query returns no rows, the alert value is effectively undefined (NULL).\nDatabricks SQL treats a NULL result as UNKNOWN, which does not satisfy the threshold\ncondition. The alert does not fire. If detecting the absence of data (zero rows) is the\ngoal, rewrite the query to return a `COUNT(*)` which will return 0 instead of no rows.",
+      "explanation": ""
+    },
+    {
+      "id": "data-analyst-associate-mock-2-q045",
+      "domain": "analytics-applications",
+      "title": "Question 45",
+      "difficulty": "medium",
+      "question": "Which approach is the documented and safest fit?",
+      "choices": {
+        "A": "Standard view: `CREATE VIEW gold.daily_revenue AS SELECT date, SUM(amount) ... GROUP BY date`",
+        "B": "Materialized view: `CREATE MATERIALIZED VIEW gold.daily_revenue AS ...` with an hourly refresh schedule",
+        "C": "Pin the dashboard to a Pro SQL Warehouse with result caching enabled",
+        "D": "Convert the orders table to bucketing on date"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Genie Spaces is the documented natural-language analytics surface for exactly this use case. UC permissions, including column masks and row filters, apply to every Genie-generated SQL query — so CS users physically cannot see PII columns they're not granted on, regardless of how Genie phrases the question. Option A reinvents Genie poorly. Option C duplicates data and creates a refresh / drift problem. Option D is a retrieval-augmentation pattern over *unstructured* data — vector search returns similar rows by embedding distance, which is the wrong tool for structured analytic queries (counts, aggregates, joins).",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-analyst-associate"
+}
diff --git a/practice/data/data-analyst-associate.json b/practice/data/data-analyst-associate.json
index 06c76e5..a4b671c 100644
--- a/practice/data/data-analyst-associate.json
+++ b/practice/data/data-analyst-associate.json
@@ -2,7 +2,7 @@
   "cert": "data-analyst-associate",
   "certTitle": "Data Analyst Associate",
   "blueprintVersion": "Oct 2025",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "databricks-sql",
diff --git a/practice/data/data-engineer-associate-mock-1.json b/practice/data/data-engineer-associate-mock-1.json
new file mode 100644
index 0000000..098560d
--- /dev/null
+++ b/practice/data/data-engineer-associate-mock-1.json
@@ -0,0 +1,762 @@
+{
+  "cert": "data-engineer-associate-mock-1",
+  "certTitle": "Data Engineer Associate — Mock Exam 1",
+  "blueprintVersion": "May 2026",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-lakehouse-platform",
+      "name": "Databricks Lakehouse Platform",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 11
+    },
+    {
+      "id": "elt-with-spark-sql-and-python",
+      "name": "ELT with Spark SQL and Python",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "incremental-data-processing-delta-lake",
+      "name": "Incremental Data Processing / Delta Lake",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 10
+    },
+    {
+      "id": "production-pipelines",
+      "name": "Production Pipelines",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 7
+    },
+    {
+      "id": "data-governance",
+      "name": "Data Governance",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 4
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-engineer-associate-mock-1-q001",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "A data engineering team is evaluating whether to migrate their existing data warehouse to a Databricks Lakehouse. The primary concern is maintaining ACID guarantees for concurrent reads and writes on large tables. Which Databricks technology directly addresses this requirement?",
+      "choices": {
+        "A": "Apache Parquet file format with schema enforcement",
+        "B": "Delta Lake with transaction log (`_delta_log`)",
+        "C": "Databricks SQL Serverless warehouses",
+        "D": "Unity Catalog with row-level security"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake provides ACID transactions through its transaction log (`_delta_log`), which records every operation as an atomic commit. This enables concurrent readers and writers without data corruption. Parquet alone has no transaction support, Serverless warehouses are a compute option, and Unity Catalog handles governance — not storage-level ACID.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q002",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "An engineer is setting up a new Databricks workspace and needs to run interactive notebooks for development while also running scheduled production jobs. Which cluster type should they use for each workload?",
+      "choices": {
+        "A": "All-purpose clusters for both — they are more flexible",
+        "B": "Job clusters for both — they are cheaper and auto-terminate",
+        "C": "All-purpose clusters for interactive notebooks; job clusters for scheduled production jobs",
+        "D": "SQL warehouses for notebooks; job clusters for scheduled jobs"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "All-purpose clusters support interactive, multi-user notebook sessions and persist between runs. Job clusters are created specifically for a single job run and terminate automatically upon completion, making them more cost-effective for production pipelines. SQL warehouses are optimized for SQL queries, not general notebook workloads.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q003",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 3",
+      "difficulty": "medium",
+      "question": "A company wants to reduce cluster startup time for their machine learning jobs that run every 30 minutes. The jobs require identical cluster configurations each time. Which Databricks feature should they configure?",
+      "choices": {
+        "A": "Autoscaling enabled on job clusters",
+        "B": "Instance pools with pre-warmed instances",
+        "C": "Photon engine acceleration",
+        "D": "Serverless compute for ML workloads"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Instance pools maintain a set of idle, pre-warmed virtual machines that clusters can acquire immediately, drastically reducing startup time from minutes to seconds. Autoscaling adjusts the number of workers during a run but doesn't reduce initial startup time. Photon accelerates query execution. Serverless compute is currently available for SQL and Delta Live Tables, not general ML jobs.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q004",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 4",
+      "difficulty": "easy",
+      "question": "A team member asks about the difference between the Databricks Control Plane and the Data Plane. Which statement correctly describes this architecture?",
+      "choices": {
+        "A": "The Control Plane stores all data; the Data Plane manages cluster configuration",
+        "B": "The Control Plane is managed by Databricks in its cloud account; the Data Plane runs in the customer's cloud account and processes data",
+        "C": "The Control Plane and Data Plane are both in the customer's cloud account for security",
+        "D": "The Data Plane manages the web UI; the Control Plane runs Spark jobs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Control Plane (web UI, job scheduler, cluster manager) runs in Databricks' cloud account. The Data Plane (clusters, DBFS, customer data) runs in the customer's own cloud account. This architecture ensures that sensitive data never leaves the customer's environment, while Databricks manages the platform overhead.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q005",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "An analyst needs to access data stored in an external S3 bucket from a Databricks cluster without hardcoding credentials in notebooks. Which approach is most appropriate?",
+      "choices": {
+        "A": "Store credentials in a notebook cell marked as hidden",
+        "B": "Use Databricks Secrets with `dbutils.secrets.get()` to retrieve credentials at runtime",
+        "C": "Export credentials as environment variables in the cluster init script",
+        "D": "Pass credentials as job parameters in the Workflows UI"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Secrets provides a secure vault for storing sensitive values. `dbutils.secrets.get()` retrieves them at runtime and the values are never shown in logs or notebook output. Hardcoding in notebooks or init scripts exposes credentials in version control and logs. Job parameters are visible in the UI and logs.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q006",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "A data engineer is comparing Databricks Photon engine to standard Spark. In which scenario does Photon provide the greatest performance benefit?",
+      "choices": {
+        "A": "Python UDFs running complex custom logic",
+        "B": "SQL queries on Delta Lake tables with aggregations and joins",
+        "C": "Streaming jobs using foreachBatch sinks",
+        "D": "Machine learning model training with MLlib"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Photon is a native vectorized query engine written in C++ that accelerates SQL workloads on Delta Lake, especially aggregations, joins, and scans. It does not accelerate Python UDFs (which require serialization between JVM and Python), and provides limited benefit for MLlib model training or streaming micro-batch logic.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q007",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "A Databricks cluster is configured with a driver node (16 cores) and 4 worker nodes (8 cores each). A user runs a SQL query. What is the total parallelism available for task execution?",
+      "choices": {
+        "A": "16 cores (driver only coordinates)",
+        "B": "32 cores (workers only)",
+        "C": "48 cores (driver + workers)",
+        "D": "Depends on the number of partitions in the data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "In Spark, the driver node coordinates tasks but does not execute them. Task execution happens exclusively on worker nodes. With 4 workers × 8 cores = 32 cores available for parallel task execution. The number of partitions determines how many tasks run simultaneously, but available parallelism is capped by worker cores.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q008",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 8",
+      "difficulty": "easy",
+      "question": "A team wants to use Databricks Runtime for Machine Learning (ML Runtime) instead of the standard Databricks Runtime. What is the primary reason to choose the ML Runtime?",
+      "choices": {
+        "A": "ML Runtime supports Delta Lake operations; standard Runtime does not",
+        "B": "ML Runtime includes pre-installed ML libraries such as TensorFlow, PyTorch, and scikit-learn",
+        "C": "ML Runtime enables GPU acceleration automatically on all node types",
+        "D": "ML Runtime provides faster SQL query execution via Photon"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Runtime for Machine Learning comes pre-installed with popular ML libraries (TensorFlow, PyTorch, scikit-learn, XGBoost, etc.) so teams don't need to install them manually. Both runtimes support Delta Lake. GPU acceleration requires GPU-enabled instance types regardless of runtime. Photon is available on the standard runtime.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q009",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "A data engineer wants to understand the Lakehouse architecture. Which statement best describes what differentiates a Lakehouse from a traditional two-tier Lambda architecture (data lake + data warehouse)?",
+      "choices": {
+        "A": "A Lakehouse stores data only in columnar formats, while Lambda uses row-based storage",
+        "B": "A Lakehouse consolidates storage and compute so that BI tools can query data directly from cloud storage with ACID guarantees",
+        "C": "A Lakehouse requires all data to be structured; Lambda architecture supports unstructured data",
+        "D": "A Lakehouse eliminates the need for data transformation; Lambda requires full ETL pipelines"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Lakehouse pattern eliminates the costly ETL copy step from data lake to data warehouse by adding metadata layers (like Delta Lake) that bring ACID transactions, schema enforcement, and performance optimizations directly to cloud storage. BI and ML tools can query the same data store. It supports both structured and unstructured data, and transformation is still required.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q010",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "An organization runs a multi-tenant Databricks workspace. A cluster policy is configured with `spark.executor.memory` set as a fixed value. What is the effect of this policy on users?",
+      "choices": {
+        "A": "Users can override the fixed value by setting it in their notebook",
+        "B": "Users cannot change the fixed value when creating clusters governed by this policy",
+        "C": "The fixed value applies only to SQL warehouse clusters, not all-purpose clusters",
+        "D": "Cluster policies only restrict admin users; regular users are unaffected"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Cluster policies enforce configuration constraints. When a value is set as \"fixed\" in a policy, users cannot override it — the UI hides the field or makes it read-only. This ensures cost control and security compliance. Policies apply to any cluster type the policy is assigned to, not only warehouses.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q011",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "A data engineer needs to run a notebook that performs interactive EDA (exploratory data analysis) with visualizations, then automatically hand off to a scheduled production pipeline. Which Databricks features best match these two phases respectively?",
+      "choices": {
+        "A": "All-purpose cluster for EDA; DLT pipeline for production",
+        "B": "Job cluster for EDA; all-purpose cluster for production",
+        "C": "SQL warehouse for EDA; serverless compute for production",
+        "D": "All-purpose cluster for EDA; job cluster with Workflows for production"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "All-purpose clusters support interactive notebook sessions ideal for EDA with visualizations and iterative development. Databricks Workflows with job clusters provide automated, scheduled, cost-efficient execution for production pipelines. Job clusters terminate after the job completes, reducing cost. SQL warehouses are optimized for SQL queries, not general notebook EDA.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q012",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 12",
+      "difficulty": "easy",
+      "question": "A data engineer runs the following SQL command. What is the result?\n\n```sql\nCREATE OR REPLACE TABLE sales_summary AS\nSELECT region, SUM(amount) AS total_sales\nFROM transactions\nGROUP BY region;\n```",
+      "choices": {
+        "A": "Creates a new table only if it does not already exist",
+        "B": "Creates a new table or replaces the entire table if it already exists",
+        "C": "Appends aggregated results to the existing table",
+        "D": "Creates a temporary view of the aggregated results"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CREATE OR REPLACE TABLE ... AS SELECT` (CRAS) creates a new table with the query results. If a table with that name already exists, it is completely replaced (dropped and recreated). Use `CREATE TABLE IF NOT EXISTS` to skip creation when the table exists, or `INSERT INTO` to append rows.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q013",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "A Databricks SQL query must return all rows from the `orders` table and only the matching rows from the `customers` table. Which JOIN type accomplishes this?",
+      "choices": {
+        "A": "INNER JOIN",
+        "B": "RIGHT JOIN",
+        "C": "LEFT JOIN",
+        "D": "CROSS JOIN"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A LEFT JOIN returns all rows from the left table (`orders`) and matched rows from the right table (`customers`). Unmatched rows from `customers` appear as NULL. INNER JOIN returns only matched rows from both tables. RIGHT JOIN returns all rows from `customers` and matched rows from `orders` — the inverse of what is needed.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q014",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "A data engineer needs to find the top 3 highest-selling products within each product category. Which SQL feature is most appropriate?",
+      "choices": {
+        "A": "GROUP BY with HAVING clause",
+        "B": "Correlated subquery with LIMIT",
+        "C": "Window function with `RANK() OVER (PARTITION BY category ORDER BY sales DESC)`",
+        "D": "PIVOT table with category as columns"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Window functions with `RANK()` or `ROW_NUMBER()` partitioned by category and ordered by sales descending assign a rank to each product within its category. Filtering `WHERE rank <= 3` returns the top 3 per category. `GROUP BY` with `HAVING` can't retrieve individual rows within groups. Subqueries with `LIMIT` don't partition by category.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q015",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "A data engineer writes the following PySpark code. What does it accomplish?\n\n```python\n(df.filter(col(\"status\") == \"active\")\n   .groupBy(\"department\")\n   .agg(avg(\"salary\").alias(\"avg_salary\"))\n   .orderBy(\"avg_salary\", ascending=False))\n```",
+      "choices": {
+        "A": "Updates salaries for active employees grouped by department",
+        "B": "Returns the average salary per department for active employees, sorted highest to lowest",
+        "C": "Deletes inactive employees and calculates department headcount",
+        "D": "Creates a new Delta table with department salary averages"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The code filters rows where `status == \"active\"`, groups by `department`, calculates the average salary as `avg_salary`, and sorts descending. It is a read-only transformation — no writes or deletes occur. `write()` or `save()` would be needed to persist results to storage.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q016",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 16",
+      "difficulty": "medium",
+      "question": "A data engineer needs to apply a custom Python function to a column in a large Spark DataFrame. The function uses a third-party library not available as a built-in Spark function. What is the recommended approach?",
+      "choices": {
+        "A": "Use `df.apply()` to apply the function row by row",
+        "B": "Register the function as a Spark UDF with `spark.udf.register()` or `udf()`",
+        "C": "Export the DataFrame to Pandas, apply the function, then convert back",
+        "D": "Use `df.withColumn()` with a Python lambda directly without registration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Spark UDFs (User-Defined Functions) allow custom Python logic to be applied to DataFrame columns in a distributed manner. They must be registered before use. Exporting to Pandas loses distributed processing and will fail on large datasets. `withColumn()` with a lambda doesn't work — Spark columns require Spark expressions or registered UDFs.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q017",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "A data engineer uses `explode()` on a column containing arrays. What does this function do?",
+      "choices": {
+        "A": "Removes all NULL values from array columns",
+        "B": "Converts an array column into multiple rows, one row per array element",
+        "C": "Flattens nested structs into separate columns",
+        "D": "Converts an array column into a string by joining elements"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`explode()` takes an array (or map) column and generates one new row per element, duplicating all other column values. This is the standard way to \"unnest\" array data in Spark. `flatten()` flattens nested arrays. Struct flattening uses `col(\"field.*\")`. `array_join()` converts an array to a string.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q018",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 18",
+      "difficulty": "easy",
+      "question": "A data engineer needs to add a column to an existing Delta table without rewriting the data. Which SQL command accomplishes this?",
+      "choices": {
+        "A": "`UPDATE table_name SET new_col = NULL`",
+        "B": "`ALTER TABLE table_name ADD COLUMN new_col STRING`",
+        "C": "`INSERT INTO table_name SELECT *, NULL AS new_col FROM table_name`",
+        "D": "`CREATE OR REPLACE TABLE table_name AS SELECT *, NULL AS new_col FROM table_name`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ALTER TABLE ... ADD COLUMN` adds a new column to the Delta table schema without rewriting existing data files — the new column returns NULL for existing rows until populated. `UPDATE` modifies existing rows. `INSERT INTO` adds new rows. `CREATE OR REPLACE` rewrites the entire table, which is expensive and unnecessary.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q019",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 19",
+      "difficulty": "hard",
+      "question": "A data engineer writes SQL to calculate a running total of sales by date using the following window specification. What does it return?\n\n```sql\nSUM(amount) OVER (ORDER BY date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)\n```",
+      "choices": {
+        "A": "This syntax is invalid — `ROWS BETWEEN` is not supported",
+        "B": "The cumulative sum of `amount` from the earliest date up to and including the current row",
+        "C": "The total sum of all rows repeated for every date (grand total)",
+        "D": "The sum of only the current row and the immediately following row"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW` defines a window that starts at the very first row (in `ORDER BY date` order) and ends at the current row, producing a cumulative running total. `ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING` would return the grand total for every row.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q020",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 20",
+      "difficulty": "easy",
+      "question": "A data engineer needs to combine two DataFrames that have the same schema, keeping all rows from both including duplicates. Which operation should they use?",
+      "choices": {
+        "A": "`df1.join(df2, how=\"full\")`",
+        "B": "`df1.union(df2)`",
+        "C": "`df1.intersect(df2)`",
+        "D": "`df1.merge(df2)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`union()` appends all rows from `df2` to `df1`, preserving duplicates. It requires both DataFrames to have the same schema (same column count and order). `join()` combines rows based on a key condition. `intersect()` returns only rows present in both DataFrames. Spark DataFrames don't have a `merge()` method.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q021",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 21",
+      "difficulty": "easy",
+      "question": "A data engineer needs to pivot sales data so that each product category becomes a separate column showing total sales. Which SQL keyword accomplishes this?",
+      "choices": {
+        "A": "UNPIVOT",
+        "B": "CROSSTAB",
+        "C": "PIVOT",
+        "D": "TRANSPOSE"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`PIVOT` in Databricks SQL rotates rows into columns. You specify the pivot column (categories) and the aggregation (SUM of sales). `UNPIVOT` does the reverse — converts columns to rows. `CROSSTAB` is not a standard SQL keyword in Databricks. `TRANSPOSE` is not a SQL operation.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q022",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "A data engineer wants to select only distinct combinations of `customer_id` and `product_id` from a table with millions of rows. Which approach is most efficient?",
+      "choices": {
+        "A": "`SELECT DISTINCT customer_id, product_id FROM orders`",
+        "B": "`SELECT customer_id, product_id FROM orders GROUP BY ALL`",
+        "C": "Both A and B produce identical results and the Spark optimizer handles them the same way",
+        "D": "Use `dropDuplicates()` in PySpark only — `DISTINCT` is not supported in Databricks SQL"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`SELECT DISTINCT col1, col2` and `GROUP BY col1, col2` with no aggregation are logically and physically equivalent in Spark's optimizer. Both generate the same query plan. `DISTINCT` is fully supported in Databricks SQL. Either syntax is valid — the choice is stylistic.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q023",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 23",
+      "difficulty": "hard",
+      "question": "A data engineer writes a SQL query joining three large tables. The query is slow and the Spark UI shows excessive shuffle volume. Which optimization should they apply first?",
+      "choices": {
+        "A": "Increase the number of shuffle partitions with `spark.sql.shuffle.partitions`",
+        "B": "Use broadcast join hints for small dimension tables: `/*+ BROADCAST(dim) */`",
+        "C": "Convert all joins to CROSS JOINs for performance",
+        "D": "Add more worker nodes to the cluster"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "If one or more tables are small enough to fit in memory (~200MB or less), a broadcast join eliminates the shuffle entirely by sending the small table to every executor. This is the most impactful optimization for join-heavy queries. Increasing shuffle partitions only changes partition count, not the total shuffle volume. Adding nodes doesn't eliminate the shuffle.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q024",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "A data engineer uses higher-order functions to work with an array column. Which function filters array elements based on a lambda condition?",
+      "choices": {
+        "A": "`array_contains(arr, value)`",
+        "B": "`filter(arr, x -> x > 100)`",
+        "C": "`transform(arr, x -> x * 2)`",
+        "D": "`aggregate(arr, 0, (acc, x) -> acc + x)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`filter(array, lambda)` applies a boolean lambda to each array element and returns only elements where the condition is true. `array_contains()` checks if a specific value exists (returns boolean, not an array). `transform()` applies a transformation to every element (equivalent to map). `aggregate()` reduces an array to a single value (equivalent to fold/reduce).",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q025",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 25",
+      "difficulty": "medium",
+      "question": "A data engineer needs to query data as it existed 7 days ago from a Delta table named `transactions`. Which command correctly retrieves this historical snapshot?",
+      "choices": {
+        "A": "`SELECT * FROM transactions WHERE _commit_timestamp >= date_sub(current_date(), 7)`",
+        "B": "`SELECT * FROM transactions VERSION AS OF 7`",
+        "C": "`SELECT * FROM transactions TIMESTAMP AS OF date_sub(current_date(), 7)`",
+        "D": "`RESTORE TABLE transactions TO TIMESTAMP AS OF date_sub(current_date(), 7)`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Delta Lake time travel using `TIMESTAMP AS OF` queries the table state at a specific point in time. `VERSION AS OF 7` queries version number 7 (the 8th commit), not 7 days ago. `RESTORE TABLE` permanently restores the table to a previous state rather than just reading it. `_commit_timestamp` is not a valid time travel filter syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q026",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "A data engineer needs to upsert records into a Delta table: update existing customer records when `customer_id` matches, and insert new records when there is no match. Which clause correctly completes the MERGE statement?\n\n```sql\nMERGE INTO customers AS target\nUSING updates AS source\nON target.customer_id = source.customer_id\nWHEN MATCHED THEN\n  UPDATE SET target.name = source.name, target.email = source.email\nWHEN NOT MATCHED THEN\n  ___________\n```",
+      "choices": {
+        "A": "`INSERT VALUES (source.customer_id, source.name, source.email)`",
+        "B": "`INSERT INTO customers SELECT * FROM source`",
+        "C": "`INSERT (customer_id, name, email) VALUES (source.customer_id, source.name, source.email)`",
+        "D": "`INSERT * FROM source`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The correct MERGE `WHEN NOT MATCHED` syntax is `INSERT (column_list) VALUES (source.column_list)`. The column list explicitly names the target columns, and the VALUES clause provides the source values. Option A is missing the column list. Options B and D are not valid MERGE syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q027",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 27",
+      "difficulty": "medium",
+      "question": "A data engineer configures Auto Loader to ingest CSV files from an S3 bucket. The pipeline runs every hour. What happens if 5 new files arrive between runs?",
+      "choices": {
+        "A": "Only the first file is processed; subsequent files are queued for the next run",
+        "B": "Auto Loader automatically detects and processes all 5 new files in the next trigger",
+        "C": "Auto Loader processes files only when triggered manually",
+        "D": "Auto Loader fails if more than 1 file arrives between runs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Auto Loader uses cloud storage notifications or directory listing combined with a checkpoint to track which files have been processed. On the next trigger, it automatically detects all new, unprocessed files and ingests them. This checkpointing mechanism ensures exactly-once processing without manual intervention or file tracking.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q028",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "A data engineer enables Change Data Feed (CDF) on a Delta table. What additional metadata columns does CDF expose when reading changes?",
+      "choices": {
+        "A": "The Spark execution plan for each change operation",
+        "B": "Columns `_change_type`, `_commit_version`, and `_commit_timestamp` showing what changed and when",
+        "C": "A separate audit log table in the same database",
+        "D": "A JSON file in the `_delta_log` directory with changed row details"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Change Data Feed adds three metadata columns: `_change_type` (insert, update_preimage, update_postimage, delete), `_commit_version` (Delta version number), and `_commit_timestamp` (when the change occurred). These are read using `.option(\"readChangeFeed\", \"true\")`. CDF data is stored within the Delta table, not a separate table or JSON file.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q029",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 29",
+      "difficulty": "easy",
+      "question": "A Delta table has accumulated many small Parquet files over several months of streaming ingestion. A data engineer runs `OPTIMIZE` on the table. What is the primary effect?",
+      "choices": {
+        "A": "Deletes files marked for deletion by previous VACUUM operations",
+        "B": "Rewrites small Parquet files into larger, more efficient files to improve read performance",
+        "C": "Recalculates column statistics and updates the transaction log",
+        "D": "Converts the table from Parquet format to a different columnar format"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`OPTIMIZE` compacts small files into larger files (typically targeting 1GB) to reduce the overhead of reading many small files and improve scan efficiency. It does not delete files — `VACUUM` handles that. Statistics updates are a secondary benefit. Delta Lake always uses Parquet as its underlying storage format.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q030",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "A data engineer runs `VACUUM transactions RETAIN 168 HOURS`. What is the effect on time travel capabilities?",
+      "choices": {
+        "A": "No effect — VACUUM only removes duplicated data, not historical versions",
+        "B": "Historical data files older than 168 hours (7 days) are permanently deleted and time travel to those versions is no longer possible",
+        "C": "Delta Lake automatically creates a backup before running VACUUM",
+        "D": "VACUUM retains exactly 168 versions of the table, not based on time"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`VACUUM` removes data files no longer referenced by the transaction log that are older than the retention period. Once vacuumed, time travel queries to those older versions fail because the underlying Parquet files are deleted. The default retention is 7 days (168 hours). Delta Lake does not automatically create backups before VACUUM.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q031",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 31",
+      "difficulty": "medium",
+      "question": "A streaming job reads from a Kafka topic and writes to a Delta table. The engineer wants the job to process all currently available data and then stop automatically. Which trigger type should they configure?",
+      "choices": {
+        "A": "`trigger(processingTime=\"0 seconds\")` for continuous mode",
+        "B": "`trigger(availableNow=True)` to process all available data then stop",
+        "C": "`trigger(continuous=\"10 seconds\")` for low-latency micro-batch processing",
+        "D": "No trigger configuration — streaming jobs stop automatically when the source is empty"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`trigger(availableNow=True)` (Spark 3.3+) or `trigger(once=True)` processes all currently available data in the stream source and then terminates the query. This is ideal for scheduled batch-style streaming jobs. `processingTime=\"0 seconds\"` runs as fast as possible but never stops. Streaming jobs do not stop automatically without explicit trigger configuration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q032",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 32",
+      "difficulty": "easy",
+      "question": "A data engineer uses the medallion architecture. Which layer is responsible for enforcing data quality rules, deduplication, and applying business logic transformations?",
+      "choices": {
+        "A": "Bronze layer — stores raw, unmodified ingested data",
+        "B": "Silver layer — stores cleaned, filtered, and enriched data with quality checks applied",
+        "C": "Gold layer — stores aggregate KPIs and metrics for reporting",
+        "D": "The medallion architecture has no dedicated quality enforcement layer"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Silver layer is where data quality enforcement, deduplication, schema normalization, and business logic transformations occur. Bronze stores raw data as-is for auditability and reprocessing. Gold stores aggregated, business-ready data optimized for analytics and BI reporting.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q033",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 33",
+      "difficulty": "medium",
+      "question": "A data engineer wants to Z-ORDER a Delta table by the `customer_id` column to improve query performance. When does Z-ORDER provide the most benefit?",
+      "choices": {
+        "A": "When queries always perform full table scans without any filters",
+        "B": "When queries frequently filter on `customer_id`, enabling Delta's data skipping to skip entire files",
+        "C": "When the table has fewer than 10 files and is already compact",
+        "D": "Z-ORDER provides no benefit on Delta tables; use partitioning for all performance needs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Z-ORDER co-locates related values within the same set of files, enabling Delta Lake's data skipping to skip entire files that don't contain queried `customer_id` values. This is most beneficial for high-cardinality columns frequently used in `WHERE` clauses. If queries always scan the full table, or the table is very small, Z-ORDER provides no benefit.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q034",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 34",
+      "difficulty": "hard",
+      "question": "A data engineer notices that a Delta streaming job fails with `StreamingQueryException: Detected a data update in the source table`. What caused this error?",
+      "choices": {
+        "A": "The source Delta table had `OPTIMIZE` run on it while the stream was reading",
+        "B": "The source Delta table had rows `UPDATE`d or `DELETE`d, which is not supported by default streaming reads",
+        "C": "The streaming job ran out of memory due to large state size",
+        "D": "The checkpoint directory was deleted, causing the stream to restart"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "By default, Delta streaming reads assume an append-only source. If the source table has `UPDATE`, `DELETE`, or `MERGE` operations on existing rows, the stream throws this exception. To handle such sources, use `.option(\"ignoreChanges\", \"true\")` or `.option(\"ignoreDeletes\", \"true\")`, or switch to Change Data Feed for CDC-aware streaming.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q035",
+      "domain": "production-pipelines",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A data engineer is designing a Databricks Workflow with three tasks: `ingest → transform → report`. The `report` task must only run if `transform` succeeds. How should task dependencies be configured?",
+      "choices": {
+        "A": "Use a single-task job with all logic in one notebook to avoid dependency issues",
+        "B": "Configure `transform` as a dependency of `report` using the `depends_on` task setting",
+        "C": "Use separate jobs for each task and chain them with external orchestration",
+        "D": "Set `transform` and `report` to run in parallel to reduce total execution time"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Workflows supports multi-task jobs with explicit task dependencies via `depends_on`. When `transform` fails, downstream tasks (`report`) are automatically skipped or marked as failed. Running tasks in parallel would not enforce the required sequential dependency. Separate jobs with external orchestration adds unnecessary complexity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q036",
+      "domain": "production-pipelines",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "A production job fails intermittently due to transient cloud API errors. What built-in Databricks Workflows feature can automatically retry failed tasks without manual intervention?",
+      "choices": {
+        "A": "Task timeout configuration — the task retries when it exceeds the timeout",
+        "B": "Per-task retry policy with configurable maximum retries and retry interval",
+        "C": "Workflow-level SLA notifications that page the on-call engineer",
+        "D": "Databricks auto-recovers all failed tasks by default with no configuration needed"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Workflows allows configuring a retry policy per task, specifying the maximum number of retry attempts and the interval between retries. This handles transient failures automatically. Timeout configuration controls how long a task runs before being killed, not whether it retries. Auto-recovery is not enabled by default.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q037",
+      "domain": "production-pipelines",
+      "title": "Question 37",
+      "difficulty": "easy",
+      "question": "A data engineer uses Delta Live Tables (DLT) to build a pipeline. Which Python decorator defines a table that is computed and materialized from a query?",
+      "choices": {
+        "A": "`@dlt.table`",
+        "B": "`@dlt.view`",
+        "C": "`@dlt.materialized_view`",
+        "D": "`@dlt.expect`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "In Delta Live Tables, `@dlt.table` defines a materialized table that DLT computes and stores. When the query uses `spark.readStream`, DLT creates a streaming table; otherwise it creates a batch materialized table. `@dlt.view` creates a virtual, non-materialized view. `@dlt.expect` is not a table decorator — it adds data quality expectations to tables decorated with `@dlt.table`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q038",
+      "domain": "production-pipelines",
+      "title": "Question 38",
+      "difficulty": "medium",
+      "question": "A DLT pipeline has an `EXPECT` constraint: `EXPECT (amount > 0) ON VIOLATION DROP ROW`. A batch of 1,000 records arrives and 50 have `amount <= 0`. What happens?",
+      "choices": {
+        "A": "The entire batch fails and no records are written",
+        "B": "All 1,000 records are written, and the 50 violating records are flagged in the event log",
+        "C": "The 50 violating records are dropped and 950 valid records are written to the table",
+        "D": "The pipeline pauses and waits for manual intervention to resolve the violations"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`ON VIOLATION DROP ROW` instructs DLT to discard rows that fail the expectation and continue processing valid rows. Violation counts are tracked in the DLT event log. `ON VIOLATION FAIL UPDATE` would fail the pipeline on any violation. `ON VIOLATION WARN` (the default with no modifier) writes all rows but logs violations without dropping any.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q039",
+      "domain": "production-pipelines",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A data engineer configures a Databricks Workflow job with a schedule of `0 0 8 * * ?` (Quartz cron format). When does this job run?",
+      "choices": {
+        "A": "Every 8 minutes",
+        "B": "Every hour at minute 8",
+        "C": "At 8:00 AM every day",
+        "D": "At 8:00 AM on the 8th of every month"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "In Quartz cron format, fields are: second minute hour day-of-month month day-of-week. So `0 0 8 * * ?` means second=0, minute=0, hour=8, every day, every month. This fires at exactly 8:00:00 AM daily. `0 8 * * * ?` would run every hour at minute 8. `0 0 0 8 * ?` would run at midnight on the 8th of each month.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q040",
+      "domain": "production-pipelines",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "A data engineer wants job clusters to start quickly for scheduled jobs without paying for always-running compute. Which Databricks feature achieves fast startup while keeping costs low?",
+      "choices": {
+        "A": "All-purpose cluster shared via cluster ID",
+        "B": "Job cluster without any optimization — they always start from scratch",
+        "C": "Interactive cluster attached to the job",
+        "D": "Instance pool that job clusters acquire for fast startup, then release after the job completes"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Instance pools maintain pre-warmed instances that job clusters can acquire instantly, reducing startup time to seconds. The pool persists between runs while the job cluster itself is created and destroyed per run, maintaining cost isolation. All-purpose clusters are not managed by Workflows and incur continuous cost.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q041",
+      "domain": "production-pipelines",
+      "title": "Question 41",
+      "difficulty": "medium",
+      "question": "A DLT pipeline is configured in `CONTINUOUS` mode. How does this differ from `TRIGGERED` mode?",
+      "choices": {
+        "A": "Continuous mode runs the pipeline once and exits; Triggered mode runs indefinitely",
+        "B": "Triggered mode processes data on a schedule or manually and then stops; Continuous mode streams with minimal latency",
+        "C": "Continuous mode only supports SQL; Triggered mode supports both SQL and Python",
+        "D": "There is no functional difference; the setting only affects UI display"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "In Continuous mode, DLT keeps the pipeline running indefinitely, processing new data as it arrives with low latency (true streaming). In Triggered mode, the pipeline runs when scheduled or triggered manually, processes all available data, and then stops — suitable for batch workloads. Both modes support SQL and Python.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q042",
+      "domain": "data-governance",
+      "title": "Question 42",
+      "difficulty": "hard",
+      "question": "A data engineer needs to grant a user access to query a specific table in Unity Catalog without giving access to the entire schema. What is the minimum set of privileges required?",
+      "choices": {
+        "A": "`GRANT SELECT ON TABLE catalog.schema.table TO user` only",
+        "B": "`GRANT SELECT ON SCHEMA catalog.schema TO user` only",
+        "C": "`USE CATALOG` on the catalog + `USE SCHEMA` on the schema + `SELECT` on the table",
+        "D": "`GRANT ALL PRIVILEGES ON TABLE catalog.schema.table TO user`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Unity Catalog uses hierarchical privilege inheritance. To query a table, a user needs: `USE CATALOG` on the parent catalog, `USE SCHEMA` on the parent schema, and `SELECT` on the specific table. Without the `USE` privileges at each level, the user cannot navigate to the table even if `SELECT` is granted on the table itself. Granting `ALL PRIVILEGES` is overly permissive.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q043",
+      "domain": "data-governance",
+      "title": "Question 43",
+      "difficulty": "medium",
+      "question": "A company wants to share a Delta table with an external partner organization that uses a different cloud provider, without copying the underlying data. Which Databricks feature enables this?",
+      "choices": {
+        "A": "External Location with cross-account IAM role",
+        "B": "Delta Sharing — an open protocol for sharing live data across organizations",
+        "C": "Unity Catalog data lineage export",
+        "D": "DBFS mount with public access enabled"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Sharing is an open, REST-based protocol that enables sharing live Delta Lake data with external organizations without copying data or requiring the recipient to use Databricks. Recipients access shared data using open-source Delta Sharing clients in Python, Spark, or pandas. External Locations manage access to cloud storage within the same organization, not across organizations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q044",
+      "domain": "data-governance",
+      "title": "Question 44",
+      "difficulty": "hard",
+      "question": "A data engineering team creates Unity Catalog external tables pointing to existing data in S3. Which Unity Catalog objects must be configured, and in what order?",
+      "choices": {
+        "A": "Storage Credential only — it automatically creates External Locations for referenced paths",
+        "B": "External Location only — it includes embedded credential configuration",
+        "C": "Catalog first, then Schema, then External Location",
+        "D": "Storage Credential first (defines the IAM identity), then External Location (maps the cloud path to the credential)"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Configuring external storage access in Unity Catalog requires two objects in order: (1) a **Storage Credential** that holds the IAM role or service principal identity with cloud storage permissions, and (2) an **External Location** that maps a specific cloud storage path (e.g., `s3://bucket/prefix`) to that credential. External tables can then reference paths within registered External Locations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-1-q045",
+      "domain": "data-governance",
+      "title": "Question 45",
+      "difficulty": "medium",
+      "question": "A data engineer wants to audit who accessed a specific Unity Catalog table and when. Which Databricks feature provides this capability?",
+      "choices": {
+        "A": "Delta Lake transaction log (`_delta_log`) — records all read and write operations",
+        "B": "Databricks system tables (`system.access.audit`) — captures access events including table reads",
+        "C": "Unity Catalog lineage graph — shows data flow but not individual user access events",
+        "D": "Spark UI history server — stores query history with user attribution"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks system tables include audit logs in `system.access.audit` that record who accessed what resources and when. The Delta transaction log records write operations (inserts, updates, deletes) but not reads. Lineage shows data flow between datasets. The Spark UI history tracks queries but is not designed for security auditing and has limited retention.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-engineer-associate"
+}
diff --git a/practice/data/data-engineer-associate-mock-2.json b/practice/data/data-engineer-associate-mock-2.json
new file mode 100644
index 0000000..5abb63f
--- /dev/null
+++ b/practice/data/data-engineer-associate-mock-2.json
@@ -0,0 +1,762 @@
+{
+  "cert": "data-engineer-associate-mock-2",
+  "certTitle": "Data Engineer Associate — Mock Exam 2",
+  "blueprintVersion": "May 2026",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-lakehouse-platform",
+      "name": "Databricks Lakehouse Platform",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 11
+    },
+    {
+      "id": "elt-with-spark-sql-and-python",
+      "name": "ELT with Spark SQL and Python",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "incremental-data-processing-delta-lake",
+      "name": "Incremental Data Processing / Delta Lake",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 10
+    },
+    {
+      "id": "production-pipelines",
+      "name": "Production Pipelines",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 7
+    },
+    {
+      "id": "data-governance",
+      "name": "Data Governance",
+      "sourceFile": "certifications/data-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 4
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-engineer-associate-mock-2-q001",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "A data engineer needs to store a small reference file that will be accessed by Spark jobs in a Databricks workspace. The file must be accessible from any cluster without additional mount configuration. Which storage location is most appropriate?",
+      "choices": {
+        "A": "Cloud object storage (S3/ADLS) with manual mount configuration per cluster",
+        "B": "DBFS (Databricks File System) root — automatically available on all clusters",
+        "C": "Local disk of the driver node — fastest access for small files",
+        "D": "Unity Catalog external volume with IAM role configuration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "DBFS (Databricks File System) is a distributed file system mounted on every Databricks cluster automatically. Files stored in DBFS root are accessible from any cluster in the workspace without additional configuration. Local driver disk is ephemeral and not accessible from other nodes. External volumes require Unity Catalog configuration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q002",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A data engineer is choosing between a single-node cluster and a standard multi-node cluster for a machine learning training workload. When is a single-node cluster the appropriate choice?",
+      "choices": {
+        "A": "When training large neural networks that require GPU acceleration",
+        "B": "When running distributed Spark ML pipelines on terabyte-scale datasets",
+        "C": "When using single-machine ML libraries like scikit-learn or running small experiments",
+        "D": "When running production streaming pipelines that require high availability"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Single-node clusters run the Spark driver and executor on the same machine with no worker nodes. They are appropriate for single-machine libraries like scikit-learn, pandas, or small exploratory ML experiments that don't benefit from Spark's distributed processing. Large-scale Spark ML, streaming pipelines, and GPU workloads requiring failover all need multi-node clusters.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q003",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 3",
+      "difficulty": "easy",
+      "question": "A data engineer wants to version control notebooks using Git and collaborate with teammates via pull requests. Which Databricks feature supports this workflow?",
+      "choices": {
+        "A": "Databricks Archives — export notebooks to ZIP format for external storage",
+        "B": "Databricks Repos — connects workspace folders to a remote Git repository",
+        "C": "Databricks File System — stores notebook files in DBFS with version history",
+        "D": "Databricks Workflows — tracks job run history as a proxy for code versions"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Repos integrates workspace folders directly with remote Git repositories (GitHub, GitLab, Azure DevOps, etc.). Engineers can commit, push, pull, create branches, and collaborate via pull requests without leaving the Databricks interface. DBFS does not provide version control. Workflows tracks job runs, not code changes.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q004",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 4",
+      "difficulty": "medium",
+      "question": "An analyst notices that a Databricks SQL warehouse is taking 3 minutes to run the first query of the day but subsequent queries run in seconds. What is the most likely cause?",
+      "choices": {
+        "A": "The warehouse is running out of memory after the first query",
+        "B": "The warehouse has a cold start delay because the compute nodes were terminated during the idle period",
+        "C": "The first query always runs as a dry run without caching",
+        "D": "The SQL optimizer is recomputing all table statistics for the first query"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "SQL warehouses auto-stop after an idle timeout (default 120 minutes) to save cost, which terminates the underlying compute. When a new query arrives, the warehouse must provision new compute nodes — a process that takes 2–5 minutes. Serverless SQL warehouses eliminate this cold start. Subsequent queries run fast because the cluster is already running.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q005",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "A data engineer configures an all-purpose cluster with autoscaling between 2 and 8 workers. What determines when Databricks adds or removes worker nodes?",
+      "choices": {
+        "A": "A fixed schedule defined by the engineer in cluster settings",
+        "B": "Spark task queue depth — workers are added when tasks are pending and removed when idle",
+        "C": "Memory usage only — workers are added when memory exceeds 80%",
+        "D": "The engineer manually adjusts the worker count through the cluster UI"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks autoscaling monitors the Spark task queue and executor utilization. Workers are added when tasks are queued and waiting for executors. Workers are removed (scale down) after a period of executor idleness. Memory usage alone does not trigger autoscaling — it is based on task scheduling pressure.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q006",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 6",
+      "difficulty": "easy",
+      "question": "A data engineer uses the `%run` magic command in a Databricks notebook. What does this command do?",
+      "choices": {
+        "A": "Runs a shell command on the driver node",
+        "B": "Executes another notebook in the current notebook's context, importing its variables and functions",
+        "C": "Runs the current notebook as a background job",
+        "D": "Executes SQL against the currently attached SQL warehouse"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`%run ./path/to/notebook` executes another notebook inline within the current notebook's execution context. All variables, functions, and classes defined in the called notebook become available in the calling notebook. This is commonly used to load utility functions or shared configurations. `%sh` runs shell commands. `%sql` executes SQL.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q007",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "A Databricks SQL Pro warehouse is configured with a minimum of 1 cluster and a maximum of 5 clusters. A sudden spike brings 50 concurrent analysts running queries. What happens?",
+      "choices": {
+        "A": "The warehouse queues all queries until the single cluster finishes current work",
+        "B": "The warehouse scales up to 5 clusters to handle concurrent load, then scales down when demand drops",
+        "C": "The warehouse fails with a capacity error and all 50 sessions are disconnected",
+        "D": "Each analyst is automatically assigned a dedicated Classic warehouse"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Pro SQL warehouses support multi-cluster scaling. When one cluster reaches capacity, additional clusters spin up (up to the configured maximum of 5 clusters) to absorb concurrent load. When demand drops, excess clusters terminate automatically. Classic warehouses are single-cluster only. Serverless also supports auto-scaling.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q008",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "A data engineer uses `dbutils.widgets.text(\"start_date\", \"2024-01-01\")` in a notebook. What is the purpose of this widget?",
+      "choices": {
+        "A": "Displays a text message at the top of the notebook output",
+        "B": "Creates a parameterized input that can be overridden when running the notebook as a job",
+        "C": "Creates a permanent database variable that persists across cluster restarts",
+        "D": "Logs the value `\"2024-01-01\"` to the Databricks audit trail"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`dbutils.widgets` creates interactive input controls (text boxes, dropdowns, etc.) in the notebook UI. When the notebook is run as a Databricks Workflow job, the widget value can be overridden via job parameters or the `notebookParams` API. This makes notebooks parameterizable and reusable across different date ranges or environments.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q009",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 9",
+      "difficulty": "hard",
+      "question": "A data engineer examines the Spark UI after a job completes and sees one task taking 10× longer than all other tasks. What does this indicate?",
+      "choices": {
+        "A": "The cluster ran out of memory and had to spill to disk",
+        "B": "A data skew problem — one partition contains significantly more data than others",
+        "C": "The Photon engine failed to accelerate that specific task",
+        "D": "Network latency caused a delay in fetching data from cloud storage"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A single slow task (stragglers) in the Spark UI typically indicates data skew — one partition has significantly more rows than others, causing one executor to do disproportionately more work. Solutions include salting keys, using `skewHint`, or repartitioning. Memory spill shows in the Spark UI as shuffle spill metrics, not as a single slow task.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q010",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "A company migrates from an existing Hive metastore to Unity Catalog. What is the key advantage of Unity Catalog over the workspace-level Hive metastore?",
+      "choices": {
+        "A": "Unity Catalog stores data in a different file format for better performance",
+        "B": "Unity Catalog provides centralized governance, fine-grained access control, and data lineage across multiple workspaces",
+        "C": "Unity Catalog eliminates the need for any access control configuration",
+        "D": "Unity Catalog is faster because it uses an in-memory metadata cache"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog provides a centralized governance layer that spans multiple Databricks workspaces and accounts. It offers fine-grained table, column, and row-level security, automated data lineage tracking, and audit logs — none of which are available in the per-workspace Hive metastore. The metastore stores metadata; performance depends on the underlying data files.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q011",
+      "domain": "databricks-lakehouse-platform",
+      "title": "Question 11",
+      "difficulty": "easy",
+      "question": "A data engineer needs to run a Python script on a Databricks cluster that monitors a directory and triggers processing when new files arrive. Which `dbutils` module is used to interact with the file system?",
+      "choices": {
+        "A": "`dbutils.secrets`",
+        "B": "`dbutils.jobs`",
+        "C": "`dbutils.fs`",
+        "D": "`dbutils.notebook`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`dbutils.fs` provides file system utilities for listing, moving, copying, and deleting files in DBFS and cloud storage paths. Common operations: `dbutils.fs.ls()`, `dbutils.fs.cp()`, `dbutils.fs.rm()`. `dbutils.secrets` manages credentials. `dbutils.notebook` runs and exits notebooks. `dbutils.jobs` is not a valid module.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q012",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "A data engineer needs to replace all data in a partition of a Delta table with new data, without affecting other partitions. Which SQL command accomplishes this?",
+      "choices": {
+        "A": "`DELETE FROM table WHERE partition_col = 'value'` followed by `INSERT INTO`",
+        "B": "`INSERT OVERWRITE table PARTITION (partition_col = 'value') SELECT ...`",
+        "C": "`TRUNCATE TABLE table` then `INSERT INTO table SELECT ...`",
+        "D": "`CREATE OR REPLACE TABLE table AS SELECT ...`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`INSERT OVERWRITE ... PARTITION (...)` replaces data in the specified partition atomically while leaving other partitions untouched. `TRUNCATE TABLE` removes all data from all partitions. `CREATE OR REPLACE TABLE` replaces the entire table. The `DELETE` + `INSERT` approach works but is not atomic — `INSERT OVERWRITE` is preferred for partition replacement.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q013",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 13",
+      "difficulty": "medium",
+      "question": "A data engineer must choose between COPY INTO and Auto Loader for ingesting files from cloud storage. Which statement correctly describes when to use each?",
+      "choices": {
+        "A": "COPY INTO is for structured files; Auto Loader is for unstructured files",
+        "B": "COPY INTO is idempotent and suits smaller, known file sets; Auto Loader suits continuous, large-scale ingestion with automatic file tracking",
+        "C": "Auto Loader is deprecated; COPY INTO is the only recommended approach",
+        "D": "Both are equivalent — the choice is purely based on personal preference"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "COPY INTO is a SQL command that idempotently loads files into a Delta table (skipping already-loaded files) — suitable for smaller or periodic batch loads from a known set of files. Auto Loader uses checkpointing and cloud notifications to efficiently handle millions of files continuously at scale, making it the recommended approach for streaming ingestion pipelines.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q014",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 14",
+      "difficulty": "easy",
+      "question": "A data engineer has a column `price` stored as `STRING` type and needs to cast it to `DOUBLE` for calculations. Which SQL expression correctly performs this conversion?",
+      "choices": {
+        "A": "`CONVERT(price, DOUBLE)`",
+        "B": "`price::DOUBLE`",
+        "C": "`CAST(price AS DOUBLE)`",
+        "D": "`TO_DOUBLE(price)`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`CAST(column AS type)` is the standard SQL syntax for type conversion in Databricks SQL and Spark SQL. Databricks also supports the shorthand `column::type` (PostgreSQL-style). `CONVERT()` is valid in some SQL dialects but not Databricks SQL. `TO_DOUBLE()` is not a Databricks function.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q015",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "A data engineer writes `SELECT * FROM orders WHERE discount IS NOT NULL AND discount != 0`. A row with `discount = NULL` — will it be returned?",
+      "choices": {
+        "A": "Yes — `IS NOT NULL` matches NULL values",
+        "B": "No — `IS NOT NULL` excludes NULL values; rows with NULL discount are filtered out",
+        "C": "Yes — `discount != 0` returns all non-zero values including NULL",
+        "D": "A SQL error occurs because you cannot compare NULL with `!=`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`IS NOT NULL` filters out rows where the column contains NULL. Since both conditions are joined with `AND`, a row with `NULL` discount fails the `IS NOT NULL` check and is excluded. In SQL, `NULL != 0` evaluates to NULL (not TRUE), so NULL values are also excluded by the `!=` comparison — but `IS NOT NULL` already removes them first.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q016",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 16",
+      "difficulty": "medium",
+      "question": "A data engineer writes Delta table data using `df.write.format(\"delta\").mode(\"append\").save(path)`. What happens if the path already contains a Delta table with a different schema?",
+      "choices": {
+        "A": "The write succeeds and merges the schemas automatically",
+        "B": "The write fails with a `AnalysisException` due to schema mismatch unless `mergeSchema` is enabled",
+        "C": "The existing table is overwritten with the new schema",
+        "D": "The new data is silently dropped and the existing table is unchanged"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake enforces schema consistency by default. Appending data with a different schema throws an `AnalysisException`. To allow schema evolution during appends, enable `.option(\"mergeSchema\", \"true\")` which adds new columns from the source. Overwriting behavior requires `.mode(\"overwrite\")`, not `\"append\"`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q017",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "A data engineer calls `df.cache()` on a large DataFrame and then performs three different filter operations on it. What is the primary benefit of caching here?",
+      "choices": {
+        "A": "Caching compresses the DataFrame to reduce memory usage",
+        "B": "The cached DataFrame is stored in memory so subsequent operations avoid re-reading from disk/cloud storage",
+        "C": "Caching enables parallel writes to multiple Delta tables simultaneously",
+        "D": "Caching forces the DataFrame to be computed immediately (eager evaluation)"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`cache()` (or `persist()`) stores the DataFrame in memory after the first computation. Subsequent actions on the cached DataFrame skip re-reading from cloud storage and re-applying upstream transformations, significantly speeding up iterative operations like multiple filters on the same base dataset. Spark is still lazy — `cache()` itself doesn't trigger computation.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q018",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 18",
+      "difficulty": "medium",
+      "question": "A data engineer needs to share a large lookup dictionary across all tasks in a Spark job without sending it with every task. Which Spark mechanism is designed for this?",
+      "choices": {
+        "A": "Accumulators — distributed variables that collect values from executors",
+        "B": "Broadcast variables — distributes a read-only variable to all executors once",
+        "C": "Checkpointing — saves the variable to a reliable storage location",
+        "D": "DataFrames — the correct way to share data between Spark tasks"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Broadcast variables distribute a read-only value (like a lookup dictionary) to each executor once rather than sending it with every task. This is far more efficient than including it in task closures or joining DataFrames when one side is small. Accumulators collect values FROM executors to the driver (e.g., counters). Checkpointing is for fault-tolerant state storage.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q019",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 19",
+      "difficulty": "easy",
+      "question": "A data engineer defines a complex PySpark transformation pipeline with multiple `.filter()`, `.select()`, and `.groupBy()` calls. When does Spark actually execute these transformations?",
+      "choices": {
+        "A": "Each transformation executes immediately when the line of code runs",
+        "B": "Transformations execute when the Python interpreter compiles the script",
+        "C": "Transformations are lazy — they execute only when an action like `.count()`, `.show()`, or `.write()` is triggered",
+        "D": "Transformations execute in the background as soon as the cluster accepts the job"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Spark uses lazy evaluation — transformations (filter, select, groupBy, join, etc.) build a logical plan but execute nothing. Only when an action (count, show, collect, write, save) is called does Spark optimize and execute the full plan. This enables the Catalyst optimizer to combine and reorder operations for maximum efficiency.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q020",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "A data engineer writes `df = spark.read.format(\"delta\").load(\"/path/to/table\")`. What is the difference if they use `spark.readStream` instead of `spark.read`?",
+      "choices": {
+        "A": "`readStream` reads the entire table into memory at once; `read` reads in chunks",
+        "B": "`readStream` returns a streaming DataFrame that only processes new files/rows added since the last checkpoint",
+        "C": "There is no difference — both return identical DataFrames",
+        "D": "`readStream` automatically converts the Delta table to a Kafka stream"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`spark.readStream.format(\"delta\").load(path)` creates a streaming DataFrame that treats the Delta table as a streaming source. It processes only new data (rows appended after the checkpoint) in each micro-batch. `spark.read` returns a static (batch) DataFrame representing the full table at the time of reading. The two APIs have fundamentally different execution semantics.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q021",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 21",
+      "difficulty": "easy",
+      "question": "A data engineer queries a table with millions of rows and needs to know the count of distinct values in a column. Which function returns this?",
+      "choices": {
+        "A": "`COUNT(column)`",
+        "B": "`COUNT(DISTINCT column)`",
+        "C": "`SUM(DISTINCT column)`",
+        "D": "`APPROX_COUNT_DISTINCT(column)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`COUNT(DISTINCT column)` returns the exact number of distinct non-NULL values in the column. `COUNT(column)` counts non-NULL rows including duplicates. `SUM(DISTINCT column)` sums distinct numeric values, not counts. `APPROX_COUNT_DISTINCT()` uses HyperLogLog for an approximate count — faster for very large datasets but not exact.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q022",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "A data engineer uses `collect_list()` and `collect_set()` in a GROUP BY aggregation. What is the difference between these two functions?",
+      "choices": {
+        "A": "`collect_list` returns a sorted array; `collect_set` returns an unsorted array",
+        "B": "`collect_list` preserves duplicates in the array; `collect_set` returns only distinct values",
+        "C": "`collect_set` works on numeric types only; `collect_list` works on any type",
+        "D": "Both functions are identical — the names are aliases for the same behavior"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`collect_list(col)` aggregates all values into an array including duplicates, preserving order. `collect_set(col)` aggregates into an array of unique values, with no guaranteed ordering. Use `collect_list` when duplicates and order matter; use `collect_set` when you only need distinct values.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q023",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "A data engineer receives a DataFrame with a column containing nested arrays of arrays (e.g., `[[1,2],[3,4]]`). Which function flattens this into a single-level array (e.g., `[1,2,3,4]`)?",
+      "choices": {
+        "A": "`explode()`",
+        "B": "`flatten()`",
+        "C": "`array_join()`",
+        "D": "`transform()`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`flatten(array_of_arrays)` converts a nested array (array of arrays) into a single flat array by concatenating the inner arrays. `explode()` creates one row per element — it doesn't flatten, it unnests. `array_join()` converts an array to a string. `transform()` applies a lambda to each element, producing an array of the same depth.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q024",
+      "domain": "elt-with-spark-sql-and-python",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "A data engineer uses `dbutils.notebook.run(\"./child_notebook\", timeout_seconds=300, arguments={\"date\": \"2024-01-15\"})`. What does this accomplish?",
+      "choices": {
+        "A": "Runs the child notebook asynchronously in a separate Databricks job",
+        "B": "Runs the child notebook synchronously in the current cluster, passing the date argument as a widget value",
+        "C": "Schedules the child notebook to run at the specified timeout in 300 seconds",
+        "D": "Creates a permanent link between the parent and child notebook that runs on every commit"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`dbutils.notebook.run()` executes another notebook synchronously on the current cluster with a timeout. The `arguments` dictionary sets widget values in the child notebook. It blocks until the child completes or times out. Unlike `%run`, the child notebook runs in an isolated scope and its variables are not imported into the parent.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q025",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "A data engineer runs `DESCRIBE HISTORY transactions` on a Delta table. What information does this return?",
+      "choices": {
+        "A": "The table schema (column names, types, and nullability)",
+        "B": "A log of all operations performed on the table including version, timestamp, operation, and user",
+        "C": "The current partition layout and file sizes",
+        "D": "The table's Z-ORDER configuration and data skipping statistics"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`DESCRIBE HISTORY` returns the Delta transaction log as a table, showing each commit's version number, timestamp, operation type (WRITE, MERGE, DELETE, OPTIMIZE, etc.), the user who performed it, and operation parameters. `DESCRIBE TABLE` or `DESCRIBE DETAIL` shows schema and partition info. Data skipping stats are in `DESCRIBE DETAIL`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q026",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "A data engineer accidentally ran `DELETE FROM customers WHERE 1=1` which deleted all rows. The table is named `customers` in Delta format. How can they recover the data?",
+      "choices": {
+        "A": "`INSERT INTO customers SELECT * FROM customers VERSION AS OF previous_version`",
+        "B": "`RESTORE TABLE customers TO VERSION AS OF previous_version`",
+        "C": "Contact Databricks Support — deleted data cannot be recovered from Delta tables",
+        "D": "Rerun the original data ingestion pipeline to recreate the data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`RESTORE TABLE ... TO VERSION AS OF` (or `TIMESTAMP AS OF`) is the correct command to restore a Delta table to a previous version. It is an atomic operation that restores the table by re-referencing the old data files. This works as long as `VACUUM` has not deleted the files for that version. Option A creates a new table rather than restoring in-place.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q027",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 27",
+      "difficulty": "medium",
+      "question": "A data engineer needs a copy of a Delta table to test schema changes without affecting production. They need the copy to be fast and space-efficient, sharing underlying files with the source. Which clone type should they use?",
+      "choices": {
+        "A": "Deep clone — copies all data files to a new location",
+        "B": "Shallow clone — creates a copy that references the source table's data files without copying them",
+        "C": "CTAS (CREATE TABLE AS SELECT) — creates an independent copy with full data duplication",
+        "D": "Databricks snapshot — an automatic backup created by the platform"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Shallow clone creates a Delta table that references the source's data files without copying them, making it fast and storage-efficient. Schema and metadata are independent, so changes to the clone don't affect the source. Deep clone physically copies all data files to a new location — useful for true independence. CTAS also copies all data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q028",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "A data engineer configures Auto Loader with `cloudFiles.schemaEvolutionMode = \"addNewColumns\"`. A new column appears in incoming JSON files. What happens?",
+      "choices": {
+        "A": "Auto Loader fails with a schema mismatch error",
+        "B": "The new column is silently ignored and not written to the Delta table",
+        "C": "Auto Loader automatically adds the new column to the target Delta table schema",
+        "D": "Auto Loader quarantines files with new columns for manual review"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`schemaEvolutionMode = \"addNewColumns\"` instructs Auto Loader to automatically detect new columns in the source data and add them to the target Delta table schema via `mergeSchema`. Files with the new column are processed normally. The default mode `\"rescue\"` puts unexpected columns into a rescue column instead of evolving the schema.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q029",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 29",
+      "difficulty": "hard",
+      "question": "A data engineer sets a watermark on a streaming query: `withWatermark(\"event_time\", \"10 minutes\")`. What is the purpose of this watermark?",
+      "choices": {
+        "A": "Ensures that data older than 10 minutes is deleted from the Delta table",
+        "B": "Defines the maximum tolerated lateness for event-time-based aggregations, allowing late data up to 10 minutes after the window closes",
+        "C": "Buffers all incoming data for exactly 10 minutes before writing to the sink",
+        "D": "Limits the streaming query to process at most 10 minutes of historical data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Watermarks in Spark Structured Streaming define how late data can arrive and still be included in aggregations. A 10-minute watermark means data with an event_time up to 10 minutes behind the current watermark is included; older data is dropped. This allows Spark to bound the state size by eventually discarding old windows.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q030",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "A data engineer compares two streaming trigger settings: `trigger(processingTime=\"1 minute\")` and `trigger(availableNow=True)`. Which scenario is best suited for each?",
+      "choices": {
+        "A": "`processingTime` for one-time batch runs; `availableNow` for continuous low-latency streams",
+        "B": "`processingTime` for continuous micro-batch streaming on a 1-minute interval; `availableNow` for scheduled jobs that process all pending data then stop",
+        "C": "Both are equivalent — the difference is only in the polling interval",
+        "D": "`processingTime` is deprecated; use `availableNow` for all streaming jobs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`trigger(processingTime=\"1 minute\")` runs micro-batches on a fixed 1-minute interval indefinitely — suitable for continuous, near-real-time streaming. `trigger(availableNow=True)` processes all currently available data and terminates — suitable for scheduled pipeline runs where a streaming source needs batch-style processing. Neither is deprecated.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q031",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 31",
+      "difficulty": "hard",
+      "question": "A data engineer needs to delete records from a Delta table where a customer opted out, and also update other customers' status in the same operation. Which SQL command handles both in a single atomic operation?",
+      "choices": {
+        "A": "Run `DELETE` and `UPDATE` as separate transactions in sequence",
+        "B": "`MERGE INTO customers USING opt_outs ON ... WHEN MATCHED AND condition THEN DELETE WHEN MATCHED AND other_condition THEN UPDATE SET ...`",
+        "C": "`TRUNCATE TABLE customers` then reinsert only the retained records",
+        "D": "Use a Python loop to delete and update records one by one"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake's `MERGE` statement supports multiple `WHEN MATCHED` clauses with different conditions — one can trigger `DELETE` and another can trigger `UPDATE SET`. This executes atomically in a single pass over the data. Running `DELETE` and `UPDATE` as separate transactions is correct but not atomic as a combined unit. `TRUNCATE` and reinsert is expensive and error-prone.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q032",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 32",
+      "difficulty": "medium",
+      "question": "A data engineer wants to enable Change Data Feed (CDF) on an existing Delta table. Which command accomplishes this?",
+      "choices": {
+        "A": "`ALTER TABLE customers SET TBLPROPERTIES ('delta.enableChangeDataFeed' = 'true')`",
+        "B": "`CREATE TABLE customers USING DELTA WITH (enableCDF = true)`",
+        "C": "`SET spark.databricks.delta.changeDataFeed.enabled = true`",
+        "D": "CDF is enabled by default on all Delta tables; no action is needed"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Change Data Feed is enabled per-table using `ALTER TABLE ... SET TBLPROPERTIES ('delta.enableChangeDataFeed' = 'true')`. For new tables, use `CREATE TABLE ... TBLPROPERTIES ('delta.enableChangeDataFeed' = 'true')`. The Spark config in option C sets a workspace-level default but does not retroactively enable CDF on existing tables. CDF is not on by default.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q033",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 33",
+      "difficulty": "hard",
+      "question": "A data engineer runs `OPTIMIZE transactions ZORDER BY (customer_id, transaction_date)`. How does Z-ORDER with multiple columns differ from Z-ORDER with a single column?",
+      "choices": {
+        "A": "Z-ORDER with multiple columns is invalid — only one column is allowed",
+        "B": "Z-ORDER with multiple columns co-locates data that shares similar values across all specified columns, optimizing queries filtering on any combination of those columns",
+        "C": "Z-ORDER applies the first column's ordering first; the second column only applies within ties",
+        "D": "Each column is independently Z-ORDERed in separate file groups"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Z-ORDER with multiple columns uses a space-filling curve to interleave the sort dimensions, co-locating rows that are similar in all specified columns simultaneously. This enables data skipping for queries filtering on `customer_id`, `transaction_date`, or both together. Option C describes a lexicographic sort, which is not how Z-ORDER works.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q034",
+      "domain": "incremental-data-processing-delta-lake",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "A data engineer has a CSV directory and wants to convert it to a managed Delta table in Unity Catalog. Which approach creates a properly managed Delta table?",
+      "choices": {
+        "A": "`CONVERT TO DELTA parquet.'/path/to/csv/'` — converts any format to Delta",
+        "B": "`CREATE TABLE catalog.schema.table USING DELTA AS SELECT * FROM csv.'/path/'`",
+        "C": "`ALTER TABLE csv_table SET TYPE DELTA`",
+        "D": "Delta tables can only be created from Parquet format; CSV must first be converted to Parquet"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CREATE TABLE ... USING DELTA AS SELECT * FROM csv.'/path/'` reads the CSV files and creates a new managed Delta table with the query results. `CONVERT TO DELTA` works only on Parquet-formatted directories (not CSV). `ALTER TABLE SET TYPE` is not valid Databricks SQL syntax. Delta tables can be created from any format via CTAS.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q035",
+      "domain": "production-pipelines",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A DLT pipeline runs a full refresh. How does a full refresh differ from a standard pipeline update?",
+      "choices": {
+        "A": "A full refresh only processes files added in the last 24 hours",
+        "B": "A full refresh truncates all materialized tables and recomputes them from scratch using all source data",
+        "C": "A full refresh updates only the tables with failed expectations from the previous run",
+        "D": "A full refresh is identical to a standard update — the terminology is interchangeable"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A full refresh in Delta Live Tables drops all data in the pipeline's materialized tables and recomputes everything from the original sources. This is useful after fixing pipeline logic or recovering from data corruption. A standard update (incremental) processes only new data since the last checkpoint. Full refreshes are more expensive since they reprocess all historical data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q036",
+      "domain": "production-pipelines",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "A DLT pipeline has an `EXPECT` constraint with no `ON VIOLATION` modifier. A record fails the constraint. What is the default behavior?",
+      "choices": {
+        "A": "The pipeline fails and stops processing",
+        "B": "The violating record is dropped silently",
+        "C": "The violating record is written to the output table and the violation is logged in the event log as a warning",
+        "D": "The violating record is written to a quarantine table for review"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The default behavior of `EXPECT` without an `ON VIOLATION` modifier is `WARN` — all records (including violating ones) are written to the output table, and the number of violations is tracked in the DLT event log as metrics. To drop records, use `ON VIOLATION DROP ROW`. To fail the pipeline, use `ON VIOLATION FAIL UPDATE`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q037",
+      "domain": "production-pipelines",
+      "title": "Question 37",
+      "difficulty": "easy",
+      "question": "A data engineer wants to receive an email when a Databricks Workflow job fails. Where is this configured?",
+      "choices": {
+        "A": "In the cluster configuration under \"Termination Notifications\"",
+        "B": "In the job's \"Notifications\" settings, where email addresses can be added for failure, success, or start events",
+        "C": "Through a separate alerting notebook that monitors job status via the Jobs API",
+        "D": "In the Databricks workspace admin settings under \"Global Notifications\""
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Workflows has a built-in \"Notifications\" section in the job configuration where you can specify email addresses to notify on job start, job success, job failure, and task failure events. This is configured per-job, not globally. A separate monitoring notebook is an alternative but unnecessary when built-in notifications are available.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q038",
+      "domain": "production-pipelines",
+      "title": "Question 38",
+      "difficulty": "medium",
+      "question": "A data engineer uses task values to pass a dynamically computed date from Task A to Task B in a multi-task Databricks Workflow. Which `dbutils` functions are used to set and retrieve the value?",
+      "choices": {
+        "A": "`dbutils.jobs.set(\"key\", value)` in Task A; `dbutils.jobs.get(\"key\")` in Task B",
+        "B": "`dbutils.taskValues.set(\"key\", value)` in Task A; `dbutils.taskValues.get(\"taskName\", \"key\")` in Task B",
+        "C": "`dbutils.widgets.set(\"key\", value)` in Task A; `dbutils.widgets.get(\"key\")` in Task B",
+        "D": "Write the value to DBFS in Task A; read from DBFS in Task B"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`dbutils.taskValues.set(key, value)` sets a value in the current task's output. Downstream tasks retrieve it with `dbutils.taskValues.get(taskName, key)` where `taskName` is the name of the upstream task that set the value. Widgets are for parameterizing notebooks, not passing values between tasks. DBFS would work but is an anti-pattern compared to the built-in task values API.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q039",
+      "domain": "production-pipelines",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A production Databricks Workflow job runs a task that occasionally takes much longer than usual due to data volume spikes. To prevent the job from running indefinitely, which configuration should the engineer set?",
+      "choices": {
+        "A": "Retry policy with maximum retries set to 1",
+        "B": "Task timeout — the maximum time in seconds a task is allowed to run before it is cancelled",
+        "C": "Cluster autotermination minutes on the job cluster",
+        "D": "Maximum concurrent runs set to 1"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Task timeout defines the maximum wall-clock time a task is allowed to run before Databricks automatically cancels it and marks the task as failed. This prevents runaway jobs from consuming resources indefinitely. Retry policy controls what happens after failure. Autotermination applies to idle clusters, not running tasks. Max concurrent runs controls parallel job instances.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q040",
+      "domain": "production-pipelines",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "A Databricks Workflow multi-task job has tasks A → B → C (sequential dependency). Task B fails. What is the default behavior for Task C?",
+      "choices": {
+        "A": "Task C runs anyway, using the last successful output from Task B",
+        "B": "Task C is skipped and marked as `SKIPPED` because its upstream dependency failed",
+        "C": "Task C waits indefinitely for Task B to be manually retried",
+        "D": "The entire job reruns from Task A automatically"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When an upstream task fails in a Databricks Workflow, all downstream tasks that depend on it are automatically marked as `SKIPPED`. Databricks does not run dependent tasks if their dependencies failed. If the job has retry configured, the failed task is retried first. Task C is not retried or rerun automatically.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q041",
+      "domain": "production-pipelines",
+      "title": "Question 41",
+      "difficulty": "hard",
+      "question": "A data engineer needs to query the Delta Live Tables event log to find pipeline runs where expectations failed. Which system table or approach provides this information?",
+      "choices": {
+        "A": "`DESCRIBE HISTORY pipeline_name` — shows all pipeline execution history",
+        "B": "Query the DLT event log table stored at the pipeline's storage location, filtering for `eventType = 'flow_progress'` records",
+        "C": "`SELECT * FROM system.pipelines.events` in Unity Catalog",
+        "D": "The DLT UI shows expectation violations but there is no queryable log"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Live Tables stores detailed event logs as a Delta table at `<pipeline_storage>/system/events`. Engineers can query this table to analyze pipeline runs, including `flow_progress` events which contain `data_quality` metrics showing expectation pass/fail counts. The UI visualizes this data, but the underlying table is also directly queryable for custom analysis.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q042",
+      "domain": "data-governance",
+      "title": "Question 42",
+      "difficulty": "easy",
+      "question": "A data engineer creates a new Delta table in Unity Catalog using `CREATE TABLE catalog.schema.table`. Who automatically becomes the table owner?",
+      "choices": {
+        "A": "The workspace admin who configured Unity Catalog",
+        "B": "The metastore admin",
+        "C": "The user who created the table (the current session's identity)",
+        "D": "Ownership is not assigned until explicitly set with `ALTER TABLE ... OWNER TO`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "In Unity Catalog, the user who creates an object (table, schema, catalog) automatically becomes its owner. Owners have full control over the object, including the ability to grant privileges to others and transfer ownership. Ownership can be transferred using `ALTER TABLE ... OWNER TO new_owner`.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q043",
+      "domain": "data-governance",
+      "title": "Question 43",
+      "difficulty": "medium",
+      "question": "A data engineer needs to restrict certain users from seeing the full value of a `ssn` (social security number) column, showing only the last 4 digits instead. Which Unity Catalog feature implements this?",
+      "choices": {
+        "A": "Row-level security policy with a `WHERE` clause filter",
+        "B": "Column masking policy that replaces the column value with a masked version based on user identity",
+        "C": "Dynamic view with `CASE WHEN current_user() = 'admin' THEN ssn ELSE NULL END`",
+        "D": "Remove the column from the table and create a separate table for privileged users"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog column masking policies apply a transformation function to a column's value based on the requesting user's identity or group membership. For example, showing only `'***-**-' || RIGHT(ssn, 4)` to non-privileged users while showing the full value to authorized users. Dynamic views (option C) also work but require maintaining a separate view object. Column masking is the purpose-built Unity Catalog feature.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q044",
+      "domain": "data-governance",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "A data engineer creates an external table in Unity Catalog pointing to an S3 path. What happens to the underlying data files when the table is dropped with `DROP TABLE`?",
+      "choices": {
+        "A": "The data files are deleted along with the table metadata",
+        "B": "The data files are retained in cloud storage; only the table metadata (catalog registration) is removed",
+        "C": "The data files are moved to a Unity Catalog-managed trash location for 30 days",
+        "D": "`DROP TABLE` fails on external tables — you must use `DROP EXTERNAL TABLE`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "External tables in Unity Catalog (and Databricks in general) only store metadata — the table definition pointing to an external cloud storage location. When dropped, only the metadata registration is removed. The underlying data files in S3 or ADLS are untouched. This is the key difference from managed tables, where dropping the table also deletes the data files.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-associate-mock-2-q045",
+      "domain": "data-governance",
+      "title": "Question 45",
+      "difficulty": "medium",
+      "question": "A data engineer queries `SELECT * FROM system.access.audit LIMIT 100` and sees events with `actionName = 'getTable'`. What do these events represent?",
+      "choices": {
+        "A": "Metadata queries where a user read the table's schema or properties",
+        "B": "Full table scans where all rows were returned to the user",
+        "C": "Table creation events logged when a new table is registered",
+        "D": "Failed access attempts where permission was denied"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "In Databricks audit logs, `getTable` action events are recorded when a user reads a table's metadata (schema, properties, statistics) — this includes actions like `DESCRIBE TABLE` or when a BI tool queries the catalog for table info. Full data reads are logged as `commandSubmit`/`commandFinish` events. Permission denials are recorded as separate audit events with error details.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-engineer-associate"
+}
diff --git a/practice/data/data-engineer-associate.json b/practice/data/data-engineer-associate.json
index 7323aa6..41b5d43 100644
--- a/practice/data/data-engineer-associate.json
+++ b/practice/data/data-engineer-associate.json
@@ -2,7 +2,7 @@
   "cert": "data-engineer-associate",
   "certTitle": "Data Engineer Associate",
   "blueprintVersion": "May 2026",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "lakehouse-platform",
diff --git a/practice/data/data-engineer-professional-mock-1.json b/practice/data/data-engineer-professional-mock-1.json
new file mode 100644
index 0000000..18c6e7d
--- /dev/null
+++ b/practice/data/data-engineer-professional-mock-1.json
@@ -0,0 +1,1062 @@
+{
+  "cert": "data-engineer-professional-mock-1",
+  "certTitle": "Data Engineer Professional — Mock Exam 1",
+  "blueprintVersion": "Nov 30, 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "section-1-data-processing",
+      "name": "Section 1: Data Processing",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 18
+    },
+    {
+      "id": "section-2-databricks-tooling",
+      "name": "Section 2: Databricks Tooling",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 12
+    },
+    {
+      "id": "section-3-data-modeling",
+      "name": "Section 3: Data Modeling",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "section-4-security-governance",
+      "name": "Section 4: Security & Governance",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-5-monitoring-logging",
+      "name": "Section 5: Monitoring & Logging",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-6-testing-deployment",
+      "name": "Section 6: Testing & Deployment",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-7-lakeflow-pipelines-performance",
+      "name": "Section 7: Lakeflow Pipelines & Performance",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam/questions.md",
+      "questionCount": 6
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-engineer-professional-mock-1-q001",
+      "domain": "section-1-data-processing",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "Which Auto Loader configuration will automatically detect and add new columns to the target Delta table?",
+      "choices": {
+        "A": "`cloudFiles.inferColumnTypes = true`",
+        "B": "`cloudFiles.format = json` with `rescuedDataColumn`",
+        "C": "`cloudFiles.schemaLocation` with `mergeSchema = true`",
+        "D": "`cloudFiles.schemaEvolutionMode = addNewColumns`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`cloudFiles.schemaEvolutionMode = addNewColumns` is the Auto Loader configuration that automatically detects and adds new columns to the target schema. Option A only controls type inference, not schema evolution. Option C uses `schemaLocation` for storing schema but `mergeSchema` is a Delta write option, not Auto Loader. Option B captures unparseable data but doesn't handle schema evolution.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q002",
+      "domain": "section-1-data-processing",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "Which trigger configuration balances latency and file size for this workload?",
+      "choices": {
+        "A": "`trigger(availableNow=True)`",
+        "B": "`trigger(processingTime=\"1 second\")`",
+        "C": "`trigger(processingTime=\"1 minute\")`",
+        "D": "`trigger(once=True)`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A 1-minute processing time trigger allows sufficient data to accumulate for larger file writes while maintaining reasonable latency. Option A processes all available data at once (batch-like). Option B writes too frequently, creating small files. Option D is for one-time batch processing, not continuous streaming.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q003",
+      "domain": "section-1-data-processing",
+      "title": "Question 3",
+      "difficulty": "hard",
+      "question": "Which approach correctly implements this SCD Type 2 pattern using Delta Lake?",
+      "choices": {
+        "A": "Use `MERGE INTO` with `WHEN MATCHED AND target.is_current = true THEN UPDATE` to close the old record, then `INSERT` the new record",
+        "B": "Use `MERGE INTO` with `WHEN MATCHED THEN UPDATE` to update the existing record",
+        "C": "Use `INSERT OVERWRITE` to replace all records for the customer",
+        "D": "Use `DELETE` followed by `INSERT` to replace the customer record"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "SCD Type 2 requires closing the current record (setting end_date and is_current=false) and inserting a new record. The MERGE statement with a condition on `is_current = true` ensures only the active record is updated. Options B and D implement SCD Type 1 (overwrite). Option C would lose history.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q004",
+      "domain": "section-1-data-processing",
+      "title": "Question 4",
+      "difficulty": "medium",
+      "question": "Which Auto Loader configuration achieves both requirements?",
+      "choices": {
+        "A": "Set `cloudFiles.schemaLocation` and `cloudFiles.schemaEvolutionMode = rescue`",
+        "B": "Set `cloudFiles.inferColumnTypes = true` and `badRecordsPath`",
+        "C": "Set `cloudFiles.schemaHints` with all expected columns",
+        "D": "Set `cloudFiles.format = json` with `mode = PERMISSIVE`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`cloudFiles.schemaLocation` persists the inferred schema to a directory so it's reused across restarts. `schemaEvolutionMode = rescue` captures data that doesn't match the schema into a `_rescued_data` column instead of failing. Option B's `badRecordsPath` is for batch reads. Option C provides hints but doesn't persist schema or rescue data. Option D uses invalid configuration syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q005",
+      "domain": "section-1-data-processing",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "Which combination ensures exactly-once processing guarantees?",
+      "choices": {
+        "A": "`outputMode(\"append\")` with checkpointing enabled",
+        "B": "`outputMode(\"complete\")` with `foreachBatch()` and manual deduplication",
+        "C": "`outputMode(\"append\")` with checkpointing and idempotent Delta writes",
+        "D": "`outputMode(\"update\")` with watermarking"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Exactly-once semantics require checkpointing (for tracking progress) combined with idempotent writes (Delta Lake's transaction log ensures writes are atomic and can be retried safely). Option A lacks idempotency mention. Option B requires manual handling. Option D is for stateful aggregations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q006",
+      "domain": "section-1-data-processing",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "Which code correctly reads incremental changes from the CDF-enabled table?",
+      "choices": {
+        "A": "`spark.read.format(\"delta\").option(\"readChangeFeed\", \"true\").table(\"bronze\")`",
+        "B": "`spark.readStream.format(\"delta\").option(\"ignoreChanges\", \"true\").table(\"bronze\")`",
+        "C": "`spark.read.format(\"delta\").option(\"startingVersion\", last_version).table(\"bronze\")`",
+        "D": "`spark.readStream.format(\"delta\").option(\"readChangeFeed\", \"true\").table(\"bronze\")`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Using `readStream` with `readChangeFeed = true` creates a streaming source that automatically tracks progress and reads only new changes. Option A is batch read (would need version parameters). Option C reads snapshots, not change records. Option B ignores changes rather than reading them.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q007",
+      "domain": "section-1-data-processing",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "What is the most effective optimization for this MERGE operation?",
+      "choices": {
+        "A": "Increase `spark.sql.shuffle.partitions` to 1000",
+        "B": "Add a Z-ORDER on `customer_id`",
+        "C": "Partition the table by `customer_id`",
+        "D": "Enable `spark.databricks.delta.merge.enableLowShuffle`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Z-ORDER on `customer_id` co-locates data with similar customer_id values, enabling file pruning during MERGE and dramatically reducing files scanned. Option A adds parallelism but doesn't reduce data scanned. Option C is impractical for high-cardinality columns. Option D is not a valid configuration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q008",
+      "domain": "section-1-data-processing",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "What is the expected behavior and how should the engineer address this?",
+      "choices": {
+        "A": "Increase the watermark to 20 minutes to capture more late data",
+        "B": "This is expected behavior; events beyond the watermark are intentionally dropped",
+        "C": "Set `spark.sql.streaming.stateStore.providerClass` to handle late data",
+        "D": "Use `outputMode(\"complete\")` to include all data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Watermarking intentionally drops data arriving after the threshold to bound state store size. Events 15 minutes late with a 10-minute watermark will be dropped by design. Option A could work but increases state size. Options C and D don't address late data handling. The engineer should evaluate if 10 minutes is the right threshold for their use case.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q009",
+      "domain": "section-1-data-processing",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "Which approach correctly handles multiple topics with independent schemas?",
+      "choices": {
+        "A": "Read all topics in one stream and use `filter()` to split by topic before writing",
+        "B": "Use `foreachBatch()` to route records to different tables based on topic",
+        "C": "Create separate streaming queries for each topic with independent checkpoints",
+        "D": "Use `readStream.format(\"kafka\").option(\"subscribe\", \"topic1,topic2\")` with schema registry"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Separate streaming queries with independent checkpoints provide isolation for different schemas and independent failure handling. Option A requires a common schema. Option B complicates checkpoint management. Option D subscribes to multiple topics but doesn't handle different schemas well.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q010",
+      "domain": "section-1-data-processing",
+      "title": "Question 10",
+      "difficulty": "easy",
+      "question": "What must be done to reclaim storage space after DELETE operations?",
+      "choices": {
+        "A": "Run `OPTIMIZE` to compact files",
+        "B": "Recreate the table using `CREATE TABLE AS SELECT`",
+        "C": "Run `FSCK REPAIR TABLE` to fix storage",
+        "D": "Run `VACUUM` with an appropriate retention period"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "DELETE in Delta Lake marks records as removed but doesn't physically delete files (to support time travel). VACUUM removes files older than the retention period that are no longer referenced. Option A compacts but doesn't remove old files. Option C checks table integrity. Option B is inefficient.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q011",
+      "domain": "section-1-data-processing",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "Which configuration ensures accurate aggregations while bounding state store growth?",
+      "choices": {
+        "A": "Set `outputMode(\"complete\")` to recompute all windows",
+        "B": "Add `withWatermark(\"timestamp\", \"2 hours\")` before the aggregation",
+        "C": "Use `outputMode(\"append\")` without watermarking",
+        "D": "Set `spark.sql.streaming.stateStore.maintenanceInterval` to \"1 hour\""
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Watermarking allows Spark to handle late data within the threshold (2 hours) while cleaning up state for windows that can no longer receive updates. Option A recomputes but doesn't bound state. Option C would drop late data immediately. Option D controls maintenance frequency, not late data handling.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q012",
+      "domain": "section-1-data-processing",
+      "title": "Question 12",
+      "difficulty": "hard",
+      "question": "What is the most likely cause of this issue?",
+      "choices": {
+        "A": "The checkpoint location is full",
+        "B": "Auto Loader's `cloudFiles.maxFilesPerTrigger` is set too low",
+        "C": "The source files are being written to a different path than configured",
+        "D": "The stream is waiting for the trigger interval"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A stream showing ACTIVE with 0 rows processed while files are arriving typically indicates the configured source path doesn't match where files are being written. Option A would cause errors, not zero processing. Option B would limit throughput but not stop it entirely. Option D wouldn't show persistent zero processing.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q013",
+      "domain": "section-1-data-processing",
+      "title": "Question 13",
+      "difficulty": "hard",
+      "question": "Which approach correctly handles this deduplication requirement?",
+      "choices": {
+        "A": "Use `dropDuplicates()` on the source DataFrame before MERGE",
+        "B": "Use multiple MERGE statements with different conditions",
+        "C": "Set `spark.databricks.delta.merge.repartitionBeforeWrite.enabled = true`",
+        "D": "Deduplicate within the MERGE using `ROW_NUMBER()` in a subquery"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Using `ROW_NUMBER()` partitioned by key and ordered by timestamp DESC in a subquery, then filtering for row_number = 1, deduplicates source data correctly within the MERGE while ensuring the latest record is kept. Option A (`dropDuplicates()`) is non-deterministic and doesn't guarantee keeping the record with the latest timestamp. Option C affects write performance, not deduplication. Option B is unnecessarily complex.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q014",
+      "domain": "section-1-data-processing",
+      "title": "Question 14",
+      "difficulty": "easy",
+      "question": "Which configuration captures malformed records while allowing the pipeline to continue?",
+      "choices": {
+        "A": "Set `cloudFiles.ignoreCorruptFiles = true`",
+        "B": "Set `badRecordsPath` to a storage location",
+        "C": "Use `cloudFiles.rescuedDataColumn` to capture unparseable data",
+        "D": "Wrap the read in a try-catch block"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`rescuedDataColumn` creates a column containing data that couldn't be parsed according to the schema, allowing analysis of bad records. Option A ignores corrupt files entirely. Option B is for batch operations. Option D doesn't work with streaming transformations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q015",
+      "domain": "section-1-data-processing",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "Which code pattern correctly implements incremental processing using CDF?",
+      "choices": {
+        "A": "Read with `option(\"readChangeFeed\", \"true\").option(\"startingVersion\", last_processed_version)`",
+        "B": "Read with `option(\"versionAsOf\", last_processed_version)` and compare with current version",
+        "C": "Use `CHANGES` table-valued function in SQL",
+        "D": "Read the `_delta_log` directly to find changed files"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Reading CDF with `startingVersion` returns all changes (inserts, updates, deletes) since that version, including `_change_type` column. Option B reads snapshots, not changes. Option C is not valid syntax. Option D is fragile and not recommended.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q016",
+      "domain": "section-1-data-processing",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "How does Delta Lake ensure consistent reads during concurrent writes?",
+      "choices": {
+        "A": "Delta uses table-level locks to prevent reads during writes",
+        "B": "Delta uses snapshot isolation; readers see consistent snapshots regardless of concurrent writes",
+        "C": "Delta queues read requests until writes complete",
+        "D": "Configure `delta.isolationLevel = serializable` to ensure consistency"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake provides snapshot isolation by default. Readers see a consistent snapshot based on the transaction log at query start time, regardless of concurrent writes. Option A is incorrect; Delta doesn't use table locks. Option C is incorrect; reads aren't queued. Option D is not a valid setting.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q017",
+      "domain": "section-1-data-processing",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "Which MERGE clause correctly implements this conditional update logic?",
+      "choices": {
+        "A": "`WHEN MATCHED AND source.timestamp > target.timestamp THEN UPDATE SET *`",
+        "B": "`WHEN MATCHED THEN UPDATE SET * WHERE source.timestamp > target.timestamp`",
+        "C": "`WHEN MATCHED THEN UPDATE SET target.* = source.* IF source.timestamp > target.timestamp`",
+        "D": "`WHEN MATCHED THEN UPDATE SET * HAVING source.timestamp > target.timestamp`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The condition in `WHEN MATCHED AND condition` filters which matched rows receive the update. Rows not meeting the condition are skipped. Option B has invalid syntax (WHERE after UPDATE SET). Options C and D use invalid syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q018",
+      "domain": "section-1-data-processing",
+      "title": "Question 18",
+      "difficulty": "hard",
+      "question": "How can the engineer achieve atomic writes across multiple tables in `foreachBatch()`?",
+      "choices": {
+        "A": "Wrap all writes in a single Spark transaction using `spark.sql(\"BEGIN TRANSACTION\")`",
+        "B": "Use Delta Lake's multi-table transactions with `spark.databricks.delta.multiTableTransaction.enabled`",
+        "C": "This cannot be achieved directly; implement idempotent writes with manual rollback logic",
+        "D": "Use `foreachPartition()` instead for transactional guarantees"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Delta Lake doesn't support multi-table transactions. The recommended approach is to make each write idempotent (using merge keys or batch IDs) so failed batches can be safely reprocessed. Options A and B describe non-existent features. Option D doesn't provide multi-table atomicity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q019",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "Which approach correctly implements parameterization for both use cases?",
+      "choices": {
+        "A": "Use `dbutils.widgets.text()` with defaults that can be overridden by job parameters",
+        "B": "Use environment variables set at cluster startup",
+        "C": "Use `spark.conf.get()` to read parameters from cluster configuration",
+        "D": "Hard-code values and create separate notebooks for each environment"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`dbutils.widgets` creates parameters with defaults for interactive use that can be overridden when called from jobs using the notebook task parameters. Option B requires cluster configuration. Option C requires cluster-level settings. Option D is unmaintainable.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q020",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "Which approach correctly captures SQL results in a Python variable?",
+      "choices": {
+        "A": "Use `%sql` and reference the `_sqldf` variable",
+        "B": "Use `%sql` with `INTO :variable_name` syntax",
+        "C": "Use `spark.sql()` and assign to a variable",
+        "D": "Use `%run` to execute a SQL notebook and capture results"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`spark.sql(\"SELECT ...\")` returns a DataFrame that can be assigned to a variable for further processing in Python. This is the recommended programmatic approach. Option A's `_sqldf` does exist in Databricks notebooks (it captures the last %sql result) but is implicit and less reliable for production code. Option B has invalid syntax. Option D doesn't capture SQL results.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q021",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 21",
+      "difficulty": "easy",
+      "question": "Which approach correctly implements secure credential management?",
+      "choices": {
+        "A": "Store the token in a notebook cell and delete it after running",
+        "B": "Store the token in a Delta table with restricted access",
+        "C": "Use environment variables on the cluster",
+        "D": "Use `dbutils.secrets.get(scope=\"api_scope\", key=\"api_token\")`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Databricks Secrets provides secure credential storage with access control. Secrets are encrypted at rest and redacted in logs. Option A exposes secrets in notebook history. Option B is not designed for secrets. Option C requires cluster admin access and isn't as secure.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q022",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 22",
+      "difficulty": "easy",
+      "question": "Which approach provides centralized code sharing with automatic updates?",
+      "choices": {
+        "A": "Copy utility functions into each notebook",
+        "B": "Use `%run /Workspace/Shared/utilities` at the start of each notebook",
+        "C": "Package utilities as a wheel file and install via `%pip install`",
+        "D": "Store utilities in a Delta table and read them at runtime"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`%run` executes another notebook in the current notebook's context, making all its functions available. Changes to the shared notebook are immediately available to all callers. Option A requires manual updates. Option C requires reinstallation for updates. Option D is impractical for code.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q023",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "Which authentication method is most appropriate for this CI/CD scenario?",
+      "choices": {
+        "A": "OAuth user-to-machine authentication",
+        "B": "Personal access token stored in `DATABRICKS_TOKEN` environment variable",
+        "C": "Service principal with `DATABRICKS_CLIENT_ID` and `DATABRICKS_CLIENT_SECRET`",
+        "D": "Username and password authentication"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Service principals with OAuth are the recommended approach for CI/CD automation. They provide machine identity without personal credentials and can be scoped with specific permissions. Option A requires user interaction. Option B uses personal tokens that expire. Option D is deprecated.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q024",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "What is the most likely cause and solution?",
+      "choices": {
+        "A": "The cluster creation is asynchronous; poll the cluster status until it's RUNNING",
+        "B": "The API token doesn't have permission to access the cluster",
+        "C": "The cluster_id was not properly formatted in the job request",
+        "D": "Rate limiting is preventing the second API call"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Cluster creation via API returns immediately with a cluster_id, but the cluster takes time to provision. The job API call failed because the cluster wasn't ready yet. The solution is to poll `GET /api/2.0/clusters/get` until state is RUNNING. Options B-D are possible but less likely given the described sequence.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q025",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 25",
+      "difficulty": "medium",
+      "question": "Which recommendation optimizes for cost while maintaining reliability?",
+      "choices": {
+        "A": "Use all-purpose clusters with auto-termination to save costs",
+        "B": "Use a shared all-purpose cluster across all jobs to maximize utilization",
+        "C": "Use serverless compute for all jobs regardless of workload characteristics",
+        "D": "Use job clusters which are automatically created and terminated per job run"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Job clusters are created for each job run and terminated afterward, providing cost savings (lower DBU rates) and isolation between runs. Option A still has higher DBU rates. Option B risks resource contention and failures affecting multiple jobs. Option C may not be cost-effective for predictable scheduled workloads.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q026",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "Which approach correctly accesses Unity Catalog volumes?",
+      "choices": {
+        "A": "`dbutils.fs.ls(\"dbfs:/Volumes/catalog/schema/volume\")`",
+        "B": "`dbutils.fs.ls(\"/Volumes/catalog/schema/volume\")`",
+        "C": "`spark.read.format(\"binaryFile\").load(\"dbfs:/Volumes/catalog/schema/volume\")`",
+        "D": "`os.listdir(\"/dbfs/Volumes/catalog/schema/volume\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog volumes are accessed via the `/Volumes` path without the `dbfs:` prefix. Option A uses the wrong path format. Option C reads file content, not metadata. Option D may work but `dbutils.fs` is the recommended approach for Databricks.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q027",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 27",
+      "difficulty": "easy",
+      "question": "How should the job task be configured to pass the parameter?",
+      "choices": {
+        "A": "In the notebook task configuration, set `base_parameters: {\"env\": \"prod\"}`",
+        "B": "Set cluster environment variable `ENV=prod`",
+        "C": "Use `spark.conf.set(\"env\", \"prod\")` in the job configuration",
+        "D": "Create a separate notebook for production without widgets"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The notebook task's `base_parameters` map directly to widget values, overriding defaults when the notebook runs as a job. Option B doesn't connect to widgets. Option C sets Spark config, not widget values. Option D is unmaintainable.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q028",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "Which API endpoint and request body correctly submits this job run?",
+      "choices": {
+        "A": "POST `/api/2.1/jobs/create` with `notebook_params` in the request",
+        "B": "PUT `/api/2.1/jobs/update` with `notebook_params` in the settings",
+        "C": "POST `/api/2.1/jobs/runs/submit` with `notebook_params` in the task configuration",
+        "D": "POST `/api/2.1/jobs/run-now` with `notebook_params` in the request"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`run-now` triggers an existing job with parameter overrides via `notebook_params`. Option A creates a job definition but doesn't run it. Option C submits a one-time run (requires full job spec). Option B updates job definition, doesn't run it.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q029",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 29",
+      "difficulty": "medium",
+      "question": "What is the recommended migration approach for accessing cloud storage with Unity Catalog?",
+      "choices": {
+        "A": "Update all paths to use `abfss://` or `s3://` URLs directly",
+        "B": "Create external locations in Unity Catalog and use `/Volumes/` paths",
+        "C": "Keep using mounts but register them as external locations",
+        "D": "Use storage credentials to access cloud storage via `dbutils.fs`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog volumes provide governed access to cloud storage with paths like `/Volumes/catalog/schema/volume/`. External locations and volumes replace the ungoverned mount pattern. Option A bypasses governance. Option C mixes patterns incorrectly. Option D doesn't leverage Unity Catalog.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q030",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "Which CLI command correctly executes a SQL query and formats output as JSON?",
+      "choices": {
+        "A": "`databricks sql execute --query \"SELECT * FROM table\" --format JSON`",
+        "B": "`databricks workspace execute-sql --statement \"SELECT * FROM table\" --output json`",
+        "C": "`databricks sql-cli -e \"SELECT * FROM table\" -o json`",
+        "D": "`databricks api post /api/2.0/sql/statements -d '{\"statement\": \"SELECT * FROM table\"}'`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The Databricks CLI can make arbitrary API calls. The SQL Statement Execution API (`/api/2.0/sql/statements`) executes SQL queries programmatically. Options A-C use non-existent CLI commands. The actual implementation may vary by CLI version, but the API approach always works.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q031",
+      "domain": "section-3-data-modeling",
+      "title": "Question 31",
+      "difficulty": "easy",
+      "question": "Which layer should handle flattening the nested JSON structure into a relational format?",
+      "choices": {
+        "A": "Bronze layer - ingest and flatten immediately",
+        "B": "Gold layer - create denormalized tables for analytics",
+        "C": "Silver layer - transform raw data into cleaned, conformed structures",
+        "D": "A separate staging layer before bronze"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The silver layer is responsible for data cleansing and conforming, including flattening nested structures. Bronze should preserve raw data as-is for auditability. Gold focuses on business aggregations. Option D adds unnecessary complexity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q032",
+      "domain": "section-3-data-modeling",
+      "title": "Question 32",
+      "difficulty": "easy",
+      "question": "What happens when this data is written to the table?",
+      "choices": {
+        "A": "Null values are converted to empty strings",
+        "B": "The write fails with a constraint violation error",
+        "C": "Records with null emails are silently dropped",
+        "D": "The NOT NULL constraint is automatically removed"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Lake enforces NOT NULL constraints at write time. Attempting to write null values to a NOT NULL column causes the entire write operation to fail with an error. Options A, C, and D describe behaviors that don't occur.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q033",
+      "domain": "section-3-data-modeling",
+      "title": "Question 33",
+      "difficulty": "medium",
+      "question": "Which statement correctly adds this column?",
+      "choices": {
+        "A": "`ALTER TABLE customers ADD COLUMN loyalty_tier STRING AFTER customer_id`",
+        "B": "`ALTER TABLE customers ADD COLUMNS (loyalty_tier STRING AFTER customer_id)`",
+        "C": "`ALTER TABLE customers ADD COLUMN loyalty_tier STRING` (column position cannot be specified)",
+        "D": "Table must be recreated to add a column at a specific position"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Delta Lake supports column positioning with `FIRST` or `AFTER` clauses in ADD COLUMN statements. The syntax `ALTER TABLE ADD COLUMN column_name TYPE AFTER existing_column` correctly positions the new column. Option B uses incorrect syntax (COLUMNS instead of COLUMN with positioning). Option C is incorrect because position CAN be specified. Option D is unnecessary since ADD COLUMN with AFTER is supported.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q034",
+      "domain": "section-3-data-modeling",
+      "title": "Question 34",
+      "difficulty": "easy",
+      "question": "How many rows should be affected by this single address change?",
+      "choices": {
+        "A": "1 row (update the existing record)",
+        "B": "2 rows (close old record, insert new record)",
+        "C": "3 rows (update old, insert new, update audit table)",
+        "D": "Depends on the number of historical records for that customer"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "SCD Type 2 handles changes by: (1) closing the current record (setting end_date and is_current=false) and (2) inserting a new record with the new address (is_current=true). This affects exactly 2 rows. Option A describes SCD Type 1. Options C and D describe non-standard implementations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q035",
+      "domain": "section-3-data-modeling",
+      "title": "Question 35",
+      "difficulty": "hard",
+      "question": "What modification would most improve query performance?",
+      "choices": {
+        "A": "Add more partitions by also partitioning on `customer_id`",
+        "B": "Remove date partitioning and use Z-ORDER on `customer_id, product_id`",
+        "C": "Keep date partitioning and add Z-ORDER on `customer_id, product_id`",
+        "D": "Convert to Liquid Clustering on `customer_id, product_id`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Liquid Clustering on the frequently filtered columns provides automatic data organization and maintenance. Since queries rarely filter on date, date partitioning provides little benefit. Option B loses time-based data management benefits. Option C combines both but has more maintenance overhead than liquid clustering. Option A creates too many small partitions.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q036",
+      "domain": "section-3-data-modeling",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "Which Delta Lake feature and configuration supports this requirement?",
+      "choices": {
+        "A": "Enable Change Data Feed to track all changes",
+        "B": "Create a separate history table with trigger-based logging",
+        "C": "Time travel with default retention (30 days log retention)",
+        "D": "Use Delta Lake versioning with `delta.logRetentionDuration = 30 days`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Delta Lake's time travel allows querying historical versions using `VERSION AS OF` or `TIMESTAMP AS OF`. The default 30-day log retention supports this requirement. Option A tracks changes but doesn't provide point-in-time queries. Option B is unnecessary given Delta's built-in capabilities. Option D describes the feature partially but misses that it's the default behavior.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q037",
+      "domain": "section-3-data-modeling",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "What is the default behavior in Delta Lake and how can it be controlled?",
+      "choices": {
+        "A": "Delta is case-insensitive by default; both names map to the same column",
+        "B": "Delta is case-sensitive by default; they become separate columns",
+        "C": "Delta throws an error on case conflicts",
+        "D": "Delta automatically renames conflicting columns with suffixes"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "By default, Delta Lake (following Spark SQL) treats column names as case-insensitive. \"CustomerId\" and \"customerid\" refer to the same column. This behavior can be changed with `spark.sql.caseSensitive = true`. Options B, C, and D describe non-default behaviors.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q038",
+      "domain": "section-3-data-modeling",
+      "title": "Question 38",
+      "difficulty": "easy",
+      "question": "How do changes to the production table affect the cloned table?",
+      "choices": {
+        "A": "Changes automatically propagate to the clone",
+        "B": "Changes propagate until the clone is modified, then it becomes independent",
+        "C": "Only schema changes propagate; data changes don't",
+        "D": "The clone is completely independent; changes don't propagate"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Deep clone creates a completely independent copy with its own data files. After cloning, both tables evolve independently. No changes propagate between them. Option A describes linked tables, not clones. Options B and C describe behaviors that don't exist.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q039",
+      "domain": "section-3-data-modeling",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "Which SCD type best supports this requirement?",
+      "choices": {
+        "A": "SCD Type 1 with a separate audit log table",
+        "B": "SCD Type 2 with effective dates",
+        "C": "SCD Type 3 with previous value columns",
+        "D": "SCD Type 6 (hybrid) with Type 1, 2, and 3 elements"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "For corrections (not legitimate changes), SCD Type 1 updates the current value while a separate audit log table preserves the history of corrections. Type 2 is for legitimate business changes, not error corrections. Type 3 only tracks one previous value. Type 6 is complex and not specifically designed for corrections.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q040",
+      "domain": "section-4-security-governance",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "Which Unity Catalog permission model correctly implements this requirement?",
+      "choices": {
+        "A": "Grant SELECT on each table individually as they're created",
+        "B": "Create a view for each table and grant SELECT on views only",
+        "C": "Grant SELECT on the catalog to give access to all schemas and tables",
+        "D": "Grant USE SCHEMA and SELECT on SCHEMA to give access to all current and future tables"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Granting SELECT at the schema level provides access to all current and future tables in that schema. USE SCHEMA is required to access objects within the schema. Option A requires ongoing maintenance. Option C is too broad. Option B is unnecessarily complex.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q041",
+      "domain": "section-4-security-governance",
+      "title": "Question 41",
+      "difficulty": "medium",
+      "question": "Which Unity Catalog feature implements this column-level security requirement?",
+      "choices": {
+        "A": "Create separate tables for HR and managers with different columns",
+        "B": "Use dynamic views with `is_account_group_member()` to filter columns",
+        "C": "Use column masks to hide salary for non-HR users",
+        "D": "Implement application-level security in the BI tool"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Column masks in Unity Catalog apply functions to column values based on the querying user's permissions, showing the real value to authorized users and masked/null values to others. Option A creates data duplication. Option B requires view maintenance. Option D doesn't protect data at the source.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q042",
+      "domain": "section-4-security-governance",
+      "title": "Question 42",
+      "difficulty": "easy",
+      "question": "Which feature enables secure data sharing with external organizations?",
+      "choices": {
+        "A": "Create a service principal for the partner to access via API",
+        "B": "Use Delta Sharing to share data via open protocol",
+        "C": "Export data daily to a shared cloud storage location",
+        "D": "Create a Databricks workspace for the partner with access to the dataset"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta Sharing provides an open protocol for secure data sharing across organizations and platforms. Partners can use compatible clients (including Snowflake, Spark, pandas) without Databricks access. Option A requires workspace access. Option C requires file transfer management. Option D is costly and requires Databricks licenses.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q043",
+      "domain": "section-4-security-governance",
+      "title": "Question 43",
+      "difficulty": "easy",
+      "question": "Which code correctly retrieves the database password?",
+      "choices": {
+        "A": "`dbutils.secrets.get(scope=\"keyvault-scope\", key=\"db-password\")`",
+        "B": "`spark.conf.get(\"azure.keyvault.db-password\")`",
+        "C": "`dbutils.credentials.get(\"keyvault-scope\", \"db-password\")`",
+        "D": "`%keyvault get db-password`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "When Azure Key Vault is configured as a secret scope backend, secrets are accessed through `dbutils.secrets.get()` using the scope name and key name. The Key Vault integration is transparent to the code. Options B, C, and D use invalid syntax.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q044",
+      "domain": "section-4-security-governance",
+      "title": "Question 44",
+      "difficulty": "easy",
+      "question": "What permissions does the user have on that table in Workspace B?",
+      "choices": {
+        "A": "No permissions; grants are workspace-specific",
+        "B": "Same SELECT permission; Unity Catalog permissions are centralized",
+        "C": "Read-only permissions with a warning about cross-workspace access",
+        "D": "Permissions depend on workspace-level settings"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Unity Catalog provides centralized governance across all workspaces attached to the same metastore. Permissions granted on objects apply regardless of which workspace is used to access them. This is a key benefit of Unity Catalog over legacy Hive metastore.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q045",
+      "domain": "section-4-security-governance",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "Which approach correctly implements this row-level security in Unity Catalog?",
+      "choices": {
+        "A": "Add a row filter using `ROW FILTER filter_function ON (patient_id)`",
+        "B": "Create dynamic views with `WHERE doctor_id = current_user()`",
+        "C": "Use column masks to hide rows from unauthorized users",
+        "D": "Implement filtering in the application layer only"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Unity Catalog row filters apply a function that determines which rows each user can access based on their identity. The filter function can join with assignment tables to implement complex rules. Option B works but requires view maintenance. Option C is for column security, not row security. Option D doesn't protect data at the source.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q046",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 46",
+      "difficulty": "easy",
+      "question": "Which system table provides this billing information?",
+      "choices": {
+        "A": "`system.compute.clusters`",
+        "B": "`system.access.audit`",
+        "C": "`system.billing.usage`",
+        "D": "`system.workflow.jobs`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `system.billing.usage` table contains detailed DBU consumption data by workspace, cluster, and SKU. It's the primary source for cost analysis. Option A has cluster metadata. Option B has security audit logs. Option D has job definitions, not cost data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q047",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 47",
+      "difficulty": "medium",
+      "question": "What does this pattern indicate and what is the recommended solution?",
+      "choices": {
+        "A": "Insufficient executors; increase cluster size",
+        "B": "Data skew; enable AQE skew join handling or salt the skewed key",
+        "C": "Memory pressure; increase executor memory",
+        "D": "Network bottleneck; check cluster networking"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "One slow task with idle executors is the classic sign of data skew--one partition has much more data than others. AQE can automatically split skewed partitions, or you can manually salt keys. Option A wouldn't help if executors are idle. Options C and D show different symptoms.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q048",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 48",
+      "difficulty": "medium",
+      "question": "Which approach retrieves the expectation violation details?",
+      "choices": {
+        "A": "Check the cluster driver logs",
+        "B": "Review the pipeline settings in the UI",
+        "C": "Use `dbutils.pipelines.getLatestUpdate()` API",
+        "D": "Query the pipeline's event log table for expectation metrics"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Lakeflow Declarative Pipelines stores detailed metrics including expectation results in the event log. Querying the event log with filters for the update ID shows which expectations failed and the row counts. Option A has limited detail. Option C isn't a valid API. Option B shows configuration, not runtime details.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q049",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 49",
+      "difficulty": "medium",
+      "question": "Which tool reveals whether partition pruning is occurring?",
+      "choices": {
+        "A": "Run `ANALYZE TABLE` to update statistics",
+        "B": "Check the Query History for execution time breakdown",
+        "C": "Run `EXPLAIN` and check for `PartitionFilters` in the plan",
+        "D": "Review the table's `DESCRIBE DETAIL` output"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`EXPLAIN` shows the query execution plan including `PartitionFilters` (pruned partitions) and `PushedFilters` (filters pushed to scan). Empty `PartitionFilters` indicates no pruning occurred. Option A updates statistics but doesn't show the plan. Options B and D don't show execution details.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q050",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 50",
+      "difficulty": "easy",
+      "question": "Which system table contains this access information?",
+      "choices": {
+        "A": "`system.billing.usage`",
+        "B": "`system.access.audit`",
+        "C": "`system.information_schema.tables`",
+        "D": "`system.compute.clusters`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `system.access.audit` table contains audit logs of actions including table reads, with user identity and timestamp. Filter by `action_name` and `request_params` for table access events. Option A has billing data. Option C has table metadata. Option D has cluster info.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q051",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 51",
+      "difficulty": "medium",
+      "question": "Which factors should be investigated first?",
+      "choices": {
+        "A": "Data volume growth and partition sizing",
+        "B": "Cluster hardware degradation",
+        "C": "Changes to Databricks Runtime",
+        "D": "Network latency to cloud storage"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Gradual performance degradation with unchanged code typically indicates data volume growth or small file accumulation (affecting read performance). Check table sizes, file counts, and partition strategies. Option B is unlikely to be gradual. Options C and D would cause immediate changes, not gradual.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q052",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 52",
+      "difficulty": "easy",
+      "question": "Which `databricks.yml` structure correctly defines these environments?",
+      "choices": {
+        "A": "Create separate `databricks-dev.yml`, `databricks-staging.yml`, `databricks-prod.yml` files",
+        "B": "Use `environments:` section with runtime variable substitution",
+        "C": "Use `targets:` section with `dev:`, `staging:`, and `prod:` subsections",
+        "D": "Create separate bundles for each environment in different directories"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "DAB uses a `targets:` section to define environment-specific configurations. Each target can override bundle settings like workspace host, cluster configs, and variables. Option A doesn't support DAB's inheritance model. Option B uses invalid syntax. Option D duplicates code.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q053",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 53",
+      "difficulty": "medium",
+      "question": "Which testing approach is most appropriate?",
+      "choices": {
+        "A": "Deploy code to a Databricks cluster and run tests remotely",
+        "B": "Skip unit tests and rely on integration tests only",
+        "C": "Use Nutter framework with Databricks Connect",
+        "D": "Use local Spark session in pytest with mocked data"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Local Spark sessions in pytest allow fast unit tests without cluster costs or dependencies. Mock DataFrames test transformation logic efficiently. Option A is slow and costly for unit tests. Option C still requires cluster resources. Option B misses the value of unit testing.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q054",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 54",
+      "difficulty": "easy",
+      "question": "What is the recommended workflow for making changes?",
+      "choices": {
+        "A": "Create a feature branch, commit changes, and create a pull request",
+        "B": "Disable branch protection temporarily to push changes",
+        "C": "Use `%git` magic commands to force push to main",
+        "D": "Make changes in a separate notebook outside Git folders"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The standard Git workflow with branch protection: create a feature branch, make changes, push, create PR for review, then merge to main after approval. This ensures code review and testing. Options B and C bypass protections. Option D loses version control benefits.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q055",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 55",
+      "difficulty": "medium",
+      "question": "Which authentication method is recommended for GitHub Actions?",
+      "choices": {
+        "A": "Store personal access token in GitHub Secrets",
+        "B": "Configure OIDC federation between GitHub and Databricks with service principal",
+        "C": "Use username and password stored in GitHub Secrets",
+        "D": "Create a dedicated user account for GitHub Actions"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "OIDC federation with service principals is the recommended approach for CI/CD authentication. GitHub Actions can authenticate using short-lived tokens without storing long-lived credentials. Option A uses personal tokens that expire. Option C is deprecated. Option D creates management overhead.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q056",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 56",
+      "difficulty": "medium",
+      "question": "Which Nutter pattern correctly implements this test case?",
+      "choices": {
+        "A": "Create an empty table in `before_all()` and clean up in `after_all()`",
+        "B": "Use `assertion_empty_table()` with the expected result",
+        "C": "Mock the Delta table read using `unittest.mock`",
+        "D": "Use Nutter's built-in empty table generator"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Nutter's `before_all()` runs setup before tests (create empty test table), and `after_all()` runs cleanup (drop table). The actual test verifies behavior with the empty table. Option B isn't a Nutter method. Option C is complex within Nutter. Option D doesn't exist.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q057",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 57",
+      "difficulty": "medium",
+      "question": "What is the correct approach to resolve this and complete the deployment?",
+      "choices": {
+        "A": "Manually delete the resource and redeploy",
+        "B": "Update the resource name in databricks.yml to avoid conflict",
+        "C": "Run `databricks bundle destroy` then `databricks bundle deploy`",
+        "D": "Run `databricks bundle deploy --force` to overwrite"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The `--force` flag allows DAB to take ownership of and update existing resources that match the bundle definition. This handles partial deployments gracefully. Option A risks missing dependent resources. Option C destroys everything unnecessarily. Option B changes the deployment, not fixing it.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q058",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 58",
+      "difficulty": "medium",
+      "question": "What is the most likely cause?",
+      "choices": {
+        "A": "The pipeline is configured for triggered execution, not continuous",
+        "B": "Materialized views don't automatically refresh from streaming tables",
+        "C": "There's a data type mismatch between the tables",
+        "D": "The materialized view requires a manual REFRESH command"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "In triggered execution mode, materialized views only refresh when the pipeline runs. For near real-time updates, use continuous mode or schedule frequent pipeline runs. In continuous mode, materialized views refresh as streaming tables update. Options B and D are incorrect; Lakeflow Declarative Pipelines handles refreshes automatically within pipeline runs. Option C would cause errors, not stale data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q059",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 59",
+      "difficulty": "medium",
+      "question": "How does APPLY CHANGES handle out-of-order records by default?",
+      "choices": {
+        "A": "Records are processed in arrival order, ignoring timestamps",
+        "B": "Records are processed by sequence column; out-of-order records are dropped",
+        "C": "Records are processed by sequence column; out-of-order records update if sequence is higher",
+        "D": "The pipeline fails on out-of-order detection"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "APPLY CHANGES uses the SEQUENCE BY column to determine record order. If a later-arriving record has a higher sequence value than the current record, it updates the target. Records with lower sequence values than existing records are ignored (as they represent older data). This handles out-of-order arrival correctly.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q060",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 60",
+      "difficulty": "medium",
+      "question": "How can the dropped row count be retrieved?",
+      "choices": {
+        "A": "Check the `dropped_records` column in the target table",
+        "B": "Dropped rows are not tracked; add manual logging",
+        "C": "Run `DESCRIBE HISTORY` on the target table",
+        "D": "Query the pipeline event log for expectation metrics"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Lakeflow Declarative Pipelines stores detailed expectation metrics in the event log including `num_dropped_records` for each expectation. Query the event log filtering for expectation events. Option A doesn't exist. Option C shows Delta operations, not expectation details. Option B is incorrect; Lakeflow Declarative Pipelines tracks this automatically.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q061",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 61",
+      "difficulty": "medium",
+      "question": "What is the optimal compaction strategy?",
+      "choices": {
+        "A": "Run `OPTIMIZE` to compact files to the default 1GB target size",
+        "B": "Run `VACUUM` to remove small files",
+        "C": "Enable auto-compaction for future writes and run `OPTIMIZE` for existing files",
+        "D": "Repartition the table with `spark.sql.shuffle.partitions = 2000`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`OPTIMIZE` compacts existing small files into larger ones (target ~1GB). Enabling auto-compaction (`spark.databricks.delta.autoCompact.enabled`) prevents small files in future writes. Option B removes old files, not compaction. Option D affects partitions in processing, not file sizes.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q062",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 62",
+      "difficulty": "medium",
+      "question": "Which optimization would most improve this join performance?",
+      "choices": {
+        "A": "Increase `spark.sql.shuffle.partitions` to 1000",
+        "B": "Enable broadcast join by setting `spark.sql.autoBroadcastJoinThreshold = 100MB`",
+        "C": "Z-ORDER the fact table by the join key",
+        "D": "Partition both tables by the join key"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A 50MB dimension table is a good candidate for broadcast join (eliminates shuffle of the large fact table). Increasing the threshold from 10MB default to 100MB enables automatic broadcast. Option A doesn't reduce shuffle. Option C helps filters, not joins. Option D requires data redistribution.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-1-q063",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 63",
+      "difficulty": "medium",
+      "question": "Which configuration change most likely resolves this issue?",
+      "choices": {
+        "A": "Configure Lakeflow Jobs notifications (email + webhook to PagerDuty) for failures AND query `system.lakeflow.job_run_timeline` for historical failure analytics",
+        "B": "Add a Slack webhook inside the job's last task that fires on success; absence of message indicates failure",
+        "C": "Set up a SQL Alert that polls `SHOW JOBS` every 5 minutes",
+        "D": "Rely on Databricks support to surface failures automatically"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "OOM during shuffle typically means individual partitions are too large. Increasing shuffle partitions creates smaller partitions that fit in memory. Option B reduces available memory. Option C helps with small partitions, not OOM. Option D can cause off-heap OOM errors.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-engineer-professional"
+}
diff --git a/practice/data/data-engineer-professional-mock-2.json b/practice/data/data-engineer-professional-mock-2.json
new file mode 100644
index 0000000..dbb174a
--- /dev/null
+++ b/practice/data/data-engineer-professional-mock-2.json
@@ -0,0 +1,1014 @@
+{
+  "cert": "data-engineer-professional-mock-2",
+  "certTitle": "Data Engineer Professional — Mock Exam 2",
+  "blueprintVersion": "Nov 30, 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "section-1-data-processing",
+      "name": "Section 1: Data Processing",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 18
+    },
+    {
+      "id": "section-2-databricks-tooling",
+      "name": "Section 2: Databricks Tooling",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 12
+    },
+    {
+      "id": "section-3-data-modeling",
+      "name": "Section 3: Data Modeling",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "section-4-security-governance",
+      "name": "Section 4: Security & Governance",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-5-monitoring-logging",
+      "name": "Section 5: Monitoring & Logging",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-6-testing-deployment",
+      "name": "Section 6: Testing & Deployment",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 6
+    },
+    {
+      "id": "section-7-lakeflow-pipelines-performance",
+      "name": "Section 7: Lakeflow Pipelines & Performance",
+      "sourceFile": "certifications/data-engineer-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 3
+    }
+  ],
+  "questions": [
+    {
+      "id": "data-engineer-professional-mock-2-q001",
+      "domain": "section-1-data-processing",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "Which Auto Loader configuration change will most effectively reduce the file discovery time for this pipeline?",
+      "choices": {
+        "A": "Set `cloudFiles.maxFilesPerTrigger` to a higher value to process more files per batch",
+        "B": "Switch to `cloudFiles.useIncrementalListing = true` to use sorted directory listing",
+        "C": "Switch to `cloudFiles.useNotifications = true` to use file notification mode",
+        "D": "Set `cloudFiles.schemaLocation` to a faster storage tier for schema caching"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "File notification mode uses cloud-native event notifications (e.g., AWS SNS/SQS, Azure Event Grid) to detect new files, eliminating the need to list the entire directory. This is dramatically faster than directory listing mode when dealing with millions of files. Option A increases batch size but does not speed up file discovery. Option B improves directory listing but still requires listing operations that are slow at scale.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q002",
+      "domain": "section-1-data-processing",
+      "title": "Question 2",
+      "difficulty": "hard",
+      "question": "What happens when Auto Loader encounters schema changes after recovering from a checkpoint?",
+      "choices": {
+        "A": "Auto Loader uses the previously inferred schema from the schema location and rejects files that do not match, causing a `UnknownFieldException` that stops the stream unless schema evolution is configured",
+        "B": "Auto Loader automatically adds the new columns and backfills existing data with null values",
+        "C": "Auto Loader ignores the new columns and continues processing with the original schema only",
+        "D": "Auto Loader restarts from the beginning of the source directory, re-reading all files with the new schema"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Auto Loader persists the inferred schema to the schema location and reuses it across restarts. When new columns appear, the behavior depends on `cloudFiles.schemaEvolutionMode`. Without explicit configuration, unexpected schema changes cause the stream to fail. Options B and C describe behaviors that only occur with specific `schemaEvolutionMode` settings (`addNewColumns` or `none` respectively).",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q003",
+      "domain": "section-1-data-processing",
+      "title": "Question 3",
+      "difficulty": "hard",
+      "question": "Which MERGE implementation correctly handles SCD Type 2 for this use case?",
+      "choices": {
+        "A": "A single MERGE with `WHEN MATCHED THEN UPDATE SET end_date = current_date(), is_current = false` and `WHEN NOT MATCHED THEN INSERT` -- this handles both closing old records and inserting new ones",
+        "B": "Two separate SQL statements: first an UPDATE to close changed records, then an INSERT for the new versions, wrapped in a transaction",
+        "C": "A single MERGE with `WHEN MATCHED AND target.is_current = true AND target.address <> source.address THEN UPDATE SET *` and `WHEN NOT MATCHED THEN INSERT *`",
+        "D": "A single MERGE with `WHEN MATCHED AND target.is_current = true AND target.address <> source.address THEN UPDATE SET end_date = current_date(), is_current = false` combined with a separate INSERT statement for new active records using a UNION of the matched changes"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "SCD Type 2 requires two operations for changed records: closing the existing record and inserting a new active version. A single MERGE cannot both update and insert for the same matched key, so the correct pattern uses MERGE to close the old record and a separate INSERT for the new version. Option A only closes old records but never inserts the new active version. Option C overwrites the record entirely (SCD Type 1 behavior).",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q004",
+      "domain": "section-1-data-processing",
+      "title": "Question 4",
+      "difficulty": "hard",
+      "question": "Which join condition correctly implements this time-bounded stream-stream join?",
+      "choices": {
+        "A": "`orders.order_id == shipments.order_id` with a post-join filter `shipments.ship_time - orders.order_time <= interval 7 days`",
+        "B": "`orders.order_id == shipments.order_id AND shipments.ship_time BETWEEN orders.order_time AND orders.order_time + interval 7 days`",
+        "C": "`orders.order_id == shipments.order_id` with watermarks set to 7 days on both streams",
+        "D": "`orders.order_id == shipments.order_id AND shipments.ship_time - orders.order_time <= 7` with implicit day conversion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The time-range condition must be part of the join condition (not a post-join filter) so that Spark can use it along with watermarks to determine when old state can be discarded. The `BETWEEN` clause clearly expresses the valid time window. Option A applies the filter after the join, which prevents Spark from optimizing state cleanup. Option C defines watermarks but lacks the required time-range join condition. Option D uses an integer comparison rather than an interval expression.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q005",
+      "domain": "section-1-data-processing",
+      "title": "Question 5",
+      "difficulty": "hard",
+      "question": "Which pattern ensures exactly-once semantics for the PostgreSQL writes within `foreachBatch()`?",
+      "choices": {
+        "A": "Use the `batchId` parameter to track which batches have been committed in a metadata table in PostgreSQL, and skip re-processing of already-committed batch IDs",
+        "B": "Use `outputMode(\"append\")` with checkpointing, which guarantees exactly-once writes to all sinks automatically",
+        "C": "Deduplicate the PostgreSQL table after each batch using a `DELETE` of duplicate rows based on primary key",
+        "D": "Write to PostgreSQL first and Delta second so that the checkpoint only advances after both succeed"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The `batchId` provided to the `foreachBatch` function is guaranteed to be the same for a replayed batch after failure recovery. By recording the committed `batchId` in PostgreSQL and checking it before writing, the pipeline achieves idempotent writes and exactly-once semantics. Option B only guarantees exactly-once for Delta sinks, not external databases. Option C creates a window of inconsistency and is not truly idempotent.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q006",
+      "domain": "section-1-data-processing",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "Which set of values does the `_change_type` column contain in a Change Data Feed?",
+      "choices": {
+        "A": "`insert`, `update`, `delete`",
+        "B": "`added`, `modified`, `removed`",
+        "C": "`insert`, `update_preimage`, `update_postimage`, `delete`",
+        "D": "`create`, `update_before`, `update_after`, `drop`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `_change_type` column in CDF contains four possible values: `insert` for new rows, `update_preimage` for the row state before an update, `update_postimage` for the row state after an update, and `delete` for removed rows. The pre/post image distinction for updates is critical for CDC pipelines that need to detect exactly which columns changed.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q007",
+      "domain": "section-1-data-processing",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "What does Databricks predictive optimization automate when enabled on a Unity Catalog metastore?",
+      "choices": {
+        "A": "It automates only `VACUUM` operations based on storage usage thresholds",
+        "B": "It automates only `OPTIMIZE` operations by monitoring query patterns",
+        "C": "It automates `OPTIMIZE` and `VACUUM` but requires manual Z-ORDER column specification",
+        "D": "It automates `OPTIMIZE`, `VACUUM`, and `ZORDERING` by analyzing query patterns and table statistics to determine when and how to run maintenance"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Predictive optimization is a Unity Catalog feature that automatically runs `OPTIMIZE` (including file compaction), `VACUUM` (file cleanup), and `ZORDERING` (based on observed query predicates) without manual intervention. It uses table access patterns and statistics to determine the optimal schedule and configuration. Options A through C each describe only a subset of what predictive optimization handles.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q008",
+      "domain": "section-1-data-processing",
+      "title": "Question 8",
+      "difficulty": "hard",
+      "question": "Which approach resolves the unbounded state growth while still deduplicating records?",
+      "choices": {
+        "A": "Reduce the watermark to 30 minutes so state expires faster",
+        "B": "Replace `dropDuplicates()` with `dropDuplicatesWithinWatermark(\"sensor_id\", \"reading_id\")` which uses the existing watermark to bound deduplication state",
+        "C": "Add a `DISTINCT` clause in a downstream SQL query instead of deduplicating in the stream",
+        "D": "Increase executor memory to accommodate the growing state"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`dropDuplicatesWithinWatermark()` leverages the existing watermark to automatically expire deduplication state for events older than the watermark threshold. In contrast, `dropDuplicates()` retains all seen keys in state indefinitely because it has no time bound. Option A changes the late-data tolerance and does not fix the root cause since `dropDuplicates` ignores the watermark entirely.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q009",
+      "domain": "section-1-data-processing",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "What does the `_rescued_data` column contain?",
+      "choices": {
+        "A": "A JSON string containing column values that did not conform to the expected schema, including columns with unexpected names or data that failed type casting",
+        "B": "The complete original raw record as a single string for any row that had at least one parsing warning",
+        "C": "Only the column names that were added since the schema was first inferred",
+        "D": "A binary-encoded copy of the entire source file that contained the mismatched record"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The `_rescued_data` column captures a JSON map of any data that could not be parsed into the expected schema. This includes columns with unexpected names not in the schema and values that failed type casting (e.g., a string in an integer column). It does not store the entire raw record or file, only the specific fields that did not fit the defined schema.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q010",
+      "domain": "section-1-data-processing",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "When is it more appropriate to use `TIMESTAMP AS OF` versus `VERSION AS OF` for Delta time travel?",
+      "choices": {
+        "A": "`TIMESTAMP AS OF` is for streaming queries; `VERSION AS OF` is for batch queries",
+        "B": "`VERSION AS OF` should always be preferred because timestamps can be ambiguous across time zones",
+        "C": "`TIMESTAMP AS OF` works only with dates, not datetime values; `VERSION AS OF` supports both",
+        "D": "`TIMESTAMP AS OF` is ideal when querying by a business point-in-time (e.g., end-of-day), while `VERSION AS OF` is ideal for reproducibility when the exact commit version is known"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`TIMESTAMP AS OF` maps a datetime to the latest Delta version committed at or before that timestamp, making it natural for business-time queries like audits. `VERSION AS OF` uses the exact commit version number, ensuring deterministic reproducibility when the specific version is tracked (e.g., in a report metadata table). Both work in batch and streaming contexts, and timestamps support full datetime precision.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q011",
+      "domain": "section-1-data-processing",
+      "title": "Question 11",
+      "difficulty": "hard",
+      "question": "What is the key difference between `ProcessingTimeTimeout` and `EventTimeTimeout` in stateful streaming?",
+      "choices": {
+        "A": "`ProcessingTimeTimeout` triggers based on the event timestamp column, while `EventTimeTimeout` triggers based on wall-clock time",
+        "B": "`ProcessingTimeTimeout` is more accurate for out-of-order data because it accounts for late-arriving events",
+        "C": "`EventTimeTimeout` triggers when the watermark advances past the timeout timestamp, providing deterministic timeout behavior based on data timestamps rather than wall-clock time",
+        "D": "There is no functional difference; they are aliases for the same timeout mechanism"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`EventTimeTimeout` is driven by the watermark, so the timeout fires when the watermark (derived from event timestamps across all partitions) advances past the configured timeout timestamp. This makes it deterministic and reproducible during reprocessing. `ProcessingTimeTimeout` uses the system clock, so timeouts depend on when micro-batches execute, which is non-deterministic and not reproducible.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q012",
+      "domain": "section-1-data-processing",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "Why is running `VACUUM` with a retention period less than 7 days considered dangerous?",
+      "choices": {
+        "A": "It will permanently delete the Delta transaction log, making the table unreadable",
+        "B": "It may remove files that are still needed by concurrent readers or writers that started before the VACUUM, leading to query failures with `FileNotFoundException`",
+        "C": "It converts the Delta table to a plain Parquet table by removing all metadata files",
+        "D": "It triggers a full table rewrite that doubles the storage usage temporarily"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "VACUUM with a short retention period can delete data files that are still referenced by long-running queries or streaming jobs that hold an older table snapshot. These queries will fail with `FileNotFoundException` when they attempt to read the removed files. The 7-day default retention provides a safety buffer for concurrent operations. The transaction log (`_delta_log`) is not affected by VACUUM.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q013",
+      "domain": "section-1-data-processing",
+      "title": "Question 13",
+      "difficulty": "medium",
+      "question": "Which output mode correctly supports streaming aggregations with `groupBy`?",
+      "choices": {
+        "A": "`outputMode(\"complete\")` outputs the entire aggregation result table after each micro-batch, replacing all previous output",
+        "B": "`outputMode(\"append\")` writes only new rows and is the only mode that supports aggregations",
+        "C": "`outputMode(\"update\")` is required because it is the only mode that works with stateful operations",
+        "D": "Both `outputMode(\"append\")` and `outputMode(\"update\")` work equally well for aggregations without watermarks"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "For streaming aggregations without a watermark, `complete` mode is required because the aggregation results change with every micro-batch and must be fully rewritten. `append` mode fails because Spark cannot determine when an aggregation result is finalized without a watermark. With a watermark defined, `append` and `update` modes also become available, but without one, only `complete` works.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q014",
+      "domain": "section-1-data-processing",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "How does the configuration hierarchy work for Auto Loader's file format setting?",
+      "choices": {
+        "A": "The top-level `.format(\"json\")` call on the DataStreamReader overrides `cloudFiles.format`",
+        "B": "The two settings are independent: `.format()` sets the stream source type and `cloudFiles.format` sets the file parsing format",
+        "C": "Setting both causes an `IllegalArgumentException` at runtime because they conflict",
+        "D": "`.format(\"cloudFiles\")` is required to activate Auto Loader as the stream source, and `cloudFiles.format` separately specifies the data file format (e.g., JSON, CSV, Parquet) to parse within Auto Loader"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Auto Loader requires `.format(\"cloudFiles\")` on the DataStreamReader to identify the source as Auto Loader. The `cloudFiles.format` option then tells Auto Loader which file format parser to use for the actual data files. These are not competing settings but operate at different levels: one selects the streaming source, the other configures it. Using `.format(\"json\")` directly would bypass Auto Loader entirely and use the standard file stream source.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q015",
+      "domain": "section-1-data-processing",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "Where in the multi-hop architecture should malformed data be handled to balance data quality and completeness?",
+      "choices": {
+        "A": "At the Gold layer, since business logic determines what is valid",
+        "B": "At the Bronze-to-Silver transition, where data quality rules quarantine bad records to a separate \"quarantine\" table while valid records proceed to Silver",
+        "C": "At ingestion into Bronze, rejecting any records that do not pass schema validation",
+        "D": "Malformed data should be silently dropped at every layer to maintain clean tables"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Bronze-to-Silver transition is the standard point for data quality enforcement in a multi-hop architecture. Bronze stores raw data as-is for auditability and replay. At the Silver layer, quality rules validate, clean, and route malformed records to a quarantine table for investigation. Option C risks data loss at ingestion, and Option D provides no visibility into data quality issues.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q016",
+      "domain": "section-1-data-processing",
+      "title": "Question 16",
+      "difficulty": "hard",
+      "question": "What happens when this `ALTER TABLE ADD CONSTRAINT` statement is executed?",
+      "choices": {
+        "A": "The constraint is added and the 200 violating rows are automatically deleted",
+        "B": "The constraint is added successfully but only enforced on future writes; existing rows are not validated",
+        "C": "The statement fails because existing rows violate the constraint, and the constraint is not added until all violating data is removed or corrected",
+        "D": "The constraint is added and the 200 violating rows are quarantined to a separate error table"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Delta Lake validates all existing data against the CHECK constraint before adding it. If any rows violate the constraint, the `ALTER TABLE` statement fails and the constraint is not created. The engineer must first clean or remove the violating rows before the constraint can be added. This prevents the table from entering an inconsistent state with a constraint that existing data already violates.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q017",
+      "domain": "section-1-data-processing",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "What level of delivery guarantee does Structured Streaming provide with checkpointing and a Delta Lake sink?",
+      "choices": {
+        "A": "Exactly-once end-to-end: Structured Streaming's checkpointing tracks offsets, and Delta Lake's transaction log ensures each micro-batch is committed atomically and idempotently, so replayed batches produce no duplicates",
+        "B": "At-least-once: checkpointing tracks offsets but Delta Lake may write duplicate rows if a batch is replayed after a partial commit",
+        "C": "At-most-once: if a failure occurs, the uncommitted batch is lost and processing resumes from the next offset",
+        "D": "Exactly-once only if `foreachBatch()` is used with manual deduplication logic"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Structured Streaming with checkpointing and a Delta Lake sink provides exactly-once end-to-end guarantees. The checkpoint records which offsets have been processed, and Delta Lake's transaction log ensures that write operations are atomic and idempotent. If a micro-batch is replayed after failure, Delta detects the duplicate commit and does not write the data again.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q018",
+      "domain": "section-1-data-processing",
+      "title": "Question 18",
+      "difficulty": "hard",
+      "question": "What is the recommended pattern for handling late-arriving dimension data in an incremental batch pipeline?",
+      "choices": {
+        "A": "Delay the fact table MERGE until all dimension tables are fully loaded, using a job dependency that blocks the fact pipeline",
+        "B": "Reject fact records with unknown dimension keys by filtering them out before the MERGE, accepting the data loss",
+        "C": "Use a surrogate key of -1 for unknown dimensions and update the fact records later when the dimension arrives, but this requires a second pass over the data",
+        "D": "Insert fact records with the unknown dimension key, place those records into an \"early-arriving facts\" holding table, and reprocess them in the next pipeline run after the dimension has been loaded"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The early-arriving facts pattern captures fact records whose dimension keys are not yet available in a holding (or error) table, then reprocesses them in subsequent runs once the dimension data has arrived. This avoids data loss (Option B), avoids tight pipeline coupling and delays (Option A), and avoids the complexity of placeholder surrogate keys that must be corrected later (Option C).",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q019",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "When the scheduled job needs to generate the report for the \"operations\" business unit, how should the job task be configured to override the widget default?",
+      "choices": {
+        "A": "Set a cluster environment variable `BUSINESS_UNIT=operations` and modify the notebook to read from `os.environ`",
+        "B": "In the notebook task configuration, set `base_parameters: {\"business_unit\": \"operations\"}` to override the widget default",
+        "C": "Create a separate copy of the notebook with the dropdown default changed to \"operations\"",
+        "D": "Use `spark.conf.set(\"business_unit\", \"operations\")` in an init script attached to the job cluster"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `base_parameters` field in a notebook task directly maps to widget names and overrides their default values at runtime. This is the intended mechanism for parameterizing notebooks across interactive and job contexts. Options A and D bypass the widget system entirely, and Option C creates maintenance overhead with duplicated notebooks.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q020",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "Which statement correctly describes a key difference between Databricks Asset Bundles and the legacy CLI approach?",
+      "choices": {
+        "A": "Asset Bundles require all resources to be defined in Python rather than YAML or JSON",
+        "B": "Asset Bundles only support job deployments and cannot manage clusters or permissions",
+        "C": "Asset Bundles use declarative YAML configuration files (`databricks.yml`) that define resources, environments, and deployment targets in a single project structure",
+        "D": "Asset Bundles replace the REST API entirely and cannot be used alongside direct API calls"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Asset Bundles introduce a declarative, project-based approach using `databricks.yml` files where resources (jobs, pipelines, etc.), environment-specific overrides, and deployment targets are defined together. This replaces the imperative scripting approach of the legacy CLI. Option A is wrong because DABs use YAML, Option B understates their capabilities, and Option D is incorrect since the API and bundles can coexist.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q021",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "Which JSON structure correctly defines the task dependency graph for this job?",
+      "choices": {
+        "A": "Define each task with a `depends_on` array referencing parent task keys, such as Task B having `\"depends_on\": [{\"task_key\": \"task_a\"}]` and Task D having `\"depends_on\": [{\"task_key\": \"task_b\"}, {\"task_key\": \"task_c\"}]`",
+        "B": "Set a single `execution_order` array at the job level listing tasks in sequential order: `[\"task_a\", \"task_b\", \"task_c\", \"task_d\"]`",
+        "C": "Use `run_after` fields on each task with a single string value referencing one parent, requiring a separate mechanism for multi-parent dependencies",
+        "D": "Define a `dag` object at the job level with an adjacency list of task edges separate from the task definitions"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The Jobs API 2.1 uses a `depends_on` array within each task definition to specify upstream dependencies by `task_key`. This allows expressing complex DAGs including fan-out and fan-in patterns directly within the task list. Option B would enforce purely sequential execution, Option C incorrectly limits dependencies to a single parent, and Option D describes a structure not used by the Jobs API.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q022",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 22",
+      "difficulty": "hard",
+      "question": "Which compute configuration best balances cost and responsiveness for these two workload types?",
+      "choices": {
+        "A": "Use a single large all-purpose cluster for both workloads with auto-scaling enabled",
+        "B": "Use job clusters for interactive exploration and serverless compute for nightly ETL",
+        "C": "Use all-purpose clusters with auto-termination for both workloads to ensure resources are freed",
+        "D": "Use serverless compute for ad hoc exploration notebooks and job clusters for the nightly ETL pipelines"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Serverless compute eliminates startup latency and charges only for active usage, making it ideal for unpredictable, bursty interactive workloads. Job clusters are cost-optimized for scheduled batch work since they offer lower DBU rates and auto-terminate after each run. Option A wastes resources during idle periods, Option B reverses the optimal assignment, and Option C still incurs higher DBU rates for production workloads.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q023",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "Which approach most effectively reduces cluster startup time for these jobs?",
+      "choices": {
+        "A": "Switch all jobs to use a single shared all-purpose cluster with auto-scaling to avoid repeated cluster creation",
+        "B": "Create an instance pool with `i3.xlarge` instances and configure each job cluster to use the pool, keeping warm instances available for immediate allocation",
+        "C": "Increase the cluster size for each job so that Spark initialization is parallelized across more nodes",
+        "D": "Attach init scripts to pre-install all libraries at the cluster level so startup only involves launching the runtime"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Instance pools maintain a set of warm (pre-provisioned) cloud instances that can be allocated to clusters instantly, reducing startup time from minutes to seconds. Since all jobs use the same instance type, a shared pool maximizes reuse. Option A sacrifices job isolation and cost optimization, Option C does not reduce provisioning time, and Option D addresses library install time but not the dominant cost of instance provisioning.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q024",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "Which Databricks feature allows the governance team to enforce these constraints?",
+      "choices": {
+        "A": "Cluster policies that define allowed attribute values, maximum limits, and required tags, then assign the policy to data engineering groups",
+        "B": "Workspace-level admin settings that globally restrict all cluster configurations to the approved runtime versions",
+        "C": "Unity Catalog metastore-level compute restrictions that govern runtime versions and node counts",
+        "D": "Custom init scripts that validate cluster configuration at startup and terminate non-compliant clusters"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Cluster policies provide fine-grained, declarative constraints on cluster attributes including runtime versions (allowlist), maximum nodes (range), required tags (fixed values), and disabled features. Policies are assigned to groups so engineers can only create compliant clusters. Option B lacks the granularity needed, Option C does not manage compute configurations, and Option D is reactive rather than preventive.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q025",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 25",
+      "difficulty": "medium",
+      "question": "Which statement correctly explains the permission behavior in this scenario?",
+      "choices": {
+        "A": "The analyst cannot view the notebook because notebook-level permissions always override folder-level permissions",
+        "B": "The analyst should be able to view the notebook because all authenticated users have implicit read access to all workspace objects",
+        "C": "The analyst cannot view the notebook because Databricks workspace permissions are additive and do not grant implicit access",
+        "D": "The analyst cannot view the notebook because folder-level ACLs are inherited by child objects, and without explicit permissions on the folder or notebook, the analyst has no access"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Workspace folder permissions use inheritance: child objects (notebooks, sub-folders) inherit the ACLs of their parent folder. Since the `data_analysts` group was not granted any permission on the `TeamAlpha` folder, they inherit no access to objects within it. Option A incorrectly states that notebook permissions override folder permissions (they supplement them), Option B is false, and Option C is partially correct but misses the inheritance mechanism.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q026",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "Which statement correctly describes a key behavioral difference between `%run` and `dbutils.notebook.run()`?",
+      "choices": {
+        "A": "`%run` executes the child notebook in a separate process while `dbutils.notebook.run()` executes in the same process",
+        "B": "`dbutils.notebook.run()` executes the child notebook in an isolated context and returns only a string result, whereas `%run` merges the child's execution context (variables, functions, imports) into the calling notebook",
+        "C": "`dbutils.notebook.run()` supports passing DataFrames as parameters while `%run` only supports string parameters",
+        "D": "`%run` is asynchronous and returns immediately while `dbutils.notebook.run()` blocks until completion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`%run` is a compile-time inclusion that merges the child notebook's entire execution context (all variables, functions, and imports) into the parent, as if the code were pasted inline. `dbutils.notebook.run()` launches the child in an isolated context and can only return a single string via `dbutils.notebook.exit()`. Option A reverses the isolation model, Option C is incorrect since neither method passes DataFrames directly, and Option D is incorrect since `%run` also blocks.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q027",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 27",
+      "difficulty": "medium",
+      "question": "Which Databricks SQL warehouse type meets all of these requirements?",
+      "choices": {
+        "A": "Serverless SQL warehouse, which provides instant scaling, high concurrency, built-in query federation, and eliminates infrastructure management overhead",
+        "B": "Pro SQL warehouse, which supports query federation and high concurrency but requires manual cluster management",
+        "C": "Classic SQL warehouse, which provides the lowest cost and supports all the required features including query federation",
+        "D": "Any warehouse type works since query federation, concurrency, and dashboards are available on all tiers"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Serverless SQL warehouses provide instant elastic scaling for high concurrency, built-in support for query federation (including external databases like PostgreSQL), and require no infrastructure management. Pro warehouses support federation but lack serverless scaling benefits. Classic warehouses do not support query federation, making Option C incorrect. Option D is wrong because feature availability varies across tiers.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q028",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "Which Unity Catalog feature is most appropriate for this requirement?",
+      "choices": {
+        "A": "Create an external table with `STORED AS CSV` format to register the files in Unity Catalog",
+        "B": "Create an external location pointing to the cloud storage path where partner files are uploaded",
+        "C": "Create a managed volume within a Unity Catalog schema so that files are stored under Unity Catalog's managed storage with full lifecycle governance",
+        "D": "Create a Delta table and use `COPY INTO` to ingest the CSV/JSON files, then export them back to the original format when needed"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Managed volumes in Unity Catalog store files in the catalog's managed storage location, providing full lifecycle management (files are deleted when the volume is dropped) and governed access through Unity Catalog permissions. Files retain their original format and are accessible via `/Volumes/` paths. Option A does not apply since the requirement is for file storage, not tabular data. Option B provides governance over a location but not lifecycle management. Option D adds unnecessary conversion steps.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q029",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 29",
+      "difficulty": "hard",
+      "question": "Which configuration correctly implements both the schedule and retry policy?",
+      "choices": {
+        "A": "Use three separate jobs each with a simple daily cron schedule (`0 6 * * 1-5`, `0 12 * * 1-5`, `0 18 * * 1-5`) and configure retries at the job level with `max_retries: 3`",
+        "B": "Use a single cron expression `0 6,12,18 * * MON-FRI` with a task-level `retry_policy` of `max_retries: 3, min_retry_interval_millis: 300000`",
+        "C": "Use a continuous trigger with a conditional check on the current hour and day, and implement retry logic within the notebook code using try/except blocks",
+        "D": "Use a single cron expression `0 6,12,18 * * 1-5` with a task-level `retry_policy` specifying `max_retries: 3` and `min_retry_interval_millis: 300000`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The cron expression `0 6,12,18 * * 1-5` correctly triggers at 6:00, 12:00, and 18:00 on weekdays (1-5 represents Monday-Friday in the Databricks/Quartz cron format). The task-level `retry_policy` with `max_retries` and `min_retry_interval_millis` (300000ms = 5 minutes) configures automatic retries. Option A unnecessarily creates three separate jobs. Option B uses `MON-FRI` which is not valid in the Quartz cron format used by Databricks. Option C is overly complex and loses built-in retry tracking.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q030",
+      "domain": "section-2-databricks-tooling",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "Which statement correctly describes the behavior of global and cluster-scoped init scripts in Databricks?",
+      "choices": {
+        "A": "Global init scripts and cluster-scoped init scripts run in parallel during cluster startup, with no guaranteed ordering between them",
+        "B": "Global init scripts run first on every cluster in the workspace, followed by cluster-scoped init scripts, allowing the monitoring agent to be installed globally while team-specific libraries are added via cluster-scoped scripts",
+        "C": "Cluster-scoped init scripts run before global init scripts, so team-specific configurations take precedence over workspace-wide settings",
+        "D": "Global init scripts can only be configured by metastore admins through Unity Catalog, not through workspace admin settings"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks executes global init scripts first (in the order specified by the admin), followed by cluster-scoped init scripts. This means the monitoring agent can be deployed as a global init script that runs on every cluster, while the team-specific Python library is added as a cluster-scoped init script on data science clusters only. Option A incorrectly states they run in parallel, Option C reverses the execution order, and Option D is wrong since global init scripts are managed through workspace admin settings.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q031",
+      "domain": "section-3-data-modeling",
+      "title": "Question 31",
+      "difficulty": "hard",
+      "question": "What is the most appropriate approach for building this pipeline in the medallion architecture?",
+      "choices": {
+        "A": "Write directly from Bronze to Gold, skipping Silver, since the intermediate transformations add no meaningful value",
+        "B": "Always create a Silver layer to maintain architectural consistency, even if transformations are trivial",
+        "C": "Write the raw data directly to Gold and skip both Bronze and Silver",
+        "D": "Create a Silver table but only materialize it as a view to reduce storage costs"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "When the Silver layer would only perform trivial transformations that add no real cleansing or conforming value, it is acceptable to bypass it and write directly from Bronze to Gold. The medallion architecture is a guideline, not a rigid rule, and unnecessary layers add latency and storage overhead without benefit. Option B wastes resources on an empty pass-through, and option C loses the raw data auditability that Bronze provides.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q032",
+      "domain": "section-3-data-modeling",
+      "title": "Question 32",
+      "difficulty": "hard",
+      "question": "Which MERGE approach correctly implements SCD Type 2 with proper current/expired flag management?",
+      "choices": {
+        "A": "Use MERGE with `WHEN MATCHED THEN UPDATE SET *` to overwrite the existing row with the new values",
+        "B": "Use MERGE with `WHEN MATCHED THEN DELETE` followed by a separate INSERT of both the expired and new rows",
+        "C": "Use MERGE with `WHEN MATCHED AND source.hash <> target.hash THEN UPDATE SET is_current = false, effective_end_date = current_date()` combined with a `WHEN NOT MATCHED THEN INSERT` clause, then run a second INSERT for the new current rows",
+        "D": "Use MERGE with `WHEN MATCHED THEN UPDATE SET is_current = false` and include the new row in the WHEN NOT MATCHED clause, which automatically handles both operations in a single pass"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "SCD Type 2 requires two operations for changed records: expiring the old row (updating `is_current` to false and setting `effective_end_date`) and inserting the new current row. The correct approach uses a MERGE to expire matched rows with changed attributes, then a separate INSERT statement to add the new current versions. Option D is incorrect because the `WHEN NOT MATCHED` clause only fires for source rows with no match in the target, not for rows that were just updated.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q033",
+      "domain": "section-3-data-modeling",
+      "title": "Question 33",
+      "difficulty": "hard",
+      "question": "Which approach allows the team to rename and drop columns on the Delta table without rewriting data files?",
+      "choices": {
+        "A": "Use `ALTER TABLE RENAME COLUMN txn_amt TO transaction_amount` and `ALTER TABLE DROP COLUMN legacy_flag` directly, as Delta Lake supports this by default",
+        "B": "Create a new table with the desired schema and use `INSERT INTO ... SELECT` to copy the data",
+        "C": "Create a view on top of the existing table with column aliases to simulate the rename",
+        "D": "Enable Delta column mapping by setting `delta.columnMapping.mode = 'name'` and then use `ALTER TABLE RENAME COLUMN` and `ALTER TABLE DROP COLUMN`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Delta column mapping (`delta.columnMapping.mode = 'name'`) decouples logical column names from physical column names in Parquet files, enabling column rename and drop operations without rewriting data files. Without column mapping enabled, Delta Lake does not support column rename or drop operations. Option A would fail because the default column mapping mode (`none`) does not permit these operations. Option B requires a full data rewrite, which violates the constraint.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q034",
+      "domain": "section-3-data-modeling",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "Which data modeling approach is most appropriate for the Gold layer of this lakehouse?",
+      "choices": {
+        "A": "A fully denormalized single wide table containing all customer, account, transaction, and product attributes",
+        "B": "A star schema with a central fact table for transactions and dimension tables for customer, account, and product",
+        "C": "A normalized third normal form (3NF) model to minimize data redundancy",
+        "D": "A Data Vault 2.0 model with hubs, links, and satellites for maximum flexibility"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A star schema is ideal for the Gold layer when queries involve multiple filter dimensions and the team includes SQL analysts familiar with relational patterns. It provides a balance of query performance (through reduced joins compared to 3NF) and manageability (compared to a single denormalized table that would be unwieldy with this many entities). Option A would create an extremely wide table with massive redundancy, while option C optimizes for storage at the cost of query performance due to excessive joins.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q035",
+      "domain": "section-3-data-modeling",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "Which cloning strategy best meets these requirements?",
+      "choices": {
+        "A": "Use SHALLOW CLONE, which copies only the metadata and transaction log while referencing the original data files, providing a fast and storage-efficient copy",
+        "B": "Use DEEP CLONE, which copies all data files and metadata to create a fully independent copy",
+        "C": "Use CTAS (`CREATE TABLE AS SELECT`) to create a complete physical copy of the data",
+        "D": "Use SHALLOW CLONE and then immediately run OPTIMIZE on the clone to consolidate files"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "SHALLOW CLONE creates a copy by referencing the source table's data files without physically duplicating them, making it both fast and storage-efficient. This is ideal for development and testing environments where cost and speed matter. Option B (DEEP CLONE) would require copying all 2 TB of data, which is slow and expensive. Note that if the dev team writes to a shallow clone, only the modified files are stored separately while unchanged data still references the source.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q036",
+      "domain": "section-3-data-modeling",
+      "title": "Question 36",
+      "difficulty": "hard",
+      "question": "Which partitioning strategy is most appropriate for this table?",
+      "choices": {
+        "A": "Partition by `sensor_id` to ensure queries filtering on individual sensors are fast",
+        "B": "Partition by both `device_region` and `reading_date` to align with the two most common filter columns",
+        "C": "Partition by `device_region` only, and use Z-ORDER BY on `reading_date, sensor_id` for additional data skipping",
+        "D": "Partition by `reading_date` only, since it is the most granular time-based column"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "With Hive-style partitioning, partition columns should have low cardinality to avoid creating too many small files. `device_region` with 5 distinct values is an excellent partition column. Adding `reading_date` as a partition would create thousands of sub-partitions (5 regions x 365+ days), leading to a small-files problem. Z-ORDER on `reading_date` and `sensor_id` provides efficient data skipping within each partition. Option A is wrong because 500,000 partitions would cause severe performance degradation.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q037",
+      "domain": "section-3-data-modeling",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "What is the primary advantage of converting this table to use Liquid Clustering?",
+      "choices": {
+        "A": "Liquid Clustering compresses data files more efficiently than Hive-style partitioning, reducing storage costs",
+        "B": "Liquid Clustering incrementally reorganizes data without requiring full table rewrites and supports flexible, multi-column clustering that adapts to evolving query patterns",
+        "C": "Liquid Clustering eliminates the need for the OPTIMIZE command entirely since data is always optimally organized at write time",
+        "D": "Liquid Clustering automatically creates materialized views for the most frequently queried column combinations"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Liquid Clustering's key advantages over Hive-style partitioning are incremental data reorganization (no full rewrites needed), support for multiple clustering columns without the small-files problem of multi-column partitioning, and the ability to change clustering keys without rewriting all data. Option C is incorrect because OPTIMIZE is still used to trigger clustering; it just works incrementally. Option A is misleading because compression is not the primary differentiator.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q038",
+      "domain": "section-3-data-modeling",
+      "title": "Question 38",
+      "difficulty": "medium",
+      "question": "Which description correctly characterizes the transformations applied at each layer of the medallion architecture?",
+      "choices": {
+        "A": "Bronze applies schema enforcement and deduplication; Silver adds business aggregations; Gold provides filtered views for consumers",
+        "B": "Bronze performs data type casting and validation; Silver joins reference data; Gold stores raw backup copies",
+        "C": "Bronze ingests raw data with minimal transformation (e.g., adding metadata columns and enforcing schema-on-read); Silver cleanses, deduplicates, and conforms data with schema enforcement; Gold applies business-level aggregations, joins, and curations for specific use cases",
+        "D": "Bronze and Silver perform identical cleansing operations for redundancy; Gold handles all business logic and aggregation"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The medallion architecture defines clear responsibilities: Bronze preserves raw data with minimal changes (append metadata, track ingestion), Silver handles data quality (dedup, null handling, type casting, schema enforcement, conforming), and Gold delivers business-ready datasets (aggregations, dimensional models, KPI tables). Option A incorrectly places schema enforcement and deduplication at the Bronze layer, which should preserve raw data fidelity.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q039",
+      "domain": "section-3-data-modeling",
+      "title": "Question 39",
+      "difficulty": "hard",
+      "question": "How does Delta Lake enforce these constraints during the write operation?",
+      "choices": {
+        "A": "The NOT NULL constraint is enforced but CHECK constraints are only evaluated during reads, so only the 5 null records cause failures",
+        "B": "Both constraints are treated as warnings, and violating records are logged but still written to the table",
+        "C": "The CHECK constraint catches all 8 violating records (nulls and negatives) since CHECK implicitly covers nulls, and the write fails for the entire batch",
+        "D": "Both constraints are enforced independently at write time, and the entire write operation fails if any record violates either constraint, with an error indicating which constraint was violated"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Delta Lake enforces both NOT NULL and CHECK constraints at write time. If any record in the batch violates either constraint, the entire transaction is rejected with an error message identifying the violated constraint. These are independent checks: NOT NULL catches the 5 null records and CHECK catches the 3 negative-quantity records. Option C is incorrect because CHECK constraints do not implicitly handle nulls; SQL CHECK constraints evaluate to UNKNOWN (not false) for nulls, so the NOT NULL constraint is needed separately.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q040",
+      "domain": "section-4-security-governance",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "What happens to the existing Hive metastore tables in the subsidiary workspace once it is attached to the Unity Catalog metastore?",
+      "choices": {
+        "A": "The legacy Hive metastore tables are automatically migrated into Unity Catalog as managed tables",
+        "B": "The legacy Hive metastore tables remain accessible through the `hive_metastore` catalog but are not governed by Unity Catalog",
+        "C": "The legacy Hive metastore tables are deleted and must be recreated in Unity Catalog",
+        "D": "The legacy Hive metastore tables are copied into Unity Catalog as external tables with identical permissions"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When a workspace is attached to a Unity Catalog metastore, the legacy Hive metastore does not disappear. Its tables remain accessible under the built-in `hive_metastore` catalog, but they are not governed by Unity Catalog's centralized access controls. To bring those tables under Unity Catalog governance, teams must explicitly migrate them using tools like the UCX migration utility or `CREATE TABLE` statements.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q041",
+      "domain": "section-4-security-governance",
+      "title": "Question 41",
+      "difficulty": "hard",
+      "question": "Which approach correctly implements this row-level security requirement in Unity Catalog?",
+      "choices": {
+        "A": "Create a dynamic view that filters rows using `SELECT * FROM transactions WHERE region = CASE WHEN is_account_group_member('region_us') THEN 'US' WHEN is_account_group_member('region_eu') THEN 'EU' WHEN is_account_group_member('region_apac') THEN 'APAC' END`",
+        "B": "Apply a column mask on the `region` column so that unauthorized analysts see NULL instead of the actual region value",
+        "C": "Create three separate tables partitioned by region and grant each group SELECT on only their table",
+        "D": "Use a cluster-level Spark configuration to set `spark.sql.region.filter` to the user's assigned region"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Dynamic views with `is_account_group_member()` provide row-level security by evaluating the querying user's group membership at runtime and filtering rows accordingly. This approach enforces security centrally at the data layer without requiring data duplication. Option B hides column values but still returns all rows, Option C creates data management overhead with duplicated tables, and Option D is not a real Spark configuration parameter.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q042",
+      "domain": "section-4-security-governance",
+      "title": "Question 42",
+      "difficulty": "hard",
+      "question": "How does the third institution (the non-Databricks recipient) authenticate and access data shared via Delta Sharing?",
+      "choices": {
+        "A": "They receive a Databricks personal access token that grants read-only access to the shared tables",
+        "B": "They connect via OAuth using the pharmaceutical company's identity provider",
+        "C": "They install a Databricks Connect client that tunnels into the provider's workspace",
+        "D": "They download an activation link that provisions a bearer token, which the open-source Delta Sharing client uses to authenticate with the sharing server"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Delta Sharing uses an open protocol where recipients receive an activation link to generate a bearer token stored in a credential file. The open-source Delta Sharing connector (available for Spark, pandas, and other platforms) uses this token to authenticate directly with the sharing server without requiring a Databricks account. Options A and C incorrectly assume the recipient needs Databricks credentials or workspace connectivity, and Option B is not how Delta Sharing authenticates external recipients.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q043",
+      "domain": "section-4-security-governance",
+      "title": "Question 43",
+      "difficulty": "hard",
+      "question": "Which query correctly retrieves the relevant audit log entries from the Unity Catalog system tables?",
+      "choices": {
+        "A": "`SELECT * FROM system.information_schema.grants WHERE grantee = 'etl-service-principal' AND grant_date > current_date() - INTERVAL 7 DAYS`",
+        "B": "`SELECT * FROM system.access.audit WHERE user_identity = 'etl-service-principal' AND event_type = 'SECURITY_ALERT'`",
+        "C": "`SELECT * FROM system.access.audit WHERE user_identity.email = 'etl-service-principal' AND action_name IN ('updatePermissions', 'grantPermission') AND event_time > current_date() - INTERVAL 7 DAYS`",
+        "D": "`SELECT * FROM system.billing.usage WHERE identity.email = 'etl-service-principal' AND usage_type = 'GRANT_OPERATION'`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `system.access.audit` table records all governance-related actions in Unity Catalog, including permission changes. Filtering on `user_identity.email` for the service principal and `action_name` for grant-related operations isolates privilege escalation events. Option A queries the information schema which shows current grants but not the audit trail of who made changes, Option B uses a non-existent `event_type` value, and Option D queries billing data which does not track security operations.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q044",
+      "domain": "section-4-security-governance",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "What is the recommended approach to address this situation and prevent similar issues going forward?",
+      "choices": {
+        "A": "Create a service principal with a client secret, assign it only the permissions needed to run production jobs, and configure Airflow to authenticate using the service principal's credentials",
+        "B": "Transfer the engineer's personal access token to a shared team account so that multiple engineers can maintain it",
+        "C": "Generate a new personal access token under the engineering manager's account and update Airflow before the engineer departs",
+        "D": "Disable token-based authentication entirely and switch to interactive SSO login for all Airflow-triggered jobs"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Service principals are the recommended approach for production workloads because their lifecycle is independent of any individual user. They support least-privilege access through dedicated role assignments and their credentials can be rotated without impacting a person's account. Option B creates a shared credential anti-pattern with no individual accountability, Option C merely shifts the same problem to a different person, and Option D is impractical since orchestrators like Airflow require non-interactive authentication.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q045",
+      "domain": "section-4-security-governance",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "Which combination of controls should be implemented to prevent this type of data exfiltration while still allowing legitimate workloads?",
+      "choices": {
+        "A": "Revoke all `SELECT` permissions and require users to submit data access requests for each query",
+        "B": "Enable IP access lists on the workspace and restrict notebook execution to read-only mode",
+        "C": "Disable the `COPY INTO` command at the cluster level using a Spark configuration override",
+        "D": "Configure storage firewall rules to restrict egress to only approved storage accounts, and apply table ACLs in Unity Catalog to limit write permissions on external locations to authorized service principals only"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "Defense-in-depth requires both network-level and data-level controls working together. Storage firewall rules and NSG/egress restrictions block connectivity to unapproved storage accounts, while Unity Catalog's external location permissions ensure that only authorized service principals can write to sanctioned destinations. Option A is operationally impractical, Option B does not prevent data writes to external storage, and Option C does not address other exfiltration methods such as direct Spark writes via DataFrames.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q046",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 46",
+      "difficulty": "hard",
+      "question": "Based on the Spark UI Storage tab observations, what is the most likely root cause and the recommended corrective action?",
+      "choices": {
+        "A": "The shuffle partitions are too large; increase `spark.sql.shuffle.partitions` to reduce partition size",
+        "B": "Cached DataFrames are consuming excessive executor memory; unpersist DataFrames that are no longer needed downstream",
+        "C": "The executor JVM garbage collection is misconfigured; switch to G1GC with larger heap regions",
+        "D": "The driver node is running out of memory from collecting results; increase driver memory allocation"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When the Spark UI Storage tab shows multiple large cached DataFrames consuming most executor memory, it creates memory pressure that leaves insufficient heap space for active computation. The fix is to call `.unpersist()` on DataFrames once they are no longer needed in subsequent stages, freeing executor memory for processing. Options A, C, and D address different symptoms and would not resolve memory consumed by unnecessary cached data.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q047",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 47",
+      "difficulty": "hard",
+      "question": "What is the most effective method to identify backlog metrics across individual flows in the Lakeflow Declarative Pipelines pipeline?",
+      "choices": {
+        "A": "Check the Lakeflow Declarative Pipelines pipeline UI graph view and look for red-highlighted tables indicating failures",
+        "B": "Query `system.billing.usage` filtered by the pipeline ID to find the slowest compute phase",
+        "C": "Query the pipeline's event log for `flow_progress` events and examine the `metrics.backlog_bytes` field for each flow",
+        "D": "Examine the Spark UI Streaming tab for each cluster to view micro-batch processing rates"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The Lakeflow Declarative Pipelines event log stores `flow_progress` event types that include detailed metrics such as `backlog_bytes` and `num_output_rows` for each individual flow in the pipeline. Querying these events lets you pinpoint exactly which flow has the largest backlog and is causing downstream lag. Option A shows status but not quantitative backlog metrics, Option B provides cost data not pipeline throughput, and Option D is not directly accessible for DLT-managed clusters.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q048",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 48",
+      "difficulty": "medium",
+      "question": "Which approach most efficiently identifies the source of the cost anomaly?",
+      "choices": {
+        "A": "Export the cluster activity logs from the Admin Console and aggregate compute hours per workspace",
+        "B": "Review the Databricks account billing dashboard to compare high-level totals by workspace",
+        "C": "Query `system.billing.usage` to aggregate DBU consumption by `sku_name`, `workspace_id`, and `usage_date`, then compare month-over-month",
+        "D": "Check each job's run history in the Lakeflow Jobs UI and manually calculate DBU usage from cluster uptime"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `system.billing.usage` system table provides granular, queryable billing records that include SKU name, workspace ID, usage quantities, and dates, enabling precise month-over-month comparisons with SQL aggregations. This is far more efficient than manual approaches. Option B gives only high-level summaries without SKU-level drill-down, Option A lacks DBU cost attribution, and Option D is impractical at scale.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q049",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 49",
+      "difficulty": "hard",
+      "question": "Based on the Ganglia metrics pattern, what is the most likely cause of the executor failures?",
+      "choices": {
+        "A": "Executors are running out of memory due to large shuffle spills or oversized partitions; increase `spark.executor.memory` or repartition the data",
+        "B": "The cluster network bandwidth is saturated during shuffle operations; switch to a compute-optimized instance type",
+        "C": "The autoscaler is removing executors prematurely due to idle timeout; increase the autoscale idle timeout threshold",
+        "D": "The YARN resource manager is preempting executors for higher-priority jobs; configure the job with maximum priority"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Ganglia showing memory utilization spiking to 95% with low CPU usage before executor loss is a strong indicator of out-of-memory conditions, typically caused by large shuffle operations or skewed partitions that exceed the executor memory limit. Increasing executor memory or repartitioning to reduce per-partition size resolves this. Option B would show network metrics spiking rather than memory, Option C applies when executors go idle (not when they crash), and Option D is not applicable in Databricks-managed YARN environments.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q050",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 50",
+      "difficulty": "hard",
+      "question": "What is the recommended approach to implement custom monitoring and alerting for Structured Streaming queries at this scale?",
+      "choices": {
+        "A": "Schedule a notebook to periodically call `spark.streams.active` and check `lastProgress` for each query, then send alerts via webhook",
+        "B": "Enable Databricks SQL Alerts on the `system.billing.usage` table to detect when streaming cluster costs increase unexpectedly",
+        "C": "Implement a `StreamingQueryListener` that captures `onQueryProgress` events, extracts processing rate and watermark lag metrics, and publishes them to an external monitoring system",
+        "D": "Configure Ganglia metric thresholds on each cluster to trigger email alerts when CPU utilization drops below expected levels"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`StreamingQueryListener` is the official Spark API for programmatically monitoring streaming queries, providing `onQueryProgress` callbacks with detailed metrics including `inputRowsPerSecond`, `processedRowsPerSecond`, and watermark information. Publishing these to an external system like PagerDuty enables centralized alerting across all jobs. Option A requires polling and is less reliable, Option B monitors cost not streaming health, and Option D uses infrastructure metrics that do not directly reflect streaming processing rates.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q051",
+      "domain": "section-5-monitoring-logging",
+      "title": "Question 51",
+      "difficulty": "hard",
+      "question": "How should the analyst use the Query Profile to identify the specific bottleneck operator causing the slow performance?",
+      "choices": {
+        "A": "Check the \"Results\" tab to see which rows are returned most frequently and identify if the output is too large",
+        "B": "Examine the operator tree in the Query Profile to find the node with the highest time duration and spill-to-disk metrics, then optimize the corresponding join or aggregation",
+        "C": "Review the \"Query History\" page to compare this query's execution time with previous runs and detect regression",
+        "D": "Look at the warehouse's \"Monitoring\" tab to check if other concurrent queries are competing for resources"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Query Profile's operator tree visualizes each physical operator (scan, join, aggregate, exchange) with time spent and data processed, and highlights operators that spill to disk. Identifying the node with the longest duration and largest spill reveals the exact bottleneck, allowing targeted optimization such as adding filters, changing join order, or adjusting the join strategy. Options A and C do not pinpoint the specific operator, and Option D checks for resource contention rather than query-level optimization issues.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q052",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 52",
+      "difficulty": "medium",
+      "question": "When the bundle is deployed to the production target, what is the effective configuration for `max_concurrent_runs` and `num_workers`?",
+      "choices": {
+        "A": "`max_concurrent_runs: 1`, `num_workers: 2` -- root-level defaults always take precedence",
+        "B": "`max_concurrent_runs: 4`, `num_workers: unset` -- the target completely replaces the root-level job definition",
+        "C": "The deployment fails because the target cannot override root-level resource settings",
+        "D": "`max_concurrent_runs: 4`, `num_workers: 2` -- the target overrides only the settings it explicitly specifies"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "DAB uses a merge strategy where target-level settings are deep-merged with root-level defaults. Properties explicitly set in the target override the corresponding root-level values, while unspecified properties inherit the root-level defaults. This allows teams to define common baseline configurations at the root level and only override what differs per environment.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q053",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 53",
+      "difficulty": "hard",
+      "question": "What happens during the OIDC token exchange with Databricks?",
+      "choices": {
+        "A": "Databricks validates the GitHub OIDC token against the configured identity federation policy and issues a short-lived OAuth access token for the service principal",
+        "B": "Databricks stores the GitHub OIDC token as a persistent secret and uses it for all future API calls from that service principal",
+        "C": "GitHub Actions receives a Databricks personal access token that is valid for 90 days and cached in the workflow runner",
+        "D": "Databricks converts the GitHub OIDC token into a workspace-level API key that must be manually rotated every 30 days"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "In the OIDC token exchange flow, Databricks validates the incoming GitHub OIDC token by checking its claims against the identity federation policy configured on the service principal. If validation succeeds, Databricks issues a short-lived OAuth token scoped to the service principal's permissions. This eliminates the need to store long-lived credentials in GitHub Secrets and provides automatic token rotation per workflow run.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q054",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 54",
+      "difficulty": "medium",
+      "question": "Which deployment strategy best meets these requirements?",
+      "choices": {
+        "A": "Blue-green deployment: deploy the new pipeline version alongside the old one, then switch all traffic instantly by updating the job definition",
+        "B": "Rolling deployment: gradually update each cluster node to run the new pipeline code one at a time",
+        "C": "Canary deployment: route a small percentage of incoming data to the new pipeline version, monitor its metrics, and gradually increase the percentage if results are healthy",
+        "D": "Feature flag deployment: wrap all new transformation logic in feature flags and toggle them on simultaneously across the existing pipeline"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A canary deployment allows the team to validate the new pipeline version with a small subset of real production data while keeping the existing pipeline handling the majority of traffic. This provides production-grade validation with minimal blast radius -- if the canary pipeline shows errors or data quality issues, the team can instantly stop routing data to it. Unlike blue-green, canary gives gradual confidence building rather than an all-or-nothing switchover.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q055",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 55",
+      "difficulty": "hard",
+      "question": "How should the team validate the expectation results in their CI/CD pipeline?",
+      "choices": {
+        "A": "Parse the Lakeflow Declarative Pipelines pipeline logs from the cluster driver output to count dropped rows",
+        "B": "Query the Lakeflow Declarative Pipelines event log for expectation metrics using `expectations.dropped_records` and compare the drop rate against the 0.1% threshold",
+        "C": "Add a downstream notebook that reads the target table's row count and compares it to the source table's row count",
+        "D": "Configure a Lakeflow Declarative Pipelines alert that sends an email notification if the drop rate exceeds 0.1%"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Lakeflow Declarative Pipelines event log captures detailed metrics for each expectation, including the number of records that passed, failed, and were dropped. By querying the event log for `expectations` events, the CI/CD pipeline can programmatically extract the drop counts, calculate the drop rate, and fail the pipeline promotion if the rate exceeds the defined threshold. This approach is precise, automatable, and uses the purpose-built observability layer rather than indirect row-count comparisons or non-programmatic alerts.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q056",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 56",
+      "difficulty": "medium",
+      "question": "Which `databricks.yml` configuration correctly implements these permission requirements?",
+      "choices": {
+        "A": "Set `run_as` to the `data-ops` group and leave permissions unspecified so the group inherits run access",
+        "B": "Add a `permissions` block with `CAN_MANAGE` for `data-ops` and rely on Unity Catalog to restrict edit access",
+        "C": "Deploy the job with no permissions block and then manually configure permissions through the Databricks workspace UI",
+        "D": "Add a `permissions` block granting `CAN_VIEW` and `CAN_MANAGE_RUN` to `group_name: data-ops` while the deploying service principal retains `CAN_MANAGE` as the owner"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The DAB `permissions` block on a job resource supports fine-grained access levels including `CAN_VIEW`, `CAN_MANAGE_RUN`, and `CAN_MANAGE`. Granting `CAN_MANAGE_RUN` to the `data-ops` group allows them to trigger and monitor job runs without being able to edit the job definition. The deploying service principal automatically retains `CAN_MANAGE` as the resource owner, ensuring only the deployment pipeline can modify the job configuration.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q057",
+      "domain": "section-6-testing-deployment",
+      "title": "Question 57",
+      "difficulty": "medium",
+      "question": "What is the fastest way to roll back the deployment using Databricks Asset Bundles?",
+      "choices": {
+        "A": "Check out the previous Git commit in the repository and run `databricks bundle deploy --target production` to redeploy the last known good version",
+        "B": "Run `databricks bundle destroy --target production` to remove the broken deployment, then manually recreate the resources from the Databricks UI",
+        "C": "Use `databricks bundle run --target production --version previous` to automatically roll back to the prior deployed version",
+        "D": "Navigate to the Databricks workspace UI, locate each deployed resource, and manually revert the settings to match the previous configuration"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Since DAB deployments are driven from source-controlled configuration files, the fastest rollback strategy is to check out the previous known-good commit in Git and redeploy with `databricks bundle deploy`. This restores all resource configurations -- jobs, pipelines, clusters -- to their previous state in a single command. Option C uses a `--version` flag that does not exist in the DAB CLI. Options B and D are slow, error-prone, and defeat the purpose of infrastructure-as-code.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q058",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 58",
+      "difficulty": "medium",
+      "question": "How should the team define the session metrics dataset in the Lakeflow Declarative Pipelines pipeline to best serve both downstream consumers?",
+      "choices": {
+        "A": "Define it as a materialized view so that both the dashboard and batch process always read a consistent, pre-computed result",
+        "B": "Define it as a streaming table with Change Data Feed enabled so the batch process can read incremental changes",
+        "C": "Define it as a streaming table so the real-time dashboard reads low-latency results, while the batch process queries the same table on its own schedule",
+        "D": "Define two separate datasets: a streaming table for the dashboard and a materialized view for the batch process"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A streaming table continuously processes incoming records with low latency, which satisfies the real-time dashboard's requirement for fresh data. The nightly batch process can simply query the same streaming table at its scheduled time without requiring a separate materialized view. Option D introduces unnecessary duplication, and option A (materialized view) only recomputes on pipeline refresh rather than processing incrementally, adding latency unsuitable for the 30-second dashboard polling.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q059",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 59",
+      "difficulty": "medium",
+      "question": "Which workload pattern benefits most from enabling Photon on this warehouse?",
+      "choices": {
+        "A": "The ad-hoc exploratory queries, because Photon accelerates Python UDF execution through native compilation",
+        "B": "The nightly ETL jobs, because Photon accelerates scan-heavy operations, joins, and aggregations on Delta tables",
+        "C": "Both workloads benefit equally, because Photon replaces the entire Spark execution engine",
+        "D": "Neither workload benefits significantly, because Photon only optimizes streaming workloads"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Photon is a vectorized query engine written in C++ that significantly accelerates scan-intensive operations, hash joins, aggregations, and shuffle operations on Delta tables -- exactly the patterns in the nightly ETL jobs. Photon does not accelerate Python UDFs, which still execute in the standard Python runtime, so the ad-hoc queries with Python UDFs see limited benefit. Option C is incorrect because Photon does not replace the entire engine; unsupported operations fall back to standard Spark execution.",
+      "explanation": ""
+    },
+    {
+      "id": "data-engineer-professional-mock-2-q060",
+      "domain": "section-7-lakeflow-pipelines-performance",
+      "title": "Question 60",
+      "difficulty": "medium",
+      "question": "How does `OPTIMIZE` behave differently after the table has been converted to liquid clustering?",
+      "choices": {
+        "A": "Configure Lakeflow Jobs notifications (email + webhook to PagerDuty) for failures AND query `system.lakeflow.job_run_timeline` for historical failure analytics",
+        "B": "Add a Slack webhook inside the job's last task that fires on success; absence of message indicates failure",
+        "C": "Set up a SQL Alert that polls `SHOW JOBS` every 5 minutes",
+        "D": "Rely on Databricks support to surface failures automatically"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "With liquid clustering, `OPTIMIZE` uses an incremental approach that identifies and rewrites only the files that would benefit from better clustering, rather than rewriting the entire table or requiring a full sort. This is a key behavioral difference from Z-ORDER, which rewrites all files in the targeted partitions on each OPTIMIZE run. The incremental strategy reduces write amplification and makes it practical to run OPTIMIZE more frequently without excessive I/O cost.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "data-engineer-professional"
+}
diff --git a/practice/data/data-engineer-professional.json b/practice/data/data-engineer-professional.json
index dab1017..119f486 100644
--- a/practice/data/data-engineer-professional.json
+++ b/practice/data/data-engineer-professional.json
@@ -2,7 +2,7 @@
   "cert": "data-engineer-professional",
   "certTitle": "Data Engineer Professional",
   "blueprintVersion": "Nov 30, 2025",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "data-processing",
diff --git a/practice/data/genai-engineer-associate-mock-1.json b/practice/data/genai-engineer-associate-mock-1.json
new file mode 100644
index 0000000..a85434b
--- /dev/null
+++ b/practice/data/genai-engineer-associate-mock-1.json
@@ -0,0 +1,756 @@
+{
+  "cert": "genai-engineer-associate-mock-1",
+  "certTitle": "GenAI Engineer Associate — Mock Exam 1",
+  "blueprintVersion": "Mar 2026",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "design-rag-solutions",
+      "name": "Design RAG Solutions",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 14
+    },
+    {
+      "id": "vector-search-embeddings",
+      "name": "Vector Search & Embeddings",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 11
+    },
+    {
+      "id": "llm-application-development",
+      "name": "LLM Application Development",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "databricks-genai-tools",
+      "name": "Databricks GenAI Tools",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam/questions.md",
+      "questionCount": 7
+    }
+  ],
+  "questions": [
+    {
+      "id": "genai-engineer-associate-mock-1-q001",
+      "domain": "design-rag-solutions",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "A retail company wants to allow customers to ask natural language questions about their product catalog (50,000 products, updated daily). The answers must reflect today's inventory. Which architecture is MOST appropriate?",
+      "choices": {
+        "A": "Fine-tune an LLM on the product catalog monthly and deploy as a chatbot",
+        "B": "Build a RAG pipeline that retrieves relevant products from a daily-refreshed Vector Search index",
+        "C": "Store the entire catalog in the system prompt and send it with every request",
+        "D": "Build a classification model that maps questions to product categories"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "RAG with a daily-refreshed vector index is ideal for dynamic, frequently updated knowledge. Fine-tuning requires expensive retraining for every catalog change. Including 50,000 products in the system prompt is computationally infeasible — it would vastly exceed any LLM's context window. A classification model maps categories but cannot answer freeform product questions.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q002",
+      "domain": "design-rag-solutions",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A developer decides between recursive character text splitting and fixed-size chunking for a document corpus consisting of structured legal contracts with clearly defined numbered clauses. Which is MOST appropriate?",
+      "choices": {
+        "A": "Recursive character text splitting — respects paragraph boundaries",
+        "B": "Fixed-size chunking — contracts have a known average clause length",
+        "C": "Semantic chunking based on clause boundaries — aligns naturally with the document structure",
+        "D": "Page-level chunking — legal documents are formatted consistently page by page"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Legal contracts have clearly defined clause boundaries (e.g., \"1.1\", \"2.3\") that semantically delineate distinct legal obligations. Chunking at clause boundaries produces self-contained chunks that embed and retrieve better than arbitrary-size splits. Recursive character splitting and fixed-size chunking both ignore the semantic structure of contracts. Page-level chunking may split a single clause across multiple chunks.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q003",
+      "domain": "design-rag-solutions",
+      "title": "Question 3",
+      "difficulty": "medium",
+      "question": "A developer configures their RAG pipeline with top-k=10 retrieval. The LLM produces verbose, unfocused answers that include information from many unrelated chunks. What is the MOST appropriate adjustment?",
+      "choices": {
+        "A": "Increase k to 20 to give the LLM more context",
+        "B": "Decrease k to 3–5 and add a reranker to ensure the most relevant chunks are included",
+        "C": "Switch from cosine similarity to L2 distance",
+        "D": "Increase the chunk size to reduce the total number of retrieved chunks"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When the LLM produces unfocused answers due to too many retrieved chunks, the fix is to reduce k so fewer (but more relevant) chunks are passed to the LLM, and add reranking to improve the quality of the retained chunks. Increasing k worsens the problem. The similarity metric does not affect how many chunks are noisy. Increasing chunk size does not reduce the number of chunks passed to the LLM — it just makes each chunk larger.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q004",
+      "domain": "design-rag-solutions",
+      "title": "Question 4",
+      "difficulty": "hard",
+      "question": "A RAG pipeline consistently returns good retrieval results for concrete factual questions but fails for abstract questions like \"What are the strategic risks discussed in the annual reports?\" Which technique MOST improves results for abstract queries?",
+      "choices": {
+        "A": "Reduce chunk size to 64 tokens",
+        "B": "Use HyDE — have the LLM generate a hypothetical answer, then embed and retrieve based on it",
+        "C": "Switch from dense to sparse (BM25) retrieval",
+        "D": "Add metadata filters for the `strategic_risk` category"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Abstract queries are often poorly represented in \"question space\" as embeddings. HyDE bridges the gap by having the LLM generate a hypothetical answer, which is more similar to real answer documents in the embedding space. Smaller chunks worsen context coverage. BM25 performs worse on abstract/semantic queries than on keyword queries. Metadata filters require a pre-labeled category that may not exist.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q005",
+      "domain": "design-rag-solutions",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "A developer uses `mlflow.evaluate()` to score their RAG pipeline and gets a faithfulness score of 0.4 (scale 0–1). What does this indicate?",
+      "choices": {
+        "A": "40% of retrieved documents are relevant to the question",
+        "B": "40% of the time, the LLM produces a non-empty answer",
+        "C": "The LLM's answers are grounded in the retrieved context only 40% of the time, indicating frequent hallucination",
+        "D": "The retrieval step successfully finds the correct document 40% of the time"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Faithfulness measures whether the generated answer is supported by the retrieved context. A score of 0.4 means that 60% of generated content cannot be attributed to the retrieved documents — the LLM is hallucinating at a high rate. This is a generation-quality metric, not a retrieval metric. Retrieval quality is measured by precision@k and recall@k.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q006",
+      "domain": "design-rag-solutions",
+      "title": "Question 6",
+      "difficulty": "easy",
+      "question": "A team uses RAG to power an internal HR chatbot. HR policies are updated quarterly. Which approach CORRECTLY handles policy updates?",
+      "choices": {
+        "A": "Retrain the LLM on the new policy documents each quarter",
+        "B": "Re-index the updated policy documents into the Vector Search index; no LLM changes are needed",
+        "C": "Update the system prompt with a full copy of the new policies",
+        "D": "Fine-tune the LLM's embedding layer on the new documents"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "RAG separates knowledge (the vector index) from reasoning (the LLM). When policies change, you only need to re-index updated documents into the vector store. The LLM itself does not need to be changed. Including full policy text in the system prompt is impractical at scale. Fine-tuning only for style changes, not routine knowledge updates.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q007",
+      "domain": "design-rag-solutions",
+      "title": "Question 7",
+      "difficulty": "hard",
+      "question": "A developer evaluates two RAG pipelines. Pipeline A achieves precision@5 = 0.8 but faithfulness = 0.5. Pipeline B achieves precision@5 = 0.6 but faithfulness = 0.9. Which pipeline should be preferred for a production customer-facing application, and why?",
+      "choices": {
+        "A": "Pipeline A — higher retrieval precision means better answers",
+        "B": "Pipeline B — higher faithfulness means answers are more reliably grounded in facts",
+        "C": "Both are equivalent — precision and faithfulness measure the same thing",
+        "D": "Neither is acceptable — both metrics must exceed 0.9 before production deployment"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "For a customer-facing application, faithfulness is the more critical metric because it measures whether answers are factually grounded rather than hallucinated. Pipeline B's answers are more trustworthy even though it retrieves fewer perfectly relevant documents. Low faithfulness in a customer-facing app risks spreading misinformation. Precision and faithfulness measure different things (retrieval vs generation quality).",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q008",
+      "domain": "design-rag-solutions",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "A company wants to build a multi-modal RAG system that can answer questions about both product text descriptions and product images. What must the embedding model support?",
+      "choices": {
+        "A": "RGB color quantization for consistent image representation",
+        "B": "Multi-modal embeddings that can encode both text and images into the same vector space",
+        "C": "Separate embedding models for text and images, stored in different indexes",
+        "D": "OCR to convert all images to text before embedding"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-modal RAG requires embedding text and images into the same vector space so they can be retrieved together by semantic similarity. Multi-modal models (e.g., CLIP) produce shared embedding spaces. Separate indexes require separate queries and result merging, which is less elegant and loses cross-modal retrieval. OCR loses visual information (charts, diagrams, styling).",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q009",
+      "domain": "design-rag-solutions",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "A developer's RAG pipeline answers questions about a company's internal API documentation. Users complain that answers are cut off mid-explanation. What is the MOST likely root cause?",
+      "choices": {
+        "A": "The vector index requires rebuilding",
+        "B": "The retrieved chunks are too large, consuming the entire context window and leaving no room for generation",
+        "C": "The embedding model is not suited for technical documentation",
+        "D": "The LLM's temperature is set too low, causing early stopping"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "If retrieved chunks consume most of the context window, the LLM has insufficient tokens for generating a complete response and is forced to truncate. The fix is to use smaller chunks or reduce k so fewer tokens are consumed by retrieved context, leaving more room for the generated answer. Temperature affects creativity/randomness, not output length limits.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q010",
+      "domain": "design-rag-solutions",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "A team implements a RAG pipeline for a legal QA system and wants to ensure that retrieved passages are from documents uploaded no more than 12 months ago. How is this constraint BEST implemented?",
+      "choices": {
+        "A": "Post-filter results in Python by checking the `doc_date` field after retrieval",
+        "B": "Use metadata pre-filtering in the Vector Search query with a date range filter",
+        "C": "Create separate vector indexes per month and query only recent ones",
+        "D": "Fine-tune the LLM to ignore outdated legal citations"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Metadata pre-filtering at query time restricts the candidate set before computing similarity, efficiently excluding old documents. Post-filtering wastes compute (retrieves and then discards results). Separate monthly indexes require querying multiple indexes and merging results. Fine-tuning the LLM does not prevent old documents from being retrieved.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q011",
+      "domain": "design-rag-solutions",
+      "title": "Question 11",
+      "difficulty": "easy",
+      "question": "What is the PRIMARY reason RAG is preferred over fine-tuning for grounding LLM responses in proprietary company data?",
+      "choices": {
+        "A": "RAG produces higher quality prose than fine-tuned models",
+        "B": "RAG can reference data that did not exist when the LLM was trained, without modifying model weights",
+        "C": "RAG is always cheaper than fine-tuning at inference time",
+        "D": "RAG eliminates the need for an embedding model"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "RAG's key advantage is that it can leverage private, up-to-date knowledge without modifying the LLM's weights. The LLM's knowledge cutoff is irrelevant because the relevant context is retrieved at inference time. Fine-tuning is expensive and cannot easily incorporate continuously updated information. RAG does require an embedding model — it is a core component. RAG inference cost depends on retrieval infrastructure; it is not always cheaper.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q012",
+      "domain": "design-rag-solutions",
+      "title": "Question 12",
+      "difficulty": "easy",
+      "question": "A developer implements parent-child chunking. Child chunks are 128 tokens with 20-token overlap. Parent chunks are 512 tokens. During retrieval, which chunks are passed to the LLM?",
+      "choices": {
+        "A": "The small child chunks that matched the query",
+        "B": "The large parent chunks that contain the matched child chunks",
+        "C": "Both child and parent chunks, concatenated",
+        "D": "The midpoint chunk (320 tokens) between child and parent size"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "In parent-child chunking, small child chunks are used for high-precision retrieval (finding the right location), but the larger parent chunks are what get passed to the LLM for generation. This provides richer context than the small match chunk alone while maintaining retrieval precision. Only parent chunks are sent to the LLM — passing both would duplicate content and waste context window tokens.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q013",
+      "domain": "design-rag-solutions",
+      "title": "Question 13",
+      "difficulty": "hard",
+      "question": "A RAG pipeline's `answer_relevance` score is 0.9 but its `faithfulness` score is 0.4. What does this combination indicate?",
+      "choices": {
+        "A": "The retrieval step is working well but the LLM is hallucinating content not in the retrieved documents",
+        "B": "The retrieved documents are relevant but the LLM generates verbose, off-topic answers",
+        "C": "Both retrieval and generation are functioning correctly",
+        "D": "The embedding model is producing high-quality vectors but retrieval recall is low"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "High `answer_relevance` (0.9) means the generated answers address the user's question well. Low `faithfulness` (0.4) means those answers contain claims not supported by the retrieved context — the LLM is hallucinating. This is a common failure mode where the LLM produces plausible-sounding but ungrounded answers. The fix is prompt engineering (instruct the LLM to only use provided context) or stricter output guardrails.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q014",
+      "domain": "design-rag-solutions",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "A developer wants to implement re-ranking in their RAG pipeline to improve precision. Which architecture is CORRECT?",
+      "choices": {
+        "A": "Replace the bi-encoder embedding model with a cross-encoder for initial retrieval",
+        "B": "Use a bi-encoder to retrieve top-50 candidates, then apply a cross-encoder to re-score and select top-5",
+        "C": "Use the LLM itself to generate relevance scores for all documents in the index",
+        "D": "Apply BM25 as a post-retrieval filter to remove semantically dissimilar documents"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The standard two-stage retrieval architecture uses a fast bi-encoder to retrieve a large candidate set (top-50), then applies a slower but more accurate cross-encoder to re-score the candidates and select the top-k for the LLM. Using a cross-encoder for initial retrieval over a large corpus is computationally infeasible (it would require scoring every document pair). Using the LLM to score all documents is even more expensive.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q015",
+      "domain": "vector-search-embeddings",
+      "title": "Question 15",
+      "difficulty": "easy",
+      "question": "A team creates a Delta Sync Index with `pipeline_type=\"CONTINUOUS\"` on a Delta table. When a new row is inserted into the source table, when is the index updated?",
+      "choices": {
+        "A": "The index is updated the next time a user queries it",
+        "B": "The index is updated automatically soon after the Delta table change is detected",
+        "C": "The index must be manually synced via the Databricks UI",
+        "D": "The index is updated on a fixed 24-hour schedule"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A `CONTINUOUS` pipeline type keeps the vector index automatically synchronized with the source Delta table. When rows are inserted, updated, or deleted, the changes propagate to the index without manual intervention. `TRIGGERED` mode requires manual sync. There is no automatic 24-hour schedule or query-triggered sync.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q016",
+      "domain": "vector-search-embeddings",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "A team wants to create a Databricks Vector Search index on a table that is NOT managed by Databricks (e.g., an external system writes embeddings computed abroad). Which index type is CORRECT?",
+      "choices": {
+        "A": "Delta Sync Index with `pipeline_type=\"TRIGGERED\"`",
+        "B": "Direct Access Index",
+        "C": "Delta Sync Index with `pipeline_type=\"CONTINUOUS\"`",
+        "D": "Managed Sync Index"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Direct Access Indexes allow external applications to push embeddings via the Databricks Vector Search SDK or REST API using upsert operations. This is the correct choice when embeddings are computed outside Databricks or when the source data is not a Databricks-managed Delta table. Delta Sync Indexes require a Databricks Delta table as the source. \"Managed Sync Index\" is not a valid type.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q017",
+      "domain": "vector-search-embeddings",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "A developer creates a Vector Search index using the `COSINE` similarity metric. At query time, a higher cosine similarity score between the query vector and a document vector indicates what?",
+      "choices": {
+        "A": "The document vector has a larger magnitude than the query vector",
+        "B": "The query and document vectors point in more similar directions — the documents are more semantically related",
+        "C": "The document was indexed more recently than lower-scoring documents",
+        "D": "The document chunk is shorter and therefore more specific"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Cosine similarity measures the angle between two vectors, regardless of their magnitudes. A higher cosine similarity (closer to 1.0) means the vectors point in the same direction, indicating the query and document are semantically similar. Cosine similarity is magnitude-independent, so vector length and recency are irrelevant.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q018",
+      "domain": "vector-search-embeddings",
+      "title": "Question 18",
+      "difficulty": "medium",
+      "question": "A developer is building a product search feature. Users search using image uploads (not text). The product catalog documents are stored as text. Which embedding approach enables cross-modal retrieval?",
+      "choices": {
+        "A": "Two separate indexes: one for image queries, one for text documents",
+        "B": "A multi-modal embedding model that maps both images and text into a shared vector space",
+        "C": "Convert product images to text descriptions using OCR, then use a text embedding model",
+        "D": "Use a text-only embedding model and convert user images to a text description using a captioning model before embedding"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-modal embedding models (e.g., CLIP) map images and text into a unified semantic space, enabling direct image-to-text retrieval. Option D (captioning → text embedding) is a valid workaround but loses visual information and requires an additional model step. Option C only works for text in images, not photographic product images. Two separate indexes cannot perform cross-modal retrieval directly.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q019",
+      "domain": "vector-search-embeddings",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "A developer queries a Databricks Vector Search index and receives results with low similarity scores despite the user's query being clearly relevant to indexed content. What is the MOST likely cause?",
+      "choices": {
+        "A": "The index is using COSINE instead of L2 similarity",
+        "B": "A different embedding model was used for indexing vs querying",
+        "C": "The `num_results` parameter is set too high",
+        "D": "The Vector Search endpoint has not been started"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When different embedding models are used for indexing and querying, the resulting vectors exist in different semantic spaces. Even clearly relevant documents will have low cosine similarity to the query vector because the spaces are not aligned. This is one of the most common and impactful mistakes in RAG implementation. If the endpoint had not been started, the query would fail entirely rather than returning low scores.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q020",
+      "domain": "vector-search-embeddings",
+      "title": "Question 20",
+      "difficulty": "easy",
+      "question": "A data engineer needs to add 10,000 new product embeddings to an existing Direct Access Index. Which SDK method is correct?",
+      "choices": {
+        "A": "`index.insert(data=new_embeddings_df)`",
+        "B": "`index.upsert(dataframe=new_embeddings_df)`",
+        "C": "`index.sync(source_df=new_embeddings_df)`",
+        "D": "`index.merge(embeddings=new_embeddings_df)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Databricks Vector Search SDK uses `index.upsert(dataframe=...)` to add or update vectors in a Direct Access Index. `insert`, `sync`, and `merge` are not valid methods in the Databricks Vector Search Python SDK. Upsert handles both inserts (new IDs) and updates (existing IDs) in a single operation.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q021",
+      "domain": "vector-search-embeddings",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "For a customer support chatbot, a developer can choose between `databricks-bge-large-en` (MTEB score 63.6, 1024-dim) and `databricks-gte-large-en` (MTEB score 63.1, 1024-dim). Which factor MOST influences the decision?",
+      "choices": {
+        "A": "Always choose the model with the higher MTEB score",
+        "B": "Choose based on the specific task type — BGE and GTE have different training data emphases",
+        "C": "Always use 1024-dim models over lower-dimensional models",
+        "D": "The models are equivalent; choose based on alphabetical order"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Even when overall MTEB scores are similar, embedding models differ in performance across task categories (retrieval, classification, clustering, semantic similarity). The right choice depends on the specific use case — customer support retrieval may favor one model's training distribution over the other. Dimensionality alone (both are 1024-dim) does not determine quality for a specific task.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q022",
+      "domain": "vector-search-embeddings",
+      "title": "Question 22",
+      "difficulty": "hard",
+      "question": "A developer wants to filter Vector Search results to documents where the `status` field equals `\"active\"` AND the `priority` field is greater than 3. Which filter dictionary is CORRECT?",
+      "choices": {
+        "A": "`filters={\"status\": \"active\", \"priority >\": 3}`",
+        "B": "`filters={\"status\": \"active\", \"priority\": {\"$gt\": 3}}`",
+        "C": "`filters={\"status\": \"active AND priority > 3\"}`",
+        "D": "`filters=\"status = 'active' AND priority > 3\"`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Databricks Vector Search SDK supports MongoDB-style filter operators for numeric comparisons. The `$gt` operator specifies \"greater than.\" Multiple conditions are expressed as separate keys in the filter dictionary. String SQL expressions and combined string conditions (`\"AND\"` in a single string value) are not valid filter formats for the Vector Search SDK.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q023",
+      "domain": "vector-search-embeddings",
+      "title": "Question 23",
+      "difficulty": "hard",
+      "question": "A team indexes 1 million product embeddings and notices that query latency increases significantly as the index grows. Which index configuration change is MOST likely to improve query latency?",
+      "choices": {
+        "A": "Switch from Direct Access Index to Delta Sync Index",
+        "B": "Rebuild the index with approximate nearest neighbor (ANN) search enabled",
+        "C": "Reduce the `num_results` parameter from 10 to 5",
+        "D": "Switch from COSINE to L2 similarity metric"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "VectorSearch indexes use approximate nearest neighbor (ANN) algorithms (e.g., HNSW) to trade a small amount of accuracy for dramatically faster query latency at scale. Ensuring ANN parameters are properly configured for the index size is the primary lever for latency optimization. Reducing `num_results` helps marginally but doesn't address algorithmic complexity. Index type (Direct vs Delta Sync) and similarity metric do not fundamentally change query performance characteristics.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q024",
+      "domain": "vector-search-embeddings",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "A team stores embeddings for 500,000 documents using `databricks-bge-large-en` (1024-dim, float32). Approximately how much storage do the raw vectors require?",
+      "choices": {
+        "A": "~500 MB",
+        "B": "~2 GB",
+        "C": "~20 GB",
+        "D": "~200 GB"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Each float32 value takes 4 bytes. 500,000 documents × 1024 dimensions × 4 bytes = 2,048,000,000 bytes ≈ 2 GB for the raw vectors. Vector indexes add overhead (metadata, graph structures for ANN), so the actual index size will be larger. Knowing approximate storage requirements helps in capacity planning and choosing between index configurations.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q025",
+      "domain": "vector-search-embeddings",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "A developer deletes a document from the source Delta table. With a Delta Sync Index in `CONTINUOUS` mode, what happens to the corresponding document's embedding in the vector index?",
+      "choices": {
+        "A": "The embedding remains in the index until manually deleted",
+        "B": "The embedding is automatically removed from the vector index when the deletion is detected",
+        "C": "The embedding is marked as \"archived\" but remains searchable",
+        "D": "The entire index must be rebuilt to remove the deleted document's embedding"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A Delta Sync Index in `CONTINUOUS` mode tracks insertions, updates, AND deletions from the source Delta table. When a row is deleted from the source, the corresponding embedding is automatically removed from the vector index. This keeps the index consistent with the source of truth without manual intervention.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q026",
+      "domain": "llm-application-development",
+      "title": "Question 26",
+      "difficulty": "easy",
+      "question": "A developer wants all LangChain chain calls in their notebook to be traced and logged to MLflow automatically. Which single line of code accomplishes this?",
+      "choices": {
+        "A": "`mlflow.langchain.log_model(chain, \"chain\")`",
+        "B": "`mlflow.langchain.autolog()`",
+        "C": "`mlflow.start_run(run_name=\"langchain-trace\")`",
+        "D": "`mlflow.set_tracking_uri(\"databricks\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.langchain.autolog()` enables automatic logging of LangChain chain inputs, outputs, and intermediate steps to MLflow. It must be called once before running chains. `log_model` saves a chain as a deployable model artifact (not for tracing). `start_run` opens a run context but does not enable LangChain-specific autolog. `set_tracking_uri` configures where logs are sent, not what is logged.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q027",
+      "domain": "llm-application-development",
+      "title": "Question 27",
+      "difficulty": "hard",
+      "question": "A developer passes the system prompt: \"You are a helpful assistant. Answer only from the provided context. If the answer is not in the context, say 'I don't know.'\" — but the LLM still generates answers from its parametric knowledge. What is the MOST likely cause?",
+      "choices": {
+        "A": "The system prompt is too short to be effective",
+        "B": "The LLM is ignoring the system prompt because it was not fine-tuned with instruction following",
+        "C": "The retrieved context is empty or insufficient, causing the LLM to fall back on parametric knowledge",
+        "D": "The temperature parameter is too high"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "When the retrieval step returns no relevant context (empty or low-quality retrieval), the LLM often \"fills in\" from its training knowledge despite \"answer only from context\" instructions. The fix is to improve retrieval quality or add an explicit empty-context check. Modern instruction-tuned LLMs generally honor system prompt instructions; the issue is typically an empty context, not prompt length or temperature.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q028",
+      "domain": "llm-application-development",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "A developer builds a multi-turn chatbot using LangChain with `ConversationBufferMemory`. After 50 conversation turns, the LLM API returns a context length exceeded error. What is the BEST solution?",
+      "choices": {
+        "A": "Increase the LLM's context window by switching to a larger model",
+        "B": "Switch to `ConversationBufferWindowMemory` with a fixed window of 10 turns, or to `ConversationSummaryMemory` to compress history",
+        "C": "Disable memory entirely — each turn should be independent",
+        "D": "Reduce the LLM's `max_tokens` parameter"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ConversationBufferMemory` accumulates all history indefinitely, eventually exceeding the context window. The correct fix is to use a memory type that bounds context growth: `ConversationBufferWindowMemory` keeps the last k turns, while `ConversationSummaryMemory` compresses older turns into a summary. Switching to a larger model defers the problem but doesn't solve it permanently. Disabling memory breaks conversational coherence. Reducing `max_tokens` limits output length, not input context size.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q029",
+      "domain": "llm-application-development",
+      "title": "Question 29",
+      "difficulty": "medium",
+      "question": "A developer uses `mlflow.evaluate()` to score a RAG pipeline with `model_type=\"question-answering\"`. The evaluation dataset contains `inputs`, `outputs` (model-generated answers), and `contexts` (retrieved chunks). Which column provides the retrieved context to the faithfulness metric?",
+      "choices": {
+        "A": "`inputs`",
+        "B": "`outputs`",
+        "C": "`contexts`",
+        "D": "`targets`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `contexts` column in the evaluation dataset contains the retrieved passages that were provided to the LLM. The `faithfulness` metric uses the `contexts` column to verify whether the `outputs` (generated answers) are grounded in the provided context. `inputs` contains the user questions. `targets` contains ground-truth reference answers (used for metrics like `exact_match`).",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q030",
+      "domain": "llm-application-development",
+      "title": "Question 30",
+      "difficulty": "easy",
+      "question": "A LangChain application uses a `ConversationChain` with `ConversationSummaryMemory`. What does `ConversationSummaryMemory` store between turns?",
+      "choices": {
+        "A": "The full text of all previous conversation turns",
+        "B": "A running summary of the conversation, regenerated after each turn using the LLM",
+        "C": "A vector embedding of each previous turn for semantic lookup",
+        "D": "Only the last user message and the LLM's most recent response"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ConversationSummaryMemory` progressively summarizes the conversation after each turn using an LLM call, replacing the full history with a condensed summary. This bounds the context window usage while preserving key information. `ConversationBufferMemory` stores the full history. Vector embedding memory is a different type (`VectorStoreRetrieverMemory`). `ConversationBufferWindowMemory` keeps only the last k turns verbatim.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q031",
+      "domain": "llm-application-development",
+      "title": "Question 31",
+      "difficulty": "easy",
+      "question": "A developer wants to create a LangChain agent that can use three tools: `search_database`, `call_weather_api`, and `lookup_inventory`. Which component decides which tool to call for a given user input?",
+      "choices": {
+        "A": "The `SequentialChain` executes all tools in order and returns the final result",
+        "B": "The LLM reasoning engine within the agent, using tool names and descriptions to select the appropriate tool",
+        "C": "A rule-based router that pattern-matches user inputs to tool names",
+        "D": "The `RetrievalQA` chain automatically routes to the appropriate retriever"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "LangChain Agents use an LLM as a reasoning engine (following the ReAct or similar pattern) to decide which tool to call based on the user's input and each tool's name and description. The LLM generates a \"thought\" and \"action\" (tool selection + arguments) iteratively. There is no built-in rule-based router for arbitrary tools — the LLM provides the dynamic decision-making.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q032",
+      "domain": "llm-application-development",
+      "title": "Question 32",
+      "difficulty": "medium",
+      "question": "A developer logs a LangChain `RetrievalQA` chain with `mlflow.langchain.log_model()` and wants to load it back for inference. Which code is correct?",
+      "choices": {
+        "A": "`chain = mlflow.langchain.load_model(model_uri)`",
+        "B": "`chain = mlflow.pyfunc.load_model(model_uri)`",
+        "C": "`chain = mlflow.sklearn.load_model(model_uri)`",
+        "D": "`chain = pickle.load(open(model_uri, \"rb\"))`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Models logged with any MLflow flavor (including `mlflow.langchain`) can be loaded as a `pyfunc` model using `mlflow.pyfunc.load_model(model_uri)`. This returns an object with a `.predict()` method that wraps the chain. `mlflow.langchain.load_model()` also works but is flavor-specific. `mlflow.sklearn.load_model()` is for scikit-learn models. Using `pickle` directly is not recommended and does not work with the MLflow artifact store.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q033",
+      "domain": "llm-application-development",
+      "title": "Question 33",
+      "difficulty": "easy",
+      "question": "A developer configures a LangChain `RetrievalQA` chain with `chain_type=\"stuff\"`. What does this configuration do with retrieved documents?",
+      "choices": {
+        "A": "Summarizes each retrieved document individually before passing to the LLM",
+        "B": "Selects the single most relevant document and ignores the rest",
+        "C": "Concatenates all retrieved documents into a single context block and passes them to the LLM in one call",
+        "D": "Splits retrieved documents into smaller chunks before passing to the LLM"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `\"stuff\"` chain type concatenates all retrieved documents together (\"stuffs\" them) into the LLM's prompt in a single call. This is the simplest approach and works well when k is small and retrieved chunks are short. Other chain types include `\"map_reduce\"` (summarizes each doc then combines), `\"refine\"` (iteratively refines the answer), and `\"map_rerank\"` (scores each doc's answer and picks the best).",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q034",
+      "domain": "llm-application-development",
+      "title": "Question 34",
+      "difficulty": "hard",
+      "question": "A developer needs to prevent their LangChain agent from calling the `delete_database` tool unless the user's message explicitly contains the word \"delete\". Which is the MOST appropriate implementation?",
+      "choices": {
+        "A": "Remove the `delete_database` tool from the agent's tool list",
+        "B": "Add a validation check in the `delete_database` tool function that raises an error if \"delete\" is not in the original input",
+        "C": "Add a guardrail layer that intercepts the agent's action before execution and validates the action against the original user input",
+        "D": "Set the LLM's temperature to 0 to prevent unexpected tool calls"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A guardrail interceptor layer sits between the agent's reasoning step and the tool execution step. It can validate, log, or block any proposed action before it is executed. This provides a deterministic safety check that supplements (but does not replace) the LLM's judgment. Adding the check inside the tool function (B) is a valid defense-in-depth measure but not the primary guardrail location. Temperature affects randomness, not tool selection logic.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q035",
+      "domain": "llm-application-development",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A team wants to A/B test two different system prompts for their RAG chatbot. MLflow evaluation will be run on the same 100-question test set for both prompts. Which MLflow feature enables systematic comparison?",
+      "choices": {
+        "A": "Model Registry — register each prompt variant as a separate model version",
+        "B": "`mlflow.evaluate()` run results stored in an MLflow experiment — compare runs in the experiment UI",
+        "C": "MLflow Autolog — automatically generates A/B test results for each prompt",
+        "D": "Lakeflow Jobs — schedule two jobs, one per prompt"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Running `mlflow.evaluate()` for each prompt variant logs metrics as separate MLflow runs within the same experiment. The experiment comparison UI then allows side-by-side metric comparison (faithfulness, answer relevance, etc.) across variants. Model Registry is for versioning deployable models, not for tracking evaluation configurations. Autolog captures training data, not evaluation A/B comparisons. Lakeflow Jobs orchestrate workloads but don't provide evaluation comparison.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q036",
+      "domain": "llm-application-development",
+      "title": "Question 36",
+      "difficulty": "easy",
+      "question": "A developer sets `temperature=0.0` when calling a Foundation Model API endpoint. What is the effect?",
+      "choices": {
+        "A": "The model always refuses to answer questions it is uncertain about",
+        "B": "The model produces deterministic, greedy outputs (the most likely token at each step)",
+        "C": "The model generates shorter responses to reduce cost",
+        "D": "The model skips the context window and uses only parametric knowledge"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Temperature controls the randomness of token sampling. At `temperature=0`, the model uses greedy decoding — always selecting the highest-probability token. This produces deterministic (reproducible) outputs. It does not affect response length, refusal behavior, or knowledge source. Temperature close to 1.0 produces more varied/creative outputs; temperature close to 0 produces focused, deterministic outputs.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q037",
+      "domain": "llm-application-development",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "A developer builds a LangChain pipeline where Step 1 extracts key entities from the user query, and Step 2 uses those entities to formulate a database query. Which LangChain construct is MOST appropriate?",
+      "choices": {
+        "A": "A LangChain Agent with two tools: entity extraction and database query",
+        "B": "A `SequentialChain` where the output of Step 1 is automatically passed as input to Step 2",
+        "C": "A `RetrievalQA` chain with a custom retriever that performs entity extraction",
+        "D": "Two separate `LLMChain` objects called independently and joined with Python string formatting"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A `SequentialChain` is designed for pipelines where the output of one chain step is passed as the input to the next step. This creates a directed workflow where each step builds on the previous one. Agents are appropriate for dynamic decision-making (which tool to call), not for fixed sequential pipelines. Joining chains manually with Python is possible but less maintainable than using `SequentialChain`.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q038",
+      "domain": "llm-application-development",
+      "title": "Question 38",
+      "difficulty": "hard",
+      "question": "A developer uses `mlflow.evaluate()` with a custom judge model for evaluating response quality. The judge model is a Foundation Model API endpoint. Which parameter specifies the judge model?",
+      "choices": {
+        "A": "`judge_model=\"databricks/dbrx-instruct\"`",
+        "B": "`evaluator_config={\"openai_model\": \"gpt-4\"}`",
+        "C": "`extra_metrics=[answer_relevance(model=\"endpoints:/databricks-dbrx-instruct\")]`",
+        "D": "`model_type=\"llm-judge\"` with `judge_endpoint=\"databricks-dbrx-instruct\"`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "In MLflow, LLM-judge metrics accept a `model` parameter that specifies which model to use for judging. For Databricks Foundation Model endpoints, the format is `\"endpoints:/endpoint-name\"`. This is passed inside the metric function call within `extra_metrics`. There is no top-level `judge_model` parameter or `model_type=\"llm-judge\"` option in `mlflow.evaluate()`.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q039",
+      "domain": "databricks-genai-tools",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A team's production RAG chatbot handles 500 requests per minute with strict p99 latency requirements under 2 seconds. Which Foundation Model API endpoint type is MOST appropriate?",
+      "choices": {
+        "A": "Pay-per-token endpoint — serverless and auto-scaling",
+        "B": "External Model endpoint — uses OpenAI's infrastructure",
+        "C": "Provisioned Throughput endpoint — dedicated capacity with guaranteed throughput",
+        "D": "Batch Inference endpoint — processes all 500 requests in parallel"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Provisioned Throughput endpoints provide dedicated compute capacity with guaranteed throughput (tokens per second) and more consistent latency — essential for production SLAs. Pay-per-token endpoints share infrastructure with other users and have variable latency that can exceed 2 seconds under load. External Model endpoints introduce network hops to third-party providers, adding latency variance. Batch endpoints are for offline workloads, not real-time serving.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q040",
+      "domain": "databricks-genai-tools",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "A developer registers a LangChain chain as an MLflow model. Which `mlflow.evaluate()` input format correctly measures chain performance on a test dataset?",
+      "choices": {
+        "A": "A list of user questions passed as `data=[q1, q2, q3]`",
+        "B": "A pandas DataFrame with `inputs` and `targets` columns (and optionally `contexts`)",
+        "C": "A Delta table name passed as `data=\"main.catalog.test_table\"`",
+        "D": "A dictionary with `questions` and `expected_answers` keys"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.evaluate()` accepts a pandas DataFrame with standardized column names: `inputs` (user queries), `targets` (ground truth answers, optional), `contexts` (retrieved passages, optional). This is the standard evaluation data format. A list of strings, a Delta table name (directly), or a custom dictionary format are not natively supported by `mlflow.evaluate()`.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q041",
+      "domain": "databricks-genai-tools",
+      "title": "Question 41",
+      "difficulty": "easy",
+      "question": "A team deploys a Model Serving endpoint for their RAG chain and enables inference tables. Where are the logged request/response payloads stored?",
+      "choices": {
+        "A": "In the MLflow experiment associated with the endpoint",
+        "B": "In a Delta table in Unity Catalog, as specified in the endpoint configuration",
+        "C": "In DBFS at `/dbfs/serving-endpoints/logs/`",
+        "D": "In the Databricks audit log accessible via `system.access.audit`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Inference tables write endpoint request and response data to a Delta table in Unity Catalog. The table location is specified when creating or configuring the endpoint. This enables downstream monitoring, evaluation, and fine-tuning workflows on real production traffic. MLflow experiments track training runs, not serving traffic. DBFS log paths and audit logs (`system.access.audit`) serve different purposes.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q042",
+      "domain": "databricks-genai-tools",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "A developer queries a `databricks-meta-llama-3-1-70b-instruct` Foundation Model endpoint and needs the response to be in JSON format with specific fields. Which approach is MOST reliable?",
+      "choices": {
+        "A": "Set `temperature=0` to force structured output",
+        "B": "Use JSON mode if supported by the endpoint, or include explicit JSON format instructions with an example in the system prompt",
+        "C": "Post-process the response with `json.loads()` — all Foundation Model APIs return JSON automatically",
+        "D": "Set `max_tokens=100` to prevent the model from generating extra text"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "For structured JSON output, the most reliable approaches are: (1) use JSON mode (response format parameter) if the endpoint supports it, or (2) provide clear JSON format instructions with an example in the system prompt. Not all endpoints guarantee JSON output automatically — `json.loads()` will fail on free-form text responses. Temperature=0 ensures determinism but not JSON format. `max_tokens` limits length, not format.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q043",
+      "domain": "databricks-genai-tools",
+      "title": "Question 43",
+      "difficulty": "medium",
+      "question": "An organization wants to use Databricks Foundation Model APIs for internal use but prevent individual teams from storing API keys in their notebooks. Which Databricks feature enables centralized credential management for Foundation Model endpoints?",
+      "choices": {
+        "A": "MLflow Model Registry access control lists",
+        "B": "Unity Catalog column masking policies",
+        "C": "Databricks Secrets with service principal authentication — or MLflow AI Gateway for external models",
+        "D": "Cluster-level environment variables set by workspace administrators"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Secrets store credentials securely and can be scoped to groups, preventing individual users from accessing raw API keys. For external model endpoints (OpenAI, Anthropic), MLflow AI Gateway centralizes credential management so client applications use Databricks authentication instead of provider-specific API keys. Model Registry ACLs govern model version access, not API credentials. Column masking is a Unity Catalog data governance feature.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q044",
+      "domain": "databricks-genai-tools",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "A developer logs a LangChain chain to MLflow and wants to deploy it as a REST endpoint on Databricks Model Serving. What is the EXACT correct sequence of steps?",
+      "choices": {
+        "A": "Log model → Create serving endpoint → Register to Model Registry",
+        "B": "Register to Model Registry → Log model → Create serving endpoint",
+        "C": "Log model → Register to Model Registry → Create serving endpoint",
+        "D": "Create serving endpoint → Log model → Register to Model Registry"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The correct Databricks deployment workflow is: (1) **Log** the model to an MLflow run with `mlflow.langchain.log_model()`, (2) **Register** the logged model to the MLflow Model Registry with `mlflow.register_model()`, (3) **Create** a Model Serving endpoint pointing to the registered model version. The Model Registry is the source of truth for serving; a logged (but unregistered) model cannot be served by Databricks Model Serving.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-1-q045",
+      "domain": "databricks-genai-tools",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "A team uses `mlflow.evaluate()` to score their RAG chain and gets these results: `faithfulness=0.85`, `answer_relevance=0.90`, `toxicity=0.02`. Which conclusion is MOST accurate?",
+      "choices": {
+        "A": "Sample N recent rows from the Inference Table into a Spark DataFrame; run `mlflow.evaluate(data=sample, model_type=\"databricks-agent\")` so the built-in Databricks RAG judges (groundedness, relevance, correctness, safety) score the sample; schedule via a Lakeflow Job",
+        "B": "Manually read 100 random conversations every week",
+        "C": "Compute a groundedness score with a regex over the response text",
+        "D": "Train a custom classifier on production data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Faithfulness=0.85 is strong (85% of claims are grounded in context). Answer relevance=0.90 is excellent (answers address the user's question 90% of the time). Toxicity=0.02 is very low (2% frequency, which may refer to low scores, not that 2% are harmful). Together these indicate a well-performing pipeline. Production readiness thresholds are domain-specific — there are no universal 0.95 requirements. Faithfulness is a generation metric, not a retrieval metric.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "genai-engineer-associate"
+}
diff --git a/practice/data/genai-engineer-associate-mock-2.json b/practice/data/genai-engineer-associate-mock-2.json
new file mode 100644
index 0000000..7bf6d57
--- /dev/null
+++ b/practice/data/genai-engineer-associate-mock-2.json
@@ -0,0 +1,708 @@
+{
+  "cert": "genai-engineer-associate-mock-2",
+  "certTitle": "GenAI Engineer Associate — Mock Exam 2",
+  "blueprintVersion": "Mar 2026",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "design-rag-solutions",
+      "name": "Design RAG Solutions",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 14
+    },
+    {
+      "id": "vector-search-embeddings",
+      "name": "Vector Search & Embeddings",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 10
+    },
+    {
+      "id": "llm-application-development",
+      "name": "LLM Application Development",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 12
+    },
+    {
+      "id": "databricks-genai-tools",
+      "name": "Databricks GenAI Tools",
+      "sourceFile": "certifications/genai-engineer-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 6
+    }
+  ],
+  "questions": [
+    {
+      "id": "genai-engineer-associate-mock-2-q001",
+      "domain": "design-rag-solutions",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "A pharmaceutical company has 10 million pages of clinical trial data. Researchers ask ad hoc questions daily, and new trial data is added weekly. The company must comply with strict data residency requirements — no data can leave their Databricks environment. Which architecture is MOST appropriate?",
+      "choices": {
+        "A": "Use the OpenAI API directly with a fine-tuned GPT-4 model trained on the trial data",
+        "B": "Build a RAG pipeline using Databricks Vector Search and a Provisioned Throughput Foundation Model endpoint, keeping all data and inference within Databricks",
+        "C": "Export the data to a third-party vector database for lower latency retrieval",
+        "D": "Store all 10 million pages in the LLM system prompt using a 1M-token context model"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Vector Search and Foundation Model APIs keep all data and inference within the Databricks environment, satisfying data residency requirements. The OpenAI API, third-party vector databases, and 1M-token context approaches all either violate residency constraints or are computationally infeasible at 10 million pages.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q002",
+      "domain": "design-rag-solutions",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A team processes scientific papers in PDF format for a RAG pipeline. The papers contain long structured sections (Abstract, Methods, Results, Discussion) with consistent headers. Which chunking strategy MOST preserves the semantic integrity of each section?",
+      "choices": {
+        "A": "Fixed-size chunks of 256 tokens with 32-token overlap",
+        "B": "Recursive character text splitting with aggressive overlap",
+        "C": "Semantic chunking at section boundaries (using headers as delimiters)",
+        "D": "Sentence-level chunking and re-grouping every 5 sentences"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "When documents have consistent, meaningful structure (section headers), chunking at those structural boundaries preserves the semantic integrity of each section. Each chunk (Abstract, Methods, Results) is a coherent unit that answers different types of questions. Fixed-size chunking and recursive splitting ignore document structure, often splitting important sections mid-thought.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q003",
+      "domain": "design-rag-solutions",
+      "title": "Question 3",
+      "difficulty": "hard",
+      "question": "A developer tests their RAG pipeline and finds that retrieval precision@5 = 0.40 (only 2 of 5 retrieved chunks are relevant). The LLM produces mostly correct answers despite poor retrieval. What is the BIGGEST risk of this situation in production?",
+      "choices": {
+        "A": "The pipeline is more expensive than necessary because extra chunks are retrieved",
+        "B": "The LLM may occasionally answer correctly by chance from irrelevant context, but will be unreliable and may hallucinate more often",
+        "C": "The vector index will require more storage than necessary",
+        "D": "The embedding model is mismatched to the query domain"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When 60% of retrieved chunks are irrelevant, the LLM works with noisy context and may occasionally produce correct answers from the noise in testing — but production reliability suffers significantly. Non-relevant context increases hallucination risk. Low precision is primarily a correctness problem, not a cost or storage issue.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q004",
+      "domain": "design-rag-solutions",
+      "title": "Question 4",
+      "difficulty": "hard",
+      "question": "A developer measures their RAG pipeline and finds faithfulness=0.92 but answer_relevance=0.55. What does this combination indicate?",
+      "choices": {
+        "A": "The LLM is grounding its answers in the retrieved context but the retrieved context often does not contain the information users are actually asking for",
+        "B": "The retrieval step is excellent, but the LLM is hallucinating 45% of the time",
+        "C": "The pipeline is performing well on both dimensions",
+        "D": "The embedding model is producing high-quality vectors but the LLM is too verbose"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "High faithfulness (0.92) means the LLM is accurately grounding its answers in the retrieved context — it is not hallucinating. Low answer_relevance (0.55) means the retrieved context (and therefore the answers) often does not address the user's actual question. This is a retrieval recall problem: the right documents are not being retrieved. The fix is improving the retrieval step (better embedding model, more context, different chunking).",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q005",
+      "domain": "design-rag-solutions",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "A team builds a RAG pipeline for customer support. They want to ensure that answers cite the specific support article used. Which approach enables citation generation?",
+      "choices": {
+        "A": "Set the LLM temperature to 0 for deterministic citation formatting",
+        "B": "Store source document metadata (article ID, title, URL) alongside embeddings; include metadata in the prompt context and instruct the LLM to cite sources",
+        "C": "Use an LLM with more parameters — larger models automatically cite sources",
+        "D": "Fine-tune the LLM to always include citations by training on examples with citations"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Citation generation requires: (1) storing source metadata with embeddings, (2) returning it with results, (3) including it in the LLM prompt, and (4) instructing the LLM to cite sources. Larger models do not auto-cite; fine-tuning helps format but not sourcing; temperature affects randomness, not citations.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q006",
+      "domain": "design-rag-solutions",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "A developer is building a code assistant that answers questions about a large private codebase. The codebase uses non-standard variable names and internal library APIs. Which approach provides the MOST accurate retrieval of relevant code snippets?",
+      "choices": {
+        "A": "Use a general-purpose text embedding model like `databricks-bge-large-en`",
+        "B": "Use a code-specific embedding model (e.g., `code-search-ada-002` or similar) tuned on code retrieval tasks",
+        "C": "Use keyword search (BM25) only — code is too structured for semantic embeddings",
+        "D": "Index only function docstrings, not code bodies"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Code-specific embedding models are trained on code corpora and understand programming language semantics, variable naming patterns, and API relationships better than general text models. BM25-only retrieval misses semantic code relationships (e.g., synonymous implementations). Indexing only docstrings discards the actual code logic that may be most relevant for implementation questions.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q007",
+      "domain": "design-rag-solutions",
+      "title": "Question 7",
+      "difficulty": "hard",
+      "question": "A developer implements multi-query retrieval for their RAG pipeline. The LLM generates 5 query variants, each retrieving top-5 results. After deduplication, 18 unique chunks remain. How many chunks should be passed to the final LLM generation step?",
+      "choices": {
+        "A": "All 18 chunks — more context is always better",
+        "B": "A reranked subset of 3–5 chunks — apply a reranker to the 18 candidates and select the most relevant ones",
+        "C": "The original 5 top-ranked chunks from the first query variant only",
+        "D": "1 chunk — select the single highest-scoring chunk across all 5 queries"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-query retrieval's goal is to improve recall (not to pass all retrieved chunks to the LLM). After deduplication, a reranker should score all 18 candidates and select the top 3–5 most relevant for the final generation step. Passing all 18 chunks consumes excessive context window tokens and introduces noise. Using only the first query's results defeats the purpose of multi-query retrieval.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q008",
+      "domain": "design-rag-solutions",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "A financial services RAG pipeline retrieves SEC filings. The team observes that questions about a specific company's 2023 filing sometimes retrieve documents from 2021 or 2022. How can the retrieval be constrained to specific fiscal years?",
+      "choices": {
+        "A": "Ask the LLM to only reference the most recent documents in the retrieved context",
+        "B": "Add `year` and `company` metadata to indexed documents and use metadata pre-filtering in the similarity search query",
+        "C": "Create a separate vector index for each fiscal year and route queries based on year keyword detection",
+        "D": "Use a larger embedding model to better distinguish documents from different years"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Metadata pre-filtering is correct: store `year` and `company` fields alongside embeddings, then filter in the similarity search call. LLM-side filtering is unreliable, separate per-year indexes add operational overhead, and embedding model size does not help temporal discrimination.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q009",
+      "domain": "design-rag-solutions",
+      "title": "Question 9",
+      "difficulty": "hard",
+      "question": "A developer builds a RAG pipeline where each query retrieves 5 chunks. The evaluation shows that the correct answer is almost always fully contained within the retrieved chunks, yet the LLM still produces incorrect answers. What is the MOST likely root cause?",
+      "choices": {
+        "A": "The embedding model is poorly calibrated",
+        "B": "The LLM is not extracting the correct information from the context — the problem is in the generation step, not retrieval",
+        "C": "The chunk overlap is too large, causing duplicate content confusion",
+        "D": "The vector index needs to be rebuilt with a smaller dimensionality"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When retrieval is confirmed good (answer is in retrieved chunks) but generation is wrong, the problem is in the generation step. Common causes: noisy context burying the answer, or poor prompt instructions. The fix is prompt engineering or context compression — not retrieval-side changes.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q010",
+      "domain": "design-rag-solutions",
+      "title": "Question 10",
+      "difficulty": "hard",
+      "question": "A developer implements a RAG pipeline where answers must be attributed to specific sentences (not just document chunks). Which architecture modification enables sentence-level attribution?",
+      "choices": {
+        "A": "Reduce chunk size to 1 sentence",
+        "B": "Index full document chunks but store sentence-level offsets in metadata; after retrieval, highlight which sentence(s) the LLM referenced using answer span extraction",
+        "C": "Use a cross-encoder reranker to identify the most relevant sentence",
+        "D": "Post-process the LLM output with an NLP library to identify quoted sentences"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Sentence-level attribution requires storing positional metadata (sentence offsets) for each chunk. After retrieval and generation, a span extraction step identifies which specific sentences in the retrieved chunks support the answer. Chunking at the sentence level (option A) fragments context and reduces retrieval quality. Cross-encoder reranking improves precision but does not automatically produce sentence-level attribution.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q011",
+      "domain": "design-rag-solutions",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "A team discovers that their RAG pipeline's answers degrade significantly on questions that require reasoning across information from multiple documents (e.g., \"Compare the safety profiles of Drug A and Drug B\"). Which approach BEST addresses multi-document reasoning?",
+      "choices": {
+        "A": "Increase the embedding model dimensionality",
+        "B": "Use a larger top-k (e.g., k=20) to ensure both documents are retrieved, and instruct the LLM to synthesize information across retrieved chunks",
+        "C": "Reduce chunk size to 64 tokens to retrieve more granular information",
+        "D": "Switch from RAG to a fine-tuned model"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-document reasoning requires that the relevant documents for all compared entities (Drug A and Drug B) are retrieved. Increasing k improves the likelihood that both are retrieved. Explicit prompting instructs the LLM to synthesize across retrieved chunks rather than answering from a single source. Smaller chunk sizes increase granularity but may hurt cross-document reasoning by fragmenting context. Fine-tuning does not help with dynamic comparisons of specific documents.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q012",
+      "domain": "design-rag-solutions",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "A RAG pipeline uses `answer_relevance` as its primary optimization metric. The team achieves `answer_relevance=0.95` but the legal team raises concerns that the chatbot is confidently providing answers that contradict source documents. Which metric should be added to catch this failure mode?",
+      "choices": {
+        "A": "`toxicity` — detects harmful language in answers",
+        "B": "`faithfulness` — measures whether answers are grounded in retrieved context",
+        "C": "`precision@k` — ensures retrieved documents are relevant",
+        "D": "`perplexity` — measures linguistic fluency"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`faithfulness` (groundedness) directly measures whether the LLM's answers are supported by the retrieved documents. High `answer_relevance` means the questions are addressed, but without `faithfulness`, the LLM may generate plausible-sounding answers that contradict or add to the source material. For legal and compliance use cases, `faithfulness` is the most critical metric. `toxicity` detects harmful language, not factual errors. `precision@k` is a retrieval metric.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q013",
+      "domain": "design-rag-solutions",
+      "title": "Question 13",
+      "difficulty": "medium",
+      "question": "A developer's RAG pipeline works well for exact-match questions (e.g., \"What is our return policy?\") but struggles with paraphrased versions (e.g., \"Can I get my money back?\"). Which technique MOST improves retrieval for paraphrased queries?",
+      "choices": {
+        "A": "Add exact-phrase matching using BM25 alongside dense retrieval (hybrid search)",
+        "B": "Use multi-query retrieval — generate paraphrases of the user query before embedding",
+        "C": "Reduce the chunk size to improve retrieval granularity",
+        "D": "Switch the similarity metric from cosine to dot product"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Multi-query retrieval generates multiple paraphrases of the original query, improving the chance that at least one variant closely matches the embedding of the relevant document. This is particularly effective for the paraphrase coverage problem. Hybrid search adds sparse retrieval which excels at exact terms — it helps the opposite case (exact terms that are semantically distant). Chunk size and similarity metric do not address the paraphrase coverage gap.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q014",
+      "domain": "design-rag-solutions",
+      "title": "Question 14",
+      "difficulty": "hard",
+      "question": "A production RAG pipeline has `faithfulness=0.88` and `answer_relevance=0.82` on evaluation. The team wants to improve both metrics. Which is the CORRECT priority order to investigate?",
+      "choices": {
+        "A": "Improve faithfulness first (generation quality), then answer_relevance (retrieval quality)",
+        "B": "Improve answer_relevance first (retrieval quality), then faithfulness (generation quality) — retrieval quality is the foundation",
+        "C": "Optimize both simultaneously by retraining the embedding model",
+        "D": "These metrics cannot be optimized independently — only full system retraining helps"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Retrieval quality is the foundation of RAG. If the wrong documents are retrieved (low answer_relevance foundation), improving generation quality (faithfulness) provides limited gains because the LLM is working with suboptimal context. Fix retrieval first (embedding model, chunking, metadata filtering), then optimize generation (prompting, context ordering, chain type). They can be improved independently through different components of the pipeline.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q016",
+      "domain": "vector-search-embeddings",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "A developer has a Direct Access Index and wants to update embedding for product ID `\"prod-123\"` with a new description. Which approach is CORRECT?",
+      "choices": {
+        "A": "Delete `\"prod-123\"` from the index and insert it again as a new record",
+        "B": "Call `index.upsert()` with the new embedding data for `\"prod-123\"` — upsert handles both inserts and updates",
+        "C": "Rebuild the entire index from scratch with the updated embedding",
+        "D": "Call `index.update(id=\"prod-123\", embedding=new_vector)` to update in place"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`index.upsert()` handles both inserts (new IDs) and updates (existing IDs) in a single operation. If `\"prod-123\"` already exists, its embedding is replaced. Deleting and re-inserting is functionally correct but unnecessarily complex. Rebuilding the entire index is extremely inefficient. `index.update()` is not a valid Databricks Vector Search SDK method.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q017",
+      "domain": "vector-search-embeddings",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "A team indexes 2 million documents for a RAG pipeline on Databricks. They notice that new documents added to the source Delta table take over 30 minutes to appear in the index. How can they reduce the synchronization lag?",
+      "choices": {
+        "A": "Rebuild the index from scratch with a higher replication factor",
+        "B": "Switch from `pipeline_type=\"TRIGGERED\"` to `pipeline_type=\"CONTINUOUS\"` to enable automatic incremental syncing",
+        "C": "Reduce the vector dimensionality to speed up indexing",
+        "D": "Increase the number of Vector Search endpoints"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`pipeline_type=\"TRIGGERED\"` requires manual sync initiation, which causes delays. Switching to `pipeline_type=\"CONTINUOUS\"` enables automatic, low-latency incremental syncing whenever the Delta table changes. The 30-minute lag is consistent with manual-batch sync behavior. Vector dimensionality and endpoint count do not affect sync latency. Increasing replication improves query throughput, not sync speed.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q018",
+      "domain": "vector-search-embeddings",
+      "title": "Question 18",
+      "difficulty": "hard",
+      "question": "A team stores customer reviews as embeddings in a Vector Search index with metadata columns: `rating` (integer 1–5), `product_category` (string), and `verified_purchase` (boolean). A developer wants to find reviews most similar to \"excellent battery life\" where rating >= 4 AND verified_purchase = true. Which filter dictionary is CORRECT?",
+      "choices": {
+        "A": "`filters={\"rating\": \">=4\", \"verified_purchase\": \"true\"}`",
+        "B": "`filters={\"rating\": {\"$gte\": 4}, \"verified_purchase\": True}`",
+        "C": "`filters=\"rating >= 4 AND verified_purchase = true\"`",
+        "D": "`filters=[(\"rating\", \">=\", 4), (\"verified_purchase\", \"=\", True)]`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Vector Search uses MongoDB-style filter operators: `{\"field\": {\"$gte\": value}}` for numeric comparisons. Boolean values use Python `True`/`False`. Multiple conditions are separate keys in the filter dictionary. SQL strings and list-of-tuples formats are not valid SDK filter formats.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q019",
+      "domain": "vector-search-embeddings",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "A developer wants to use Databricks-hosted embeddings with their Delta Sync Index instead of self-managed embeddings. What must be specified during index creation to enable this?",
+      "choices": {
+        "A": "`embedding_source_column` — the name of the text column to embed",
+        "B": "`embedding_vector_column` — the column containing pre-computed vectors",
+        "C": "`embedding_model` — the specific embedding model URI",
+        "D": "Both `embedding_source_column` AND the hosted embedding model endpoint name"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "To use Databricks-hosted embeddings with a Delta Sync Index, you specify: (1) `embedding_source_column` — the text column that should be embedded automatically, and (2) the embedding model endpoint (e.g., `embedding_model_endpoint_name=\"databricks-bge-large-en\"`). This tells Databricks to automatically compute embeddings from the source text column at sync time. If using self-managed embeddings, you specify `embedding_vector_column` instead.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q020",
+      "domain": "vector-search-embeddings",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "A developer wants to store both the primary article text and a separate summary field in their Vector Search index, enabling queries to match either field. What is the CORRECT approach?",
+      "choices": {
+        "A": "Create two separate Vector Search indexes — one for full text, one for summaries",
+        "B": "Create one index that embeds the summary; store the full text as a metadata column returned with results",
+        "C": "Concatenate summary and full text into a single field before embedding",
+        "D": "Use two separate query calls and merge results in Python"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The most common approach is to embed the summary (which is more query-representative) and store the full article text as a metadata column. Retrieval is based on summary similarity, but the LLM receives the full text for generation. Two separate indexes require two queries and result merging. Concatenating long text + summary before embedding dilutes the embedding quality and may exceed the model's token limit.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q021",
+      "domain": "vector-search-embeddings",
+      "title": "Question 21",
+      "difficulty": "hard",
+      "question": "A team's Vector Search index was created 3 months ago. The source Delta table is unchanged but retrieval quality has degraded over time as the query distribution evolved. What is the MOST appropriate action?",
+      "choices": {
+        "A": "Rebuild the index using a newer or more domain-adapted embedding model",
+        "B": "Switch from COSINE to L2 similarity metric",
+        "C": "Increase the `num_results` parameter to retrieve more candidates",
+        "D": "Add more worker nodes to the Vector Search endpoint"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "If query patterns have evolved and the embedding model is no longer well-aligned with how users ask questions, rebuilding with a newer or domain-adapted embedding model is the correct solution. Similarity metric changes and parameter tuning offer marginal improvements. Adding endpoint workers improves throughput and latency, not retrieval quality. The fundamental issue is model-query-document alignment.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q022",
+      "domain": "vector-search-embeddings",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "A developer has a Vector Search index with 500,000 documents. They need to delete all documents where `status = \"archived\"` (approximately 50,000 documents). Which is the MOST efficient approach?",
+      "choices": {
+        "A": "Query for all archived document IDs, then call `index.delete(ids=[...])` in batches",
+        "B": "Drop and recreate the entire index from the source Delta table with archived records already removed",
+        "C": "Mark documents as `status = \"inactive\"` and filter them out at query time using metadata filters",
+        "D": "Use `index.upsert()` to overwrite archived documents with empty embedding vectors"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "For a Direct Access Index, deleting by ID in batches is the correct approach. For a Delta Sync Index, deleting from the source Delta table and letting sync propagate the deletions is equivalent. Option C (query-time filtering) is a valid workaround but does not remove the documents from the index (wastes storage and compute). Option B is efficient only for a complete rebuild; for 10% deletions, batch delete is faster. Empty embeddings are not semantically meaningful.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q023",
+      "domain": "vector-search-embeddings",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "A developer notices that querying their Vector Search index with `num_results=100` takes 3x longer than with `num_results=10`. Which statement BEST explains this behavior?",
+      "choices": {
+        "A": "Larger `num_results` requires reading more data from Delta Lake storage",
+        "B": "Larger `num_results` requires the ANN algorithm to explore more of the graph structure to find additional neighbors",
+        "C": "The Vector Search endpoint has insufficient CPU cores to handle large result sets",
+        "D": "The `num_results` parameter directly controls the number of similarity computations performed"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "ANN algorithms like HNSW search a graph structure. Returning more results requires exploring more nodes and edges, increasing computation proportionally. CPU core count affects throughput at fixed `num_results`, not this scaling relationship. ANN does not perform exhaustive computation over all documents regardless of k.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q024",
+      "domain": "vector-search-embeddings",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "A developer creates an embedding with `databricks-gte-large-en` and queries the index with a French-language question, even though all indexed documents are in English. What is the MOST likely result?",
+      "choices": {
+        "A": "The query fails because `databricks-gte-large-en` only accepts English input",
+        "B": "The query returns relevant English documents if `databricks-gte-large-en` supports multilingual embeddings; otherwise results will be poor",
+        "C": "Databricks Vector Search automatically translates the French query to English before embedding",
+        "D": "The query returns documents with the highest token overlap with the French query terms"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Whether cross-lingual retrieval works depends entirely on whether the embedding model was trained on multilingual data. Some embedding models (e.g., multilingual-e5) support cross-lingual retrieval; others (English-only models) do not. `databricks-gte-large-en` is primarily an English model; cross-lingual retrieval quality would be poor. Databricks Vector Search does not perform automatic translation. There is no token overlap matching — Vector Search is purely vector-based.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q025",
+      "domain": "vector-search-embeddings",
+      "title": "Question 25",
+      "difficulty": "medium",
+      "question": "A team uses a Delta Sync Index with `pipeline_type=\"CONTINUOUS\"`. They truncate and reload the source Delta table with 500,000 new rows (replacing the original 500,000 rows). What happens to the Vector Search index?",
+      "choices": {
+        "A": "The index retains the old embeddings and only adds the 500,000 new documents",
+        "B": "The continuous sync detects the deletions and insertions, updating the index to reflect the new table state",
+        "C": "The index becomes corrupted and must be manually rebuilt",
+        "D": "Continuous mode only processes incremental additions; truncation requires switching to Triggered mode"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A `CONTINUOUS` Delta Sync Index uses Delta Lake's change data feed to track all operations (inserts, updates, deletes). A truncate-and-reload generates deletion records for old rows and insertion records for new rows. The sync processes both automatically, resulting in an index matching the new table state.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q026",
+      "domain": "llm-application-development",
+      "title": "Question 26",
+      "difficulty": "hard",
+      "question": "A developer uses few-shot prompting with 10 examples in the system prompt. The LLM starts ignoring the format demonstrated in the examples for complex inputs. Which intervention is MOST likely to help?",
+      "choices": {
+        "A": "Increase the number of few-shot examples to 50",
+        "B": "Move the few-shot examples closer to the end of the system prompt (nearer to the user input) to leverage recency bias",
+        "C": "Switch from few-shot to zero-shot prompting",
+        "D": "Reduce the system prompt to only the most critical instruction"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "LLMs exhibit recency bias — content near the end of the context has more influence on output format. Moving examples closer to the user's input increases formatting adherence. Adding more examples increases context but doesn't fix position-based influence. Zero-shot removes demonstrations entirely.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q027",
+      "domain": "llm-application-development",
+      "title": "Question 27",
+      "difficulty": "hard",
+      "question": "A developer builds a LangChain agent for a travel booking system. The agent has three tools: `search_flights`, `search_hotels`, `book_trip`. A user asks \"Find me flight options to Paris next week?\" The agent incorrectly calls `book_trip` instead of `search_flights`. What is the MOST likely root cause?",
+      "choices": {
+        "A": "The `book_trip` tool's description is too similar to `search_flights`, causing the LLM to conflate them",
+        "B": "The LLM's temperature is set too high, causing random tool selection",
+        "C": "The agent is missing a `max_iterations` limit",
+        "D": "The user's query is too short for the LLM to parse intent"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "LangChain Agents use tool names and descriptions to select the appropriate tool. If `book_trip` has an ambiguous description (e.g., \"Handles all travel-related requests\"), the LLM may select it for queries that should route to `search_flights`. The fix is to write clear, distinct, non-overlapping tool descriptions that explicitly state what each tool does and does NOT do. Temperature affects randomness but not systematic misrouting. `max_iterations` prevents infinite loops, not misrouting.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q028",
+      "domain": "llm-application-development",
+      "title": "Question 28",
+      "difficulty": "easy",
+      "question": "A developer builds a chatbot that supports both English and Spanish. The system prompt is in English. A user writes in Spanish. The LLM responds in English. How can the developer reliably ensure the LLM responds in the user's language?",
+      "choices": {
+        "A": "Train a language detection classifier to preprocess inputs and route to language-specific prompts",
+        "B": "Add an instruction to the system prompt: \"Always respond in the same language as the user's message\"",
+        "C": "Deploy separate endpoints for English and Spanish users",
+        "D": "Set `language=\"auto\"` in the Foundation Model API call"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Adding a language mirroring instruction to the system prompt (\"always respond in the same language the user writes in\") is the simplest and most effective solution for modern instruction-following LLMs. Separate language-specific prompts add operational complexity. A preprocessing classifier adds latency and another failure mode. There is no `language=\"auto\"` parameter in Foundation Model APIs.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q029",
+      "domain": "llm-application-development",
+      "title": "Question 29",
+      "difficulty": "medium",
+      "question": "A developer logs a RAG chain with `mlflow.langchain.log_model(chain, \"rag-chain\", input_example={\"query\": \"What is RAG?\"})`. What is the PRIMARY benefit of providing `input_example`?",
+      "choices": {
+        "A": "It enables the model to be tested during the logging call",
+        "B": "It is used to infer and record the model's input/output schema (signature), enabling better validation at serving time",
+        "C": "It stores a sample query in the model artifact for documentation purposes only",
+        "D": "It pre-warms the model's cache for faster first-query response at serving time"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`input_example` is used by MLflow to infer the model's signature (input and output schema). The inferred signature is stored with the model artifact and used by Model Serving to validate input formats at serving time, providing clearer error messages for malformed requests. It does not execute the model during logging. It is not purely for documentation — the signature has functional impact on serving validation.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q030",
+      "domain": "llm-application-development",
+      "title": "Question 30",
+      "difficulty": "hard",
+      "question": "A developer is building a RAG pipeline and must choose between `chain_type=\"stuff\"` and `chain_type=\"map_reduce\"` in LangChain's `RetrievalQA`. Their typical query retrieves 10 chunks of 512 tokens each (5120 tokens total). The LLM has a 4096-token context window. Which chain type is REQUIRED?",
+      "choices": {
+        "A": "`\"stuff\"` — concatenate all retrieved chunks into one LLM call",
+        "B": "`\"map_reduce\"` — process each chunk independently, then reduce",
+        "C": "`\"refine\"` — iteratively refine the answer",
+        "D": "Either `\"stuff\"` or `\"map_reduce\"` — both fit within the context window"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "With 10 chunks × 512 tokens = 5120 tokens of retrieved context, plus the system prompt and question, the total exceeds a 4096-token context window. `\"stuff\"` requires all content in a single prompt, which would fail. `\"map_reduce\"` processes each chunk in a separate LLM call (map phase), then combines the intermediate answers (reduce phase), fitting within the context window. `\"refine\"` is another option for long contexts but processes chunks sequentially.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q031",
+      "domain": "llm-application-development",
+      "title": "Question 31",
+      "difficulty": "hard",
+      "question": "A developer wants to ensure that every LangChain chain call logs a custom metadata field `session_id` to MLflow for request tracing. Which approach is MOST appropriate?",
+      "choices": {
+        "A": "Call `mlflow.set_tag(\"session_id\", value)` before each chain invocation",
+        "B": "Use a custom `MLflowCallbackHandler` to log the session_id tag during chain execution",
+        "C": "Add `session_id` as an extra key to the chain's input dictionary",
+        "D": "Set `MLFLOW_RUN_ID` environment variable to the session_id value"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A custom `BaseCallbackHandler` (or `MLflowCallbackHandler`) can be passed as a callback to chain invocations to log custom metadata during execution. Callbacks have access to the run context and can call `mlflow.set_tag()` at the appropriate lifecycle events. `mlflow.set_tag()` called before the chain runs works if inside an active run context, but a callback is the more robust pattern for per-invocation tracing. Adding `session_id` to the input dict changes the chain's input schema.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q032",
+      "domain": "llm-application-development",
+      "title": "Question 32",
+      "difficulty": "hard",
+      "question": "A developer uses a LangChain `RetrievalQA` chain and after debugging finds that the quality of answers depends heavily on the ORDER in which retrieved chunks are placed in the prompt. Specifically, the most relevant chunk in the middle of the context produces worse answers than when placed first. What does this represent?",
+      "choices": {
+        "A": "A vector index configuration problem",
+        "B": "The \"lost in the middle\" problem — LLMs attend less to content in the middle of long contexts",
+        "C": "An embedding model dimension mismatch",
+        "D": "A temperature calibration issue"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The \"lost in the middle\" phenomenon is well-documented: LLMs tend to attend most strongly to content at the beginning and end of long contexts, and content in the middle is sometimes underweighted. The fix is to place the most relevant retrieved chunks at the beginning or end of the context, not in the middle. This is a context ordering strategy, not an indexing or model configuration issue.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q033",
+      "domain": "llm-application-development",
+      "title": "Question 33",
+      "difficulty": "medium",
+      "question": "A developer calls an external weather API from within a LangChain agent tool. The API occasionally returns HTTP 429 (rate limit exceeded) errors. How should the tool handle this?",
+      "choices": {
+        "A": "Let the exception propagate to the agent — the LLM will automatically retry",
+        "B": "Implement exponential backoff retry logic within the tool function; return an informative message to the LLM if retries are exhausted",
+        "C": "Set a very long timeout on the API call to avoid the error",
+        "D": "Cache all weather API responses forever to avoid repeated calls"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Tool functions should implement robust error handling including retry logic with exponential backoff for transient errors like rate limits. If retries are exhausted, the tool should return a descriptive error message to the LLM so it can communicate the failure to the user gracefully. LangChain agents do not automatically retry failed tool calls. Long timeouts do not prevent rate limit errors. Caching weather data forever would return stale results.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q034",
+      "domain": "llm-application-development",
+      "title": "Question 34",
+      "difficulty": "hard",
+      "question": "A developer evaluates their RAG pipeline using `mlflow.evaluate()`. The evaluation dataset has 200 rows but `mlflow.evaluate()` completes in 5 seconds — suspiciously fast for LLM-judge metrics. What is the MOST likely explanation?",
+      "choices": {
+        "A": "The evaluation is running on GPU hardware",
+        "B": "The evaluation used cached results from a previous run",
+        "C": "The LLM-judge metrics were not correctly specified and fell back to non-LLM metrics only",
+        "D": "The model's predict function is returning cached responses"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "LLM-as-judge metrics require calling an LLM for each evaluation row, which takes several seconds per row — at least several minutes for 200 rows. If `mlflow.evaluate()` completes in 5 seconds, it likely ran only non-LLM metrics (e.g., exact match, string similarity), meaning the LLM-judge metrics were not correctly configured or the `extra_metrics` parameter was not properly specified. Check the logged metrics to confirm whether faithfulness, answer_relevance, etc. appear.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q035",
+      "domain": "llm-application-development",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "An organization deploys a RAG chatbot for internal employees. They use `ConversationSummaryMemory` to maintain context across a long session. After 30 turns, a user asks about a topic mentioned in turn 3. Which problem is MOST likely to occur?",
+      "choices": {
+        "A": "The chain raises an out-of-memory error",
+        "B": "Specific details from turn 3 may have been lost in summarization and the LLM cannot recall them accurately",
+        "C": "The LLM generates an error because the summary exceeds the context window",
+        "D": "The embedding model re-indexes the conversation history automatically"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ConversationSummaryMemory` compresses history into summaries. Specific details and precise wording from early turns (like turn 3) are often lost. The LLM may recall the general topic but not exact facts. For precise recall, `ConversationBufferMemory` or vector-based memory is more appropriate.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q036",
+      "domain": "llm-application-development",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "A developer builds a multi-step LangChain pipeline where Step 1 generates search queries and Step 2 retrieves documents using those queries. The developer wants each step's outputs to be logged separately to MLflow for debugging. Which approach enables this?",
+      "choices": {
+        "A": "Call `mlflow.log_param()` after each step with the step output",
+        "B": "Use `mlflow.langchain.autolog()` with `log_traces=True` to capture each chain step as a trace span",
+        "C": "Log two separate MLflow runs — one per step",
+        "D": "Use `mlflow.set_tag(\"step1_output\", ...)` to store intermediate results"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.langchain.autolog(log_traces=True)` enables MLflow Tracing, which captures each chain step as a separate trace span with its inputs and outputs. This provides full observability into multi-step pipelines without modifying chain code. Separate runs break the logical grouping of the pipeline. `log_param` is for configuration values, not structured trace data. Tags are string key-value pairs, not suitable for structured intermediate outputs.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q038",
+      "domain": "llm-application-development",
+      "title": "Question 38",
+      "difficulty": "medium",
+      "question": "A developer wants to compare two RAG prompting strategies across 50 test questions using MLflow. Strategy A uses a concise system prompt; Strategy B uses a detailed, multi-paragraph system prompt. What is the CORRECT MLflow pattern?",
+      "choices": {
+        "A": "Log both strategies as tags on a single run, then compare within that run",
+        "B": "Create two separate MLflow runs (one per strategy) within the same experiment, evaluating with `mlflow.evaluate()` per run, then compare runs in the experiment UI",
+        "C": "Create two separate experiments, one per strategy",
+        "D": "Log the strategies as model versions in the Model Registry and compare their evaluation metrics"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Each strategy should be a separate MLflow run within the same experiment, with `mlflow.evaluate()` logging standardized metrics (faithfulness, answer_relevance, etc.) for each. The experiment comparison UI then enables direct side-by-side metric comparison. Separate experiments cannot be directly compared in the MLflow UI. Logging both strategies as tags in one run conflates results. Model Registry is for versioning deployable models, not for A/B strategy comparison.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q039",
+      "domain": "databricks-genai-tools",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A developer calls the `databricks-meta-llama-3-1-70b-instruct` endpoint using the OpenAI Python client pointed at the Databricks host. The call succeeds during development but fails in production with a 401 Unauthorized error. What is the MOST likely cause?",
+      "choices": {
+        "A": "The model name is incorrect for the Databricks endpoint",
+        "B": "The production environment is using an expired or missing Databricks authentication token",
+        "C": "The endpoint does not support the OpenAI client library",
+        "D": "The model is not available in the production workspace region"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Foundation Model APIs require authentication via a Databricks PAT (personal access token) or service principal OAuth token. A 401 Unauthorized error indicates missing or expired credentials. In production, the OpenAI client `api_key` parameter must be set to a valid Databricks token. Databricks Foundation Model endpoints are OpenAI-compatible and support the OpenAI client. Endpoint name and regional availability issues produce different error codes.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q040",
+      "domain": "databricks-genai-tools",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "A team deploys a LangChain RAG chain to a Databricks Model Serving endpoint. Endpoint logs show frequent cold start latencies of 60–90 seconds for the first request after idle periods. What is the MOST appropriate solution for a customer-facing production app?",
+      "choices": {
+        "A": "Switch to a Provisioned Throughput endpoint which does not scale to zero",
+        "B": "Increase the number of tokens in the LLM's context window",
+        "C": "Rebuild the vector index with a smaller embedding dimension",
+        "D": "Reduce the LangChain chain complexity by removing the reranker"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Model Serving endpoints can scale to zero when idle, causing cold start latency when traffic resumes. Provisioned Throughput endpoints maintain minimum replicas (do not scale to zero), eliminating cold start delays. This is the standard solution for latency-sensitive production applications. Context window size, vector dimensionality, and chain complexity are not related to cold start latency.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q041",
+      "domain": "databricks-genai-tools",
+      "title": "Question 41",
+      "difficulty": "hard",
+      "question": "A team wants to monitor their deployed RAG chatbot for data drift — specifically detecting when user query topics shift significantly from the training distribution. What is the CORRECT Databricks approach?",
+      "choices": {
+        "A": "Use Databricks Lakehouse Monitoring on the inference table with a `TimeSeries` monitor to detect query distribution drift over time",
+        "B": "Create an MLflow experiment alert that fires when `faithfulness` drops below 0.80",
+        "C": "Enable Vector Search index auto-refresh to detect new query patterns",
+        "D": "Use a Databricks Job to compute cosine similarity between new queries and training queries weekly"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Inference tables log all requests and responses to a Delta table. Databricks Lakehouse Monitoring with a `TimeSeries` monitor can detect statistical drift in the query (input) distribution over time using metrics like population stability index (PSI). This is the purpose-built Databricks solution for serving-time data drift monitoring. MLflow alerts are not a real-time monitoring mechanism. Vector Search index refresh and manual similarity computation are not drift monitoring solutions.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q042",
+      "domain": "databricks-genai-tools",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "An engineer needs to enable multiple teams to call the same Foundation Model endpoint with different rate limits per team. Which Databricks component provides this capability?",
+      "choices": {
+        "A": "Cluster policies — limit compute per team",
+        "B": "Unity Catalog permissions — restrict endpoint access per team",
+        "C": "MLflow AI Gateway — configure per-route rate limits for different teams or API keys",
+        "D": "Databricks Secrets — store per-team API keys with different expiration times"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "MLflow AI Gateway supports per-route configuration including rate limits (requests per minute, tokens per minute). Routes can be configured for different teams or use cases, each with their own rate limit policies. Cluster policies govern cluster configuration, not LLM API access. Unity Catalog governs data and model access but not per-team LLM rate limits. Secrets store credentials but do not implement rate limiting.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q044",
+      "domain": "databricks-genai-tools",
+      "title": "Question 44",
+      "difficulty": "hard",
+      "question": "A developer deployed a RAG chain to Model Serving and enabled inference tables. They query the inference table and see rows where `response` is `null` and `status_code` is `500`. What does this indicate and how should it be investigated?",
+      "choices": {
+        "A": "The endpoint returned HTTP 200 but the response body was empty",
+        "B": "The endpoint encountered internal errors (server-side failures) for those requests — examine endpoint logs for stack traces",
+        "C": "The inference table schema is misconfigured",
+        "D": "The client sent malformed requests with null payloads"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "HTTP 500 status codes indicate server-side errors in the model serving endpoint. The inference table correctly records the status code alongside the null response for failed requests. To diagnose, examine the Model Serving endpoint logs (accessible via the endpoint events tab in the Databricks UI or via REST API) for exception messages and stack traces. This could indicate issues with the chain code, dependency failures (e.g., Vector Search connectivity), or resource exhaustion.",
+      "explanation": ""
+    },
+    {
+      "id": "genai-engineer-associate-mock-2-q045",
+      "domain": "databricks-genai-tools",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "A team is deciding between MLflow AI Gateway and direct Foundation Model API calls for their multi-team organization. Which scenario makes MLflow AI Gateway the CLEARLY better choice?",
+      "choices": {
+        "A": "Sample N recent rows from the Inference Table into a Spark DataFrame; run `mlflow.evaluate(data=sample, model_type=\"databricks-agent\")` so the built-in Databricks RAG judges (groundedness, relevance, correctness, safety) score the sample; schedule via a Lakeflow Job",
+        "B": "Manually read 100 random conversations every week",
+        "C": "Compute a groundedness score with a regex over the response text",
+        "D": "Train a custom classifier on production data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "MLflow AI Gateway adds the most value in multi-team, multi-provider scenarios where centralized credential management, unified API abstraction, and per-team rate limiting are needed. A single data scientist in a notebook has no need for the gateway's organizational features. Batch jobs benefit from direct API calls (no gateway overhead). The gateway adds a network hop that increases latency — direct API calls are faster for single-endpoint, latency-critical applications.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "genai-engineer-associate"
+}
diff --git a/practice/data/genai-engineer-associate.json b/practice/data/genai-engineer-associate.json
index 91ea7fd..e4206e6 100644
--- a/practice/data/genai-engineer-associate.json
+++ b/practice/data/genai-engineer-associate.json
@@ -2,7 +2,7 @@
   "cert": "genai-engineer-associate",
   "certTitle": "GenAI Engineer Associate",
   "blueprintVersion": "Mar 2026",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "rag-architecture",
diff --git a/practice/data/ml-associate-mock-1.json b/practice/data/ml-associate-mock-1.json
new file mode 100644
index 0000000..2bb071b
--- /dev/null
+++ b/practice/data/ml-associate-mock-1.json
@@ -0,0 +1,724 @@
+{
+  "cert": "ml-associate-mock-1",
+  "certTitle": "ML Associate — Mock Exam 1",
+  "blueprintVersion": "Mar 1, 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-ml",
+      "name": "Databricks ML",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "ml-workflows",
+      "name": "ML Workflows",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "feature-engineering",
+      "name": "Feature Engineering",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam/questions.md",
+      "questionCount": 15
+    },
+    {
+      "id": "mlflow-deployment",
+      "name": "MLflow Deployment",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam/questions.md",
+      "questionCount": 2
+    }
+  ],
+  "questions": [
+    {
+      "id": "ml-associate-mock-1-q001",
+      "domain": "databricks-ml",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "Which pre-installed library distinguishes Databricks Runtime for Machine Learning from the standard Databricks Runtime?",
+      "choices": {
+        "A": "Apache Spark",
+        "B": "Delta Lake connector",
+        "C": "MLflow",
+        "D": "JDBC driver"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Runtime for ML pre-installs ML-specific libraries including MLflow, TensorFlow, PyTorch, and scikit-learn. Apache Spark and Delta Lake are included in the standard runtime. JDBC drivers are available in both runtimes.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q002",
+      "domain": "databricks-ml",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A data scientist is prototyping a model using pandas and scikit-learn on a 200 MB dataset. Which cluster type minimizes cost while supporting this workload?",
+      "choices": {
+        "A": "Multi-node cluster with 2 workers",
+        "B": "Single-node cluster",
+        "C": "High-concurrency cluster",
+        "D": "GPU-enabled multi-node cluster"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "A single-node cluster is optimal for pandas and scikit-learn workloads because these libraries do not distribute across Spark workers. Adding worker nodes increases cost without improving performance for non-distributed workloads.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q003",
+      "domain": "databricks-ml",
+      "title": "Question 3",
+      "difficulty": "easy",
+      "question": "What does Databricks AutoML produce after completing a classification experiment?",
+      "choices": {
+        "A": "A single deployable model binary",
+        "B": "An MLflow experiment with one run per algorithm trial, plus a generated best-model notebook",
+        "C": "A Delta table of feature importances",
+        "D": "A REST endpoint ready for production traffic"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "AutoML creates an MLflow experiment and logs each algorithm trial as a separate run. It also generates an editable Python notebook for the best-performing model that the data scientist can customize. It does not automatically deploy the model or create Delta tables.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q004",
+      "domain": "databricks-ml",
+      "title": "Question 4",
+      "difficulty": "easy",
+      "question": "A data scientist wants to use AutoML to forecast future sales. Which AutoML task type should they select?",
+      "choices": {
+        "A": "Regression",
+        "B": "Classification",
+        "C": "Forecasting",
+        "D": "Time Series"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks AutoML supports three task types: classification, regression, and forecasting. Forecasting is specifically designed for time-series prediction problems. \"Time Series\" is not a separate AutoML task type.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q005",
+      "domain": "databricks-ml",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "An administrator wants to enforce that all ML team clusters use a specific instance type for cost control. What is the correct mechanism?",
+      "choices": {
+        "A": "Create a Unity Catalog data policy",
+        "B": "Define a cluster policy with fixed node type settings",
+        "C": "Set a workspace-level spending limit in the billing console",
+        "D": "Use a Databricks Workflow job with restricted compute settings"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Cluster policies allow administrators to enforce cluster configuration constraints such as fixed or allowlisted node types, maximum cluster size, and auto-termination settings. Policies are enforced at the platform level when users create or edit clusters.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q006",
+      "domain": "databricks-ml",
+      "title": "Question 6",
+      "difficulty": "easy",
+      "question": "Which Databricks Runtime is required to use GPU-accelerated deep learning with CUDA?",
+      "choices": {
+        "A": "Databricks Runtime (standard)",
+        "B": "Databricks Runtime ML",
+        "C": "Databricks Runtime ML GPU",
+        "D": "Databricks Runtime Photon"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Runtime ML GPU includes CUDA, cuDNN, NCCL, and GPU-optimized versions of PyTorch and TensorFlow. The standard ML Runtime does not include GPU drivers or CUDA libraries.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q007",
+      "domain": "databricks-ml",
+      "title": "Question 7",
+      "difficulty": "easy",
+      "question": "A data scientist stores shared feature engineering functions in a notebook. What magic command runs that notebook and imports its variables into the current notebook?",
+      "choices": {
+        "A": "`%import ./shared_utils`",
+        "B": "`%run ./shared_utils`",
+        "C": "`%load ./shared_utils`",
+        "D": "`%source ./shared_utils`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`%run ./notebook_path` executes a notebook in the context of the current notebook, making all defined functions and variables available in the current scope. The other magic commands (`%import`, `%load`, `%source`) are not valid Databricks directives.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q008",
+      "domain": "databricks-ml",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "A data scientist runs AutoML on a regression problem. After the experiment completes, they want to understand why the best model performed well. What does AutoML provide for this purpose?",
+      "choices": {
+        "A": "A Shapley value explanation for each training row",
+        "B": "A generated notebook containing training code with built-in feature importance analysis",
+        "C": "A PDF report summarizing the model's performance",
+        "D": "An automatic A/B test comparing the best model to the baseline"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "AutoML generates an editable notebook for the best model that includes training code and often integrates SHAP-based feature importance analysis. This gives data scientists a starting point to understand the model and customize it further.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q009",
+      "domain": "databricks-ml",
+      "title": "Question 9",
+      "difficulty": "medium",
+      "question": "A platform team wants to prevent users from creating clusters with more than 10 workers. Which cluster policy attribute achieves this?",
+      "choices": {
+        "A": "Set `autoscale.max_workers` to a fixed value of 10",
+        "B": "Set `num_workers` with `maxValue: 10`",
+        "C": "Set `worker_limit: 10` in the workspace settings",
+        "D": "Create a Unity Catalog group policy restricting cluster size"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Cluster policies use JSON policy definitions where numeric parameters can have `maxValue` constraints. Setting `num_workers` with `maxValue: 10` prevents users from creating clusters with more than 10 workers. Unity Catalog governs data access, not cluster configuration.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q010",
+      "domain": "databricks-ml",
+      "title": "Question 10",
+      "difficulty": "easy",
+      "question": "Which feature of Databricks Repos enables collaborative development on ML model code?",
+      "choices": {
+        "A": "Automatic conflict resolution using MLflow",
+        "B": "Git-based version control with branch, commit, and pull request support",
+        "C": "Automated notebook execution on push",
+        "D": "Shared feature store table locking"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Repos integrates with Git providers and supports standard Git operations including branching, committing, pulling, pushing, and pull requests. This enables collaborative development workflows for ML code in notebooks and Python files.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q011",
+      "domain": "databricks-ml",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "A data scientist wants to train a PyTorch model on image data. Which cluster configuration is most appropriate?",
+      "choices": {
+        "A": "Single-node cluster with no GPU",
+        "B": "Multi-node CPU cluster with autoscaling",
+        "C": "Single-node or multi-node cluster with GPU instances, using Databricks Runtime ML GPU",
+        "D": "Standard Databricks Runtime on a general-purpose cluster"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "PyTorch image model training benefits significantly from GPU acceleration. Databricks Runtime ML GPU provides the necessary CUDA libraries and PyTorch GPU support. The number of nodes depends on whether distributed training is required.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q012",
+      "domain": "databricks-ml",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "What is the primary benefit of using Databricks AutoML over manually training multiple models?",
+      "choices": {
+        "A": "AutoML models cannot be overfitted because they use ensemble methods",
+        "B": "AutoML eliminates the need to write any Python code for the entire ML workflow",
+        "C": "AutoML reduces the time to a baseline model by automatically trying multiple algorithms and hyperparameters",
+        "D": "AutoML automatically deploys models to production without human review"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "AutoML accelerates the path to a baseline model by systematically trying multiple algorithms and hyperparameter combinations, logging all results to MLflow. It does not eliminate coding entirely (data scientists still customize the generated notebooks), it can overfit on small datasets, and it does not automatically deploy to production.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q013",
+      "domain": "databricks-ml",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "A data scientist is using Databricks Repos and wants to create a new feature branch before making changes. Which operation should they perform in the Repos UI?",
+      "choices": {
+        "A": "Create a new MLflow experiment with the branch name",
+        "B": "Click \"Create Branch\" in the Repos panel and name the branch",
+        "C": "Clone the repository to a new folder",
+        "D": "Tag the current commit with the feature name"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Repos provides UI controls for standard Git operations including creating branches. The data scientist should use \"Create Branch\" to start a new feature branch. MLflow experiments are unrelated to Git branches.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q014",
+      "domain": "ml-workflows",
+      "title": "Question 14",
+      "difficulty": "easy",
+      "question": "What is the correct way to log a hyperparameter called `learning_rate` with value `0.01` to the current MLflow run?",
+      "choices": {
+        "A": "`mlflow.log_metric(\"learning_rate\", 0.01)`",
+        "B": "`mlflow.log_param(\"learning_rate\", 0.01)`",
+        "C": "`mlflow.log_artifact(\"learning_rate\", 0.01)`",
+        "D": "`mlflow.set_tag(\"learning_rate\", 0.01)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.log_param()` is used for hyperparameters and configuration values (typically strings or numbers that describe how the model was configured). `mlflow.log_metric()` is for numeric performance measurements that can be tracked over time. `log_artifact()` saves files. `set_tag()` logs string metadata.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q015",
+      "domain": "ml-workflows",
+      "title": "Question 15",
+      "difficulty": "easy",
+      "question": "A data scientist calls `mlflow.autolog()` at the start of a notebook and then trains a scikit-learn `RandomForestClassifier`. What is automatically logged?",
+      "choices": {
+        "A": "Only the trained model artifact",
+        "B": "The model's feature importances as a custom metric",
+        "C": "Parameters (n_estimators, max_depth, etc.), metrics (accuracy, f1, etc.), and the model artifact",
+        "D": "Parameters only — metrics must still be logged manually"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`mlflow.autolog()` with scikit-learn automatically captures estimator parameters (from `get_params()`), training metrics (via cross-validation if applicable), and logs the trained model as an artifact. Feature importances are sometimes logged as artifacts depending on the estimator type.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q016",
+      "domain": "ml-workflows",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "A data scientist wants all runs in their notebook to be grouped under an experiment named `churn-model-v3`. Which code achieves this?",
+      "choices": {
+        "A": "`mlflow.start_run(experiment_name=\"churn-model-v3\")`",
+        "B": "`mlflow.set_experiment(\"churn-model-v3\")`",
+        "C": "`mlflow.create_experiment(\"churn-model-v3\")`",
+        "D": "`mlflow.log_tag(\"experiment\", \"churn-model-v3\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.set_experiment(name)` sets the active experiment so all subsequent `start_run()` calls log to that experiment. `create_experiment()` creates a new experiment but does not set it as active. `start_run()` does not accept an `experiment_name` parameter.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q017",
+      "domain": "ml-workflows",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "A data scientist wants to find all runs in experiment ID `123` where `val_loss` is less than `0.5`. Which `search_runs` call is correct?",
+      "choices": {
+        "A": "`mlflow.search_runs(experiment_ids=[\"123\"], filter_string=\"metrics.val_loss < 0.5\")`",
+        "B": "`mlflow.search_runs(experiment_id=\"123\", filter=\"val_loss < 0.5\")`",
+        "C": "`mlflow.search_runs(\"123\", metrics={\"val_loss\": \"<0.5\"})`",
+        "D": "`mlflow.find_runs(experiment_ids=[\"123\"], filter_string=\"metric.val_loss < 0.5\")`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`mlflow.search_runs()` accepts `experiment_ids` (a list) and `filter_string` using `metrics.` prefix. `experiment_id` (singular) is not a valid parameter. `metrics` as a dictionary and `find_runs` do not exist in the MLflow Python API. The prefix must be `metrics.` (plural), not `metric.`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q018",
+      "domain": "ml-workflows",
+      "title": "Question 18",
+      "difficulty": "medium",
+      "question": "A data scientist logs a metric `accuracy` at step 1 (0.72), step 2 (0.85), and step 3 (0.91) within a single run. What does `mlflow.get_run(run_id).data.metrics[\"accuracy\"]` return?",
+      "choices": {
+        "A": "0.72 (first logged value)",
+        "B": "A list of all three values: [0.72, 0.85, 0.91]",
+        "C": "0.91 (last logged value)",
+        "D": "The average: 0.827"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`run.data.metrics` returns a dictionary with the **last logged value** for each metric. To retrieve the full metric history, use `MlflowClient().get_metric_history(run_id, metric_key)`, which returns all logged values with their steps and timestamps.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q019",
+      "domain": "ml-workflows",
+      "title": "Question 19",
+      "difficulty": "easy",
+      "question": "Which MLflow function saves a local file called `report.html` to the current run's artifact store?",
+      "choices": {
+        "A": "`mlflow.log_metric(\"report\", \"report.html\")`",
+        "B": "`mlflow.log_artifact(\"report.html\")`",
+        "C": "`mlflow.log_param(\"report_path\", \"report.html\")`",
+        "D": "`mlflow.upload(\"report.html\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.log_artifact(local_path)` uploads a local file to the artifact store associated with the current run. Metrics are numeric values, params are string key-value configuration, and `mlflow.upload()` does not exist.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q020",
+      "domain": "ml-workflows",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "A data scientist runs a hyperparameter sweep and wants each trial to be a child of a single parent run. Which code correctly creates a child run?",
+      "choices": {
+        "A": "`mlflow.start_run(parent=active_run_id)`",
+        "B": "`mlflow.start_run(nested=True)`",
+        "C": "`mlflow.start_child_run(parent_run_id=active_run_id)`",
+        "D": "`MlflowClient().create_run(parent_run_id=active_run_id)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.start_run(nested=True)` creates a child run within the currently active run. The parent run must already be active when this is called. `start_child_run()` does not exist. `MlflowClient().create_run()` does not accept a `parent_run_id` parameter in this form.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q021",
+      "domain": "ml-workflows",
+      "title": "Question 21",
+      "difficulty": "easy",
+      "question": "A data scientist logs a directory of plots called `./plots/` as artifacts. Which function is correct?",
+      "choices": {
+        "A": "`mlflow.log_artifact(\"./plots/\")`",
+        "B": "`mlflow.log_artifacts(\"./plots/\")`",
+        "C": "`mlflow.log_artifact(\"./plots/*\")`",
+        "D": "`mlflow.log_file_directory(\"./plots/\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.log_artifacts(local_dir)` uploads all files in a local directory to the artifact store. `mlflow.log_artifact(path)` uploads a single file. Glob patterns are not supported. `log_file_directory()` does not exist.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q022",
+      "domain": "ml-workflows",
+      "title": "Question 22",
+      "difficulty": "easy",
+      "question": "What is the best way to compare the `val_accuracy` of 20 MLflow runs from the same experiment in the Databricks UI?",
+      "choices": {
+        "A": "Open each run individually and note the metric value",
+        "B": "Export all runs to a CSV and sort in Excel",
+        "C": "On the Experiments page, select all runs and click \"Compare\" to view parallel coordinates and scatter plots",
+        "D": "Use the Model Registry to compare version metrics"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The MLflow Experiments page allows selecting multiple runs and clicking \"Compare\" to generate visualizations including parallel coordinate plots, scatter plots, contour plots, and metric comparison tables. This is the intended workflow for comparing runs within an experiment.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q023",
+      "domain": "ml-workflows",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "A data scientist uses `mlflow.autolog()` and also manually calls `mlflow.log_metric(\"custom_score\", 0.95)`. What is the result?",
+      "choices": {
+        "A": "An error is raised because manual logging conflicts with autolog",
+        "B": "The custom metric is logged in addition to the automatically logged metrics",
+        "C": "The custom metric overwrites the autolog metrics",
+        "D": "Autolog is disabled for the rest of the run once manual logging starts"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.autolog()` and manual logging are fully compatible. Autolog captures framework-generated metrics and parameters, while manual logging adds any additional custom values. Both sets of data are stored in the same run without conflict.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q024",
+      "domain": "ml-workflows",
+      "title": "Question 24",
+      "difficulty": "easy",
+      "question": "A data scientist calls `mlflow.log_metric(\"loss\", 0.3, step=10)`. What does the `step` parameter represent?",
+      "choices": {
+        "A": "The number of seconds elapsed since training started",
+        "B": "The training epoch or iteration number associated with this metric value",
+        "C": "The version of the metric schema being used",
+        "D": "The number of times this metric has been logged in the run"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `step` parameter allows associating a metric value with a specific training step, epoch, or iteration. This enables plotting metric curves over time in the MLflow UI. It is an optional integer that defaults to 0 if not provided.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q025",
+      "domain": "ml-workflows",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "Which `mlflow.start_run()` parameter allows providing a human-readable name for the run?",
+      "choices": {
+        "A": "`run_name`",
+        "B": "`name`",
+        "C": "`description`",
+        "D": "`run_label`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`mlflow.start_run(run_name=\"my-experiment-v1\")` assigns a human-readable name to the run. This name appears in the MLflow UI alongside the run ID. The other parameter names (`name`, `description`, `run_label`) are not valid parameters for `start_run()`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q026",
+      "domain": "ml-workflows",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "A data scientist retrieves a run object with `run = mlflow.get_run(run_id)`. How do they access the value of a logged parameter named `max_depth`?",
+      "choices": {
+        "A": "`run.params[\"max_depth\"]`",
+        "B": "`run.data.params[\"max_depth\"]`",
+        "C": "`run.metrics[\"max_depth\"]`",
+        "D": "`run.data[\"params\"][\"max_depth\"]`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `Run` object returned by `mlflow.get_run()` has a `.data` attribute of type `RunData`, which has `.params`, `.metrics`, and `.tags` dictionaries. The correct access pattern is `run.data.params[\"max_depth\"]`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q027",
+      "domain": "feature-engineering",
+      "title": "Question 27",
+      "difficulty": "easy",
+      "question": "Which `VectorAssembler` parameter specifies the list of input columns to combine into a single feature vector?",
+      "choices": {
+        "A": "`inputCol`",
+        "B": "`inputCols`",
+        "C": "`featureCols`",
+        "D": "`columns`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`VectorAssembler` uses `inputCols` (plural) because it accepts a list of column names. Using `inputCol` (singular) will raise a `TypeError` because `inputCol` is a single-value parameter used by transformers like `StringIndexer` that operate on one column at a time.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q028",
+      "domain": "feature-engineering",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "A data scientist has a `Pipeline` with stages: `StringIndexer`, `VectorAssembler`, `RandomForestClassifier`. They call `pipeline.fit(train_df)`. In what order do the stages execute?",
+      "choices": {
+        "A": "`RandomForestClassifier` → `VectorAssembler` → `StringIndexer`",
+        "B": "All stages execute simultaneously in parallel",
+        "C": "`StringIndexer` → `VectorAssembler` → `RandomForestClassifier`",
+        "D": "The order depends on which stages are `Estimator` vs `Transformer`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "A `Pipeline` executes stages sequentially in the order they are listed. During `fit()`, each stage's `fit()` (for Estimators) or `transform()` (for Transformers) is called in order, passing the transformed DataFrame to the next stage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q029",
+      "domain": "feature-engineering",
+      "title": "Question 29",
+      "difficulty": "easy",
+      "question": "After calling `pipeline_model = pipeline.fit(train_df)`, a data scientist calls `predictions = pipeline_model.transform(test_df)`. What does `predictions` contain?",
+      "choices": {
+        "A": "A trained `PipelineModel` object",
+        "B": "The `test_df` with new columns added by each stage's transformation",
+        "C": "Only the final model's predictions column",
+        "D": "A dictionary of metric values from the model evaluation"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`PipelineModel.transform(df)` passes the DataFrame through each stage's `transform()` method sequentially. The result is the input DataFrame with additional columns appended by each stage (e.g., `StringIndexer` adds an index column, `VectorAssembler` adds a features column, and the classifier adds `rawPrediction`, `probability`, and `prediction` columns).",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q030",
+      "domain": "feature-engineering",
+      "title": "Question 30",
+      "difficulty": "easy",
+      "question": "What is the default number of folds used by `CrossValidator` if `numFolds` is not specified?",
+      "choices": {
+        "A": "5",
+        "B": "10",
+        "C": "2",
+        "D": "3"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`CrossValidator` defaults to `numFolds=3`. This means the training data is split into 3 equal folds, and for each hyperparameter combination in the grid, the model is trained on 2 folds and evaluated on the remaining 1 fold, repeating 3 times.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q031",
+      "domain": "feature-engineering",
+      "title": "Question 31",
+      "difficulty": "medium",
+      "question": "A data scientist wants to search over `maxDepth` values of 5 and 10 for a `DecisionTreeClassifier` named `dt`. Which code correctly adds this to the parameter grid?",
+      "choices": {
+        "A": "`ParamGridBuilder().addGrid(\"maxDepth\", [5, 10]).build()`",
+        "B": "`ParamGridBuilder().addGrid(dt.maxDepth, [5, 10]).build()`",
+        "C": "`ParamGridBuilder(dt.maxDepth=[5, 10]).build()`",
+        "D": "`ParamGridBuilder().add(dt, \"maxDepth\", [5, 10]).build()`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`ParamGridBuilder().addGrid(estimator.param, [values]).build()` is the correct syntax. The first argument to `addGrid` must be the actual `Param` object from the estimator (e.g., `dt.maxDepth`), not a string. The constructor does not accept keyword arguments.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q032",
+      "domain": "feature-engineering",
+      "title": "Question 32",
+      "difficulty": "medium",
+      "question": "What is the key advantage of `CrossValidator` over `TrainValidationSplit` for hyperparameter tuning?",
+      "choices": {
+        "A": "`CrossValidator` is always faster because it uses more CPU cores",
+        "B": "`CrossValidator` provides more reliable performance estimates by using all data for both training and validation across multiple folds",
+        "C": "`CrossValidator` automatically selects the best algorithm, not just the best hyperparameters",
+        "D": "`CrossValidator` requires less memory because it processes one fold at a time"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CrossValidator` uses k-fold cross-validation, ensuring every data point is used for validation exactly once across k experiments. This produces more reliable performance estimates than `TrainValidationSplit`, which uses a single random split and may produce high-variance estimates on small datasets.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q033",
+      "domain": "feature-engineering",
+      "title": "Question 33",
+      "difficulty": "easy",
+      "question": "What error occurs if you call `FeatureStoreClient.create_feature_table()` without the `primary_keys` parameter?",
+      "choices": {
+        "A": "The table is created with a default UUID primary key",
+        "B": "A `ValueError` is raised because `primary_keys` is required",
+        "C": "The table is created successfully with no primary key",
+        "D": "A `DeprecationWarning` is shown but the table is still created"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`primary_keys` is a required parameter for `create_feature_table()`. The Feature Store needs primary keys to uniquely identify rows for updates, point-in-time lookups, and online store publishing. Omitting it raises a `ValueError`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q034",
+      "domain": "feature-engineering",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "A data engineer wants to add new rows and update existing rows in a Feature Store table based on primary key matches. Which `write_table()` mode should they use?",
+      "choices": {
+        "A": "`mode=\"append\"`",
+        "B": "`mode=\"overwrite\"`",
+        "C": "`mode=\"merge\"`",
+        "D": "`mode=\"upsert\"`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`mode=\"merge\"` performs an upsert: rows with matching primary keys are updated, and new rows are inserted. `mode=\"overwrite\"` replaces all existing data. `mode=\"append\"` is not a valid option for Feature Store `write_table()`. `mode=\"upsert\"` is not a valid mode name.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q035",
+      "domain": "feature-engineering",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A data scientist trained a model using Feature Store features and wants to score a new batch of customer IDs. Which function performs offline batch inference while automatically retrieving features from the Feature Store?",
+      "choices": {
+        "A": "`mlflow.pyfunc.load_model(model_uri).predict(entity_df)`",
+        "B": "`FeatureStoreClient.score_batch(model_uri, entity_df)`",
+        "C": "`FeatureStoreClient.get_table(table_name).join(entity_df)`",
+        "D": "`mlflow.pyfunc.spark_udf(spark, model_uri)(entity_df)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`FeatureStoreClient.score_batch(model_uri, df)` automatically retrieves features specified in the model's `FeatureLookup` configuration, joins them with the entity DataFrame, and applies the model. This ensures serving uses the same feature definitions as training, preventing train-serve skew.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q036",
+      "domain": "feature-engineering",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "Why does the Databricks Feature Store provide point-in-time feature lookups?",
+      "choices": {
+        "A": "To allow features to be queried faster using time-indexed partitioning",
+        "B": "To prevent data leakage by ensuring training labels are only joined with feature values that existed before the label's event time",
+        "C": "To enable automatic feature refresh on a schedule",
+        "D": "To support real-time feature computation with sub-second latency"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Point-in-time lookups prevent temporal data leakage. When training a model, each training example's features should reflect what was known at the time the label was generated. Without point-in-time lookups, future feature values could leak into the training data, leading to optimistic performance estimates.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q037",
+      "domain": "feature-engineering",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "Which class is an `Estimator` in Spark ML (requiring `fit()` to produce a fitted object)?",
+      "choices": {
+        "A": "`VectorAssembler`",
+        "B": "`Bucketizer`",
+        "C": "`Normalizer`",
+        "D": "`MinMaxScaler`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`MinMaxScaler` is an `Estimator` that learns the minimum and maximum values of each feature during `fit()`. `VectorAssembler`, `Bucketizer`, and `Normalizer` are `Transformer` classes that apply deterministic transformations without learning from data.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q038",
+      "domain": "feature-engineering",
+      "title": "Question 38",
+      "difficulty": "hard",
+      "question": "A Pipeline contains a `CrossValidator` as its last stage. Which statement is true?",
+      "choices": {
+        "A": "`CrossValidator` cannot be used inside a `Pipeline`",
+        "B": "The `CrossValidator` is only applied to the last stage's estimator",
+        "C": "The entire preceding pipeline (all stages) is treated as the estimator inside `CrossValidator`",
+        "D": "`CrossValidator` automatically wraps all prior pipeline stages"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "When the estimator passed to `CrossValidator` is a `Pipeline`, the entire pipeline (all stages) is fit and evaluated for each hyperparameter combination in each fold. This ensures that preprocessing stages fit only on training data within each fold, preventing data leakage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q039",
+      "domain": "feature-engineering",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A data scientist uses `StringIndexer` with `handleInvalid=\"keep\"`. What happens when the transformer encounters a category during test inference that was not seen during training?",
+      "choices": {
+        "A": "An exception is raised and the pipeline halts",
+        "B": "The unseen category is mapped to index 0 (the most frequent category)",
+        "C": "The unseen category is assigned a new index at the end of the index range",
+        "D": "The row containing the unseen category is dropped from the output"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`handleInvalid=\"keep\"` instructs `StringIndexer` to assign unseen categories a reserved index equal to the number of distinct training categories (i.e., one beyond the existing range). This allows inference to continue without errors. The alternative `handleInvalid=\"error\"` raises an exception, and `handleInvalid=\"skip\"` drops the row.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q040",
+      "domain": "feature-engineering",
+      "title": "Question 40",
+      "difficulty": "easy",
+      "question": "Which parameter in `FeatureLookup` specifies how the training DataFrame joins to the feature table?",
+      "choices": {
+        "A": "`join_key`",
+        "B": "`primary_key`",
+        "C": "`lookup_key`",
+        "D": "`entity_key`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`lookup_key` in `FeatureLookup` specifies the column(s) in the training DataFrame that map to the feature table's primary key columns. This is used to join features to training labels at the correct row level.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q041",
+      "domain": "feature-engineering",
+      "title": "Question 41",
+      "difficulty": "easy",
+      "question": "A data scientist wants to apply feature scaling so that each numerical feature has zero mean and unit variance. Which Spark ML transformer should they use?",
+      "choices": {
+        "A": "`Normalizer`",
+        "B": "`StandardScaler`",
+        "C": "`MinMaxScaler`",
+        "D": "`MaxAbsScaler`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`StandardScaler` standardizes features by removing the mean and scaling to unit variance (z-score normalization). `Normalizer` scales rows to unit norm (not column-wise). `MinMaxScaler` scales to a [0, 1] range. `MaxAbsScaler` scales by the maximum absolute value.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q042",
+      "domain": "mlflow-deployment",
+      "title": "Question 42",
+      "difficulty": "easy",
+      "question": "A data scientist has run_id `xyz789` and logged a model with `artifact_path=\"classifier\"`. Which URI registers this model to the registry as `purchase-predictor`?",
+      "choices": {
+        "A": "`mlflow.register_model(\"classifier/xyz789\", \"purchase-predictor\")`",
+        "B": "`mlflow.register_model(\"runs:/xyz789/classifier\", \"purchase-predictor\")`",
+        "C": "`mlflow.register_model(\"artifacts:/xyz789/classifier\", \"purchase-predictor\")`",
+        "D": "`mlflow.register_model(\"models:/purchase-predictor/None\", \"purchase-predictor\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The correct URI format is `runs:/<run_id>/<artifact_path>`. The artifact path matches the `artifact_path` argument used in `log_model()`. The `artifacts:/` and `models:/` URI schemes serve different purposes and are not valid for `register_model()`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-1-q045",
+      "domain": "mlflow-deployment",
+      "title": "Question 45",
+      "difficulty": "easy",
+      "question": "Which is NOT a valid stage in the MLflow Model Registry lifecycle?",
+      "choices": {
+        "A": "None",
+        "B": "Staging",
+        "C": "Production",
+        "D": "Deprecated"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "The valid Model Registry stages are: **None** (newly registered), **Staging** (under evaluation), **Production** (serving live traffic), and **Archived** (retired). \"Deprecated\" is not a valid stage. Use \"Archived\" to retire a model version.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "ml-associate"
+}
diff --git a/practice/data/ml-associate-mock-2.json b/practice/data/ml-associate-mock-2.json
new file mode 100644
index 0000000..01a78b9
--- /dev/null
+++ b/practice/data/ml-associate-mock-2.json
@@ -0,0 +1,740 @@
+{
+  "cert": "ml-associate-mock-2",
+  "certTitle": "ML Associate — Mock Exam 2",
+  "blueprintVersion": "Mar 1, 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "databricks-ml",
+      "name": "Databricks ML",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 13
+    },
+    {
+      "id": "ml-workflows",
+      "name": "ML Workflows",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 12
+    },
+    {
+      "id": "feature-engineering",
+      "name": "Feature Engineering",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 15
+    },
+    {
+      "id": "mlflow-deployment",
+      "name": "MLflow Deployment",
+      "sourceFile": "certifications/ml-associate/resources/mock-exam-2/questions.md",
+      "questionCount": 4
+    }
+  ],
+  "questions": [
+    {
+      "id": "ml-associate-mock-2-q001",
+      "domain": "databricks-ml",
+      "title": "Question 1",
+      "difficulty": "medium",
+      "question": "A data scientist is debugging a scikit-learn pipeline on a small sample of data locally in a Databricks notebook. The full training dataset is 2 TB in Delta Lake. Which cluster type should they use for the debugging phase?",
+      "choices": {
+        "A": "Multi-node cluster with 20 workers to match the production environment",
+        "B": "Single-node cluster to minimize cost during the debugging phase",
+        "C": "GPU cluster to ensure the code runs correctly before moving to GPU production",
+        "D": "High-concurrency cluster shared with the rest of the team"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "During debugging with a small data sample using scikit-learn (which does not distribute), a single-node cluster minimizes cost. Multi-node clusters add overhead with no benefit for non-distributed code. GPU and high-concurrency clusters are not needed for debugging scikit-learn logic.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q002",
+      "domain": "databricks-ml",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "A data scientist accidentally launches a Databricks Runtime ML cluster instead of Databricks Runtime ML GPU for a PyTorch training job that requires GPU. What symptom will they observe?",
+      "choices": {
+        "A": "The cluster fails to start because GPU drivers cannot be installed on a non-GPU runtime",
+        "B": "PyTorch runs in CPU-only mode, and GPU acceleration is unavailable",
+        "C": "The job runs normally because Databricks automatically detects and enables GPU support",
+        "D": "MLflow autolog is disabled because GPU metrics cannot be tracked"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Runtime ML GPU is needed for CUDA/GPU support. If a GPU instance type is selected with the standard ML Runtime, PyTorch will run in CPU-only mode because the CUDA libraries are not installed. The runtime selection must explicitly be ML GPU to enable GPU acceleration.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q003",
+      "domain": "databricks-ml",
+      "title": "Question 3",
+      "difficulty": "medium",
+      "question": "An ML platform team wants to allow data scientists to configure cluster memory and core counts but prevent them from changing the auto-termination setting. How should the policy be configured?",
+      "choices": {
+        "A": "Set auto-termination to a fixed value in the cluster policy",
+        "B": "Make auto-termination a hidden field in the cluster creation UI",
+        "C": "Create a separate termination policy in the billing console",
+        "D": "Set a minimum auto-termination threshold without fixing it"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Cluster policies support `fixed` constraints that lock a parameter to a specific value, preventing users from changing it. Setting auto-termination to a fixed value in the policy ensures all clusters terminate after the specified idle time, regardless of user preferences.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q004",
+      "domain": "databricks-ml",
+      "title": "Question 4",
+      "difficulty": "medium",
+      "question": "A data scientist runs AutoML for classification. The resulting experiment shows 20 trial runs. They want to use the best model's code as a starting point for further tuning. Where is this code located?",
+      "choices": {
+        "A": "In the DBFS path `/ml/automl/best_model.py`",
+        "B": "In a generated notebook linked from the best run in the AutoML experiment",
+        "C": "In the MLflow model artifact under `source_code/`",
+        "D": "In a Delta table named `automl_best_model_code`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "AutoML generates a Python notebook containing the complete training code for the best-performing trial. This notebook is linked directly from the best run in the MLflow experiment UI. Data scientists can clone and modify it to customize the training approach.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q005",
+      "domain": "databricks-ml",
+      "title": "Question 5",
+      "difficulty": "medium",
+      "question": "A company wants to standardize all ML cluster configurations so that data scientists cannot accidentally change the Databricks Runtime version. Which cluster policy constraint type should be used?",
+      "choices": {
+        "A": "`allowlist` — provide a list of allowed runtime versions",
+        "B": "`fixed` — lock the runtime to a specific version",
+        "C": "`range` — specify minimum and maximum runtime versions",
+        "D": "`default` — set a default but allow overrides"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `fixed` constraint in a cluster policy locks a parameter to a specific value that cannot be changed by users. `allowlist` allows users to choose from a set of approved values. `range` sets min/max bounds. `default` sets an initial value but allows the user to override it.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q006",
+      "domain": "databricks-ml",
+      "title": "Question 6",
+      "difficulty": "easy",
+      "question": "A data scientist wants to track their ML experiment notebooks in version control and collaborate with teammates using pull requests. Which Databricks feature should they use?",
+      "choices": {
+        "A": "MLflow experiment tags",
+        "B": "Databricks Repos with Git integration",
+        "C": "Delta Lake change data feed",
+        "D": "Databricks Workflows version history"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks Repos integrates with Git providers, enabling full Git workflows including branching, committing, pushing, and pull requests. This is the correct feature for source-controlling notebooks and collaborating through code reviews.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q007",
+      "domain": "databricks-ml",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "A data scientist is running a hyperparameter optimization loop in a notebook. After 50 iterations, they want to identify which hyperparameter combination produced the best validation AUC. What is the most efficient approach?",
+      "choices": {
+        "A": "Manually inspect each cell's output in the notebook",
+        "B": "Export all results to a CSV and sort by AUC",
+        "C": "Use `mlflow.search_runs()` to query runs by `metrics.val_auc` in descending order",
+        "D": "Review the printed output from each training loop iteration"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`mlflow.search_runs(filter_string=\"\", order_by=[\"metrics.val_auc DESC\"])` programmatically retrieves all runs sorted by the specified metric. This is more efficient and reproducible than manual inspection or CSV exports.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q008",
+      "domain": "databricks-ml",
+      "title": "Question 8",
+      "difficulty": "hard",
+      "question": "An organization uses AutoML for initial model prototyping. A data scientist notices that the AutoML experiment uses different feature transformations than their production preprocessing pipeline. What is the risk?",
+      "choices": {
+        "A": "The AutoML model may perform better than expected in production due to more optimized preprocessing",
+        "B": "The AutoML model may perform worse in production due to train-serve skew from different feature transformations",
+        "C": "AutoML preprocessing is always identical to production because it uses the Databricks Feature Store",
+        "D": "There is no risk because AutoML models are never used directly in production"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "If AutoML's internal feature transformations differ from the production preprocessing pipeline, the model will experience train-serve skew — it will be evaluated in production on differently transformed features than it was trained on. This can significantly degrade prediction quality. Integrating the Feature Store with AutoML or carefully replicating feature logic mitigates this risk.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q009",
+      "domain": "databricks-ml",
+      "title": "Question 9",
+      "difficulty": "easy",
+      "question": "A data scientist wants to run their model training notebook as a scheduled job. Which Databricks feature orchestrates this?",
+      "choices": {
+        "A": "Databricks Repos (scheduled sync)",
+        "B": "MLflow experiment scheduler",
+        "C": "Databricks Workflows (Jobs)",
+        "D": "Delta Live Tables pipeline"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Workflows (Jobs) allows scheduling and orchestrating notebook, Python script, and pipeline executions on a recurring schedule or trigger. MLflow does not have a scheduler, Repos is for version control, and Delta Live Tables is for data pipeline orchestration.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q010",
+      "domain": "databricks-ml",
+      "title": "Question 10",
+      "difficulty": "easy",
+      "question": "A data scientist runs `dbutils.notebook.run(\"train_model\", 600)`. What does the integer `600` represent?",
+      "choices": {
+        "A": "The maximum number of rows to process",
+        "B": "The timeout in seconds before the notebook execution is aborted",
+        "C": "The maximum number of MLflow runs to create",
+        "D": "The cluster auto-termination time in minutes"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The second parameter to `dbutils.notebook.run()` is the timeout in seconds. If the called notebook does not complete within 600 seconds (10 minutes), the call raises a `TimeoutError`. Unlike `%run`, `dbutils.notebook.run()` returns only a string result, not shared variables.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q011",
+      "domain": "databricks-ml",
+      "title": "Question 11",
+      "difficulty": "hard",
+      "question": "Which Databricks Runtime feature reduces data shuffle costs in Spark ML training by keeping data co-located?",
+      "choices": {
+        "A": "Photon engine",
+        "B": "Delta Lake Z-ordering",
+        "C": "Adaptive Query Execution (AQE)",
+        "D": "Spark ML `cacheData` option in `CrossValidator`"
+      },
+      "correctAnswer": "D",
+      "shortAnswer": "`CrossValidator` has a `parallelism` parameter and a `seed` for reproducibility, but more importantly, `CrossValidator` (and `TrainValidationSplit`) have a `collectSubModels` option and support data caching via `cacheData=True` to avoid recomputing the dataset for each fold. AQE and Photon optimize general Spark queries but are not ML-specific caching features.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q012",
+      "domain": "databricks-ml",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "A team wants to share an AutoML-generated notebook with a colleague who works in a different Databricks workspace. What is the best approach?",
+      "choices": {
+        "A": "Export the notebook as a .dbc file and import it into the colleague's workspace",
+        "B": "Share the MLflow experiment URL — it is accessible across workspaces",
+        "C": "Push the notebook to a shared Git repository using Databricks Repos",
+        "D": "Copy the notebook text and paste it into an email"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Databricks Repos with Git integration is the best approach for sharing notebooks across workspaces. Pushing to a shared Git repository allows the colleague to clone or pull the notebook in their own workspace. The `.dbc` export/import approach works but is less maintainable for ongoing collaboration.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q013",
+      "domain": "databricks-ml",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "A data scientist wants to create a reproducible experiment where the same random split is used every time the notebook runs. Which parameter in `train_test_split` (sklearn) or `randomSplit` (Spark) controls this?",
+      "choices": {
+        "A": "`reproducible=True`",
+        "B": "`random_state` (sklearn) or `seed` (Spark)",
+        "C": "`deterministic=True`",
+        "D": "`fixed_split=True`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "In scikit-learn, `train_test_split(df, random_state=42)` sets the random seed. In Spark, `df.randomSplit([0.8, 0.2], seed=42)` sets the split seed. The parameter is `random_state` in sklearn and `seed` in Spark. `reproducible`, `deterministic`, and `fixed_split` are not valid parameters.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q014",
+      "domain": "ml-workflows",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "A data scientist enables `mlflow.autolog()` and then manually logs `mlflow.log_metric(\"custom_f1\", 0.88)` within the same run. What is the result?",
+      "choices": {
+        "A": "An error is raised because manual and automatic logging cannot coexist",
+        "B": "The `custom_f1` metric is logged alongside the automatically captured metrics",
+        "C": "Autolog is disabled after the first manual logging call",
+        "D": "The manual log overwrites all autolog metrics with the same name"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.autolog()` and manual logging calls are fully compatible. Autolog captures framework-generated metrics, while manual calls add supplementary data. All logged values coexist in the same run record. Autolog is not disabled by manual logging.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q015",
+      "domain": "ml-workflows",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "A data scientist wants to log the full training dataset as an artifact for reproducibility. The dataset is a Spark DataFrame. What is the recommended approach?",
+      "choices": {
+        "A": "`mlflow.log_artifact(train_df)` — pass the DataFrame directly",
+        "B": "Save the DataFrame to a Delta table path and log the path string as a parameter",
+        "C": "`mlflow.log_param(\"dataset_path\", delta_table_path)` or save a sample CSV and log with `log_artifact()`",
+        "D": "Log the DataFrame as a pickle file using `mlflow.log_artifact()`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Spark DataFrames cannot be passed directly to `log_artifact()`. The best practice is to log the data location (Delta table path or version) as a parameter with `log_param()`, ensuring reproducibility without duplicating large datasets. For small datasets, saving a sample and logging with `log_artifact()` is also acceptable.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q016",
+      "domain": "ml-workflows",
+      "title": "Question 16",
+      "difficulty": "hard",
+      "question": "A parent run is active. A data scientist calls `mlflow.start_run(nested=True)` inside a loop to create child runs. When does the parent run end?",
+      "choices": {
+        "A": "After the first child run ends",
+        "B": "After all child runs in the loop have ended",
+        "C": "Only when the parent run's context manager or `mlflow.end_run()` is explicitly called",
+        "D": "Automatically after 60 minutes of inactivity"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The parent run's lifecycle is independent of its child runs. The parent run ends when its `with` block exits (if using a context manager) or when `mlflow.end_run()` is explicitly called. Child runs ending does not affect the parent run's status.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q017",
+      "domain": "ml-workflows",
+      "title": "Question 17",
+      "difficulty": "medium",
+      "question": "A data scientist uses the same experiment name in two different notebooks running simultaneously. Both call `mlflow.set_experiment(\"shared-experiment\")` and `mlflow.start_run()`. What happens?",
+      "choices": {
+        "A": "The second notebook's runs overwrite the first notebook's runs",
+        "B": "Both notebooks log runs to the same experiment — runs are identified by unique run IDs",
+        "C": "An error is raised because experiments cannot be used by multiple notebooks concurrently",
+        "D": "One notebook's runs are automatically moved to a new experiment"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "MLflow experiments support concurrent access. Each `mlflow.start_run()` creates a unique run with its own `run_id`. Multiple runs from different notebooks can coexist in the same experiment simultaneously. There is no locking or overwriting.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q019",
+      "domain": "ml-workflows",
+      "title": "Question 19",
+      "difficulty": "medium",
+      "question": "A data scientist logs a model inside a run but forgets to register it to the Model Registry. Later, they want to register it without re-running training. What should they do?",
+      "choices": {
+        "A": "Retrain the model and call `mlflow.register_model()` this time",
+        "B": "Use `mlflow.register_model(\"runs:/<run_id>/<artifact_path>\", \"model_name\")` to register the logged model",
+        "C": "Delete the run and start over with proper registration",
+        "D": "Copy the artifact file to the model registry manually using DBFS commands"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.register_model()` can be called at any time after a model has been logged to a run. As long as you know the `run_id` and `artifact_path`, you can register the model to the registry without re-running training. The run must not have been deleted.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q020",
+      "domain": "ml-workflows",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "Which MLflow tag is automatically set to identify the notebook path where a run was started in Databricks?",
+      "choices": {
+        "A": "`mlflow.source.name`",
+        "B": "`mlflow.databricks.notebookPath`",
+        "C": "`mlflow.notebook.path`",
+        "D": "`databricks.notebook.id`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "MLflow automatically sets the `mlflow.source.name` tag to the notebook path when runs are started from a Databricks notebook. Other Databricks-specific tags such as `mlflow.databricks.notebookRevisionID` and `mlflow.databricks.cluster.id` are also set automatically.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q021",
+      "domain": "ml-workflows",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "A data scientist calls `mlflow.log_metric(\"accuracy\", 0.92)` multiple times in a run without specifying a `step`. What happens?",
+      "choices": {
+        "A": "Only the first value is retained; subsequent calls are ignored",
+        "B": "The last logged value overwrites the previous values",
+        "C": "All values are retained in the metric history and the last value is shown in the run summary",
+        "D": "An error is raised because a metric can only be logged once per run"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "MLflow stores the complete history for each metric, including all values and their timestamps. When you call `log_metric()` without a `step`, MLflow uses an auto-incrementing step. The run summary (`run.data.metrics`) shows the last logged value, but the full history is accessible via `MlflowClient().get_metric_history()`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q022",
+      "domain": "ml-workflows",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "A data scientist wants to log a Python dictionary as a JSON artifact. Which approach is correct?",
+      "choices": {
+        "A": "`mlflow.log_artifact(my_dict)` — dicts are automatically serialized",
+        "B": "Save the dict to a JSON file locally, then call `mlflow.log_artifact(\"config.json\")`",
+        "C": "`mlflow.log_param(\"config\", str(my_dict))`",
+        "D": "`mlflow.log_metric(\"config\", my_dict)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.log_artifact()` requires a local file path, not a Python object. The correct approach is to serialize the dictionary to a local file (e.g., using `json.dump()`) and then call `log_artifact()` with the file path. `log_param()` works for short strings but not for large dictionaries. `log_metric()` only accepts numeric values.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q023",
+      "domain": "ml-workflows",
+      "title": "Question 23",
+      "difficulty": "hard",
+      "question": "A data scientist wants to programmatically delete all MLflow runs in an experiment that have `val_loss > 1.0`. Which approach is correct?",
+      "choices": {
+        "A": "Use `mlflow.delete_runs()` with a filter string",
+        "B": "Use `mlflow.search_runs()` to find matching run IDs, then call `MlflowClient().delete_run(run_id)` for each",
+        "C": "Delete the entire experiment with `mlflow.delete_experiment(experiment_id)`",
+        "D": "Use `MlflowClient().archive_runs(filter_string=\"metrics.val_loss > 1.0\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "There is no `mlflow.delete_runs()` bulk function or `archive_runs()` method. The correct approach is to use `mlflow.search_runs()` to retrieve matching run IDs, then iterate and call `MlflowClient().delete_run(run_id)` for each. Deleting the entire experiment would also delete all passing runs.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q024",
+      "domain": "ml-workflows",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "A data scientist sets `mlflow.autolog(log_models=False)`. What is the effect?",
+      "choices": {
+        "A": "Autolog is completely disabled",
+        "B": "Autolog captures parameters and metrics but does NOT log the model artifact",
+        "C": "Autolog logs the model artifact but not parameters or metrics",
+        "D": "Autolog raises a deprecation warning and falls back to default behavior"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`log_models=False` disables automatic model artifact logging within autolog, but parameters and metrics are still captured. This is useful when you want to log the model manually with custom metadata or a different artifact path, while still benefiting from automatic metric and parameter capture.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q025",
+      "domain": "ml-workflows",
+      "title": "Question 25",
+      "difficulty": "hard",
+      "question": "A data scientist uses `mlflow.autolog(disable=True)` at the top of their notebook. Then they call `mlflow.sklearn.autolog()` for a specific sklearn model. What happens?",
+      "choices": {
+        "A": "All autolog functionality remains disabled because the global disable takes precedence",
+        "B": "Global autolog is disabled, but explicitly calling `mlflow.sklearn.autolog()` re-enables sklearn-specific autolog",
+        "C": "An error is raised because autolog cannot be partially enabled",
+        "D": "The global `disable=True` is overridden by the sklearn-specific call for all frameworks"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.autolog(disable=True)` disables the global autolog. However, calling a framework-specific autolog function like `mlflow.sklearn.autolog()` explicitly re-enables autolog for that specific framework only. This allows fine-grained control over which integrations are active.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q026",
+      "domain": "ml-workflows",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "A data scientist has trained a model and wants to log it under a specific artifact subdirectory called `models/classifier` within the run. Which call is correct?",
+      "choices": {
+        "A": "`mlflow.sklearn.log_model(model, artifact_path=\"models/classifier\")`",
+        "B": "`mlflow.sklearn.log_model(model, artifact_dir=\"models/classifier\")`",
+        "C": "`mlflow.log_artifact(model, \"models/classifier\")`",
+        "D": "`mlflow.sklearn.log_model(model, path=\"models/classifier\")`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "The `artifact_path` parameter in `log_model()` specifies the subdirectory within the run's artifact store where the model is saved. The full URI to reference this model would be `runs:/<run_id>/models/classifier`. `artifact_dir` and `path` are not valid parameter names for `log_model()`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q027",
+      "domain": "feature-engineering",
+      "title": "Question 27",
+      "difficulty": "hard",
+      "question": "A data scientist creates a `Pipeline` with a `VectorAssembler` and `LogisticRegression`. The `VectorAssembler` uses `inputCols=[\"age\", \"income\"]` and `outputCol=\"features\"`. `LogisticRegression` uses `featuresCol=\"features\"`. What happens if the test DataFrame is missing the `income` column?",
+      "choices": {
+        "A": "The pipeline silently ignores the missing column and uses only `age`",
+        "B": "An exception is raised when `transform()` is called on the missing column",
+        "C": "The `VectorAssembler` fills missing values with 0 by default",
+        "D": "The pipeline adds a null `income` column automatically"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`VectorAssembler` raises an exception if any column specified in `inputCols` is missing from the input DataFrame at transform time. There is no automatic null-filling or column creation behavior unless `handleInvalid=\"keep\"` is set, which handles null values in existing columns but not entirely absent columns.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q028",
+      "domain": "feature-engineering",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "A data scientist wants to one-hot encode two categorical columns `city` and `category`. They use two `StringIndexer` stages and two `OneHotEncoder` stages. Which pipeline ordering is correct?",
+      "choices": {
+        "A": "`OHE(city)` → `OHE(category)` → `SI(city)` → `SI(category)`",
+        "B": "`SI(city)` → `SI(category)` → `OHE(city)` → `OHE(category)`",
+        "C": "`SI(city)` → `OHE(city)` → `SI(category)` → `OHE(category)`",
+        "D": "All four stages can be in any order since they operate on different columns"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "While options B and C both work functionally (each `StringIndexer` must precede its corresponding `OneHotEncoder`), the typical convention is to group all `StringIndexer` stages first, then all `OneHotEncoder` stages. However, B and C are both logically correct. The key constraint is that `SI(city)` must precede `OHE(city)` and `SI(category)` must precede `OHE(category)`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q029",
+      "domain": "feature-engineering",
+      "title": "Question 29",
+      "difficulty": "hard",
+      "question": "A `CrossValidator` with `numFolds=5` is used to tune a model with a `ParamGrid` containing 6 hyperparameter combinations. How many total model training runs occur?",
+      "choices": {
+        "A": "6 (one per hyperparameter combination)",
+        "B": "5 (one per fold)",
+        "C": "30 (6 combinations × 5 folds)",
+        "D": "11 (6 combinations + 5 folds)"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`CrossValidator` trains a model for every combination of hyperparameters and every fold. With 6 parameter combinations and 5 folds, the total is 6 × 5 = 30 training runs. After selecting the best combination, a final model is optionally retrained on the full dataset.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q030",
+      "domain": "feature-engineering",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "A data scientist fits a `Pipeline` on training data and saves it with `pipeline_model.save(\"/dbfs/models/pipeline\")`. Later, they load it with `PipelineModel.load(\"/dbfs/models/pipeline\")`. Which statement is true?",
+      "choices": {
+        "A": "The loaded model needs to be re-fitted on new data before it can transform",
+        "B": "The loaded model contains all fitted stage parameters and can transform new data immediately",
+        "C": "Only the final estimator stage is saved; preprocessing stages must be re-fitted",
+        "D": "The `save()` method does not persist the fitted parameters, only the stage configuration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`PipelineModel.save()` persists all fitted stage parameters (e.g., `StringIndexerModel`'s index mapping, `StandardScalerModel`'s mean and variance, `LogisticRegressionModel`'s coefficients). When loaded, the model is fully ready to call `transform()` without any re-fitting.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q031",
+      "domain": "feature-engineering",
+      "title": "Question 31",
+      "difficulty": "medium",
+      "question": "A data scientist wants to add `parallelism=4` to a `CrossValidator`. What does this parameter do?",
+      "choices": {
+        "A": "It splits the training data into 4 parallel streams",
+        "B": "It trains up to 4 hyperparameter-fold combinations simultaneously",
+        "C": "It uses 4 threads to read data from Delta Lake",
+        "D": "It limits the CrossValidator to evaluating only 4 hyperparameter combinations"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `parallelism` parameter in `CrossValidator` (and `TrainValidationSplit`) specifies the degree of parallelism for fitting and evaluating models. Setting `parallelism=4` allows up to 4 (hyperparameter combination, fold) pairs to be trained simultaneously, which can significantly reduce wall-clock time for large parameter grids.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q032",
+      "domain": "feature-engineering",
+      "title": "Question 32",
+      "difficulty": "hard",
+      "question": "A data scientist creates a Feature Store table called `customer_features` with `primary_keys=[\"customer_id\"]`. They then try to write a DataFrame that has duplicate `customer_id` values using `mode=\"merge\"`. What happens?",
+      "choices": {
+        "A": "The duplicate rows are silently deduplicated, keeping the last row",
+        "B": "An error is raised because duplicate primary keys violate the Feature Store constraint",
+        "C": "All duplicate rows are written, resulting in duplicate primary key entries",
+        "D": "Only the first occurrence of each duplicate `customer_id` is written"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The Databricks Feature Store enforces primary key uniqueness. Writing a DataFrame with duplicate primary key values in `mode=\"merge\"` raises an error. You must deduplicate the DataFrame before writing to ensure each primary key appears exactly once.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q033",
+      "domain": "feature-engineering",
+      "title": "Question 33",
+      "difficulty": "medium",
+      "question": "A data scientist is building a Feature Store pipeline where features are computed daily. They want to ensure that model training uses feature values from the day before each label's event. Which Feature Store capability should they use?",
+      "choices": {
+        "A": "`write_table(mode=\"overwrite\")` to replace features daily",
+        "B": "Point-in-time lookups with a `timestamp_lookup_key` in `FeatureLookup`",
+        "C": "Delta Lake time travel to query feature tables at a specific version",
+        "D": "Scheduled `score_batch()` runs that re-score all historical entities"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Point-in-time lookups use a `timestamp_lookup_key` in `FeatureLookup` to retrieve feature values as they existed at a specific timestamp for each training example. This prevents data leakage by ensuring that only feature values available before each label's event time are used in training.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q034",
+      "domain": "feature-engineering",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "A data scientist accidentally passes a string column directly to `OneHotEncoder` (skipping `StringIndexer`). What happens?",
+      "choices": {
+        "A": "`OneHotEncoder` automatically converts strings to integer indices internally",
+        "B": "An error is raised because `OneHotEncoder` expects numeric input",
+        "C": "The string column is encoded as binary using ASCII values",
+        "D": "`OneHotEncoder` silently ignores the column and produces a zero vector"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`OneHotEncoder` requires numeric input (specifically, integer indices produced by `StringIndexer`). Passing a string column directly raises a `SparkException` at runtime because the transformer cannot process string data. `StringIndexer` must always precede `OneHotEncoder` in the pipeline.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q035",
+      "domain": "feature-engineering",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "A data scientist uses the Feature Store to train a model. Later, a new version of the feature table is available with additional columns. How does this affect the deployed model?",
+      "choices": {
+        "A": "The deployed model automatically uses the new feature columns because it queries the live feature table",
+        "B": "The deployed model is unaffected — it only uses the features specified in its `FeatureLookup` configuration at training time",
+        "C": "The deployed model fails with an error because the schema has changed",
+        "D": "The deployed model uses the new columns but ignores their values"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Models deployed with Feature Store integration use the `FeatureLookup` configuration captured at training time. New columns added to the feature table are ignored by existing models unless the model is retrained with an updated `FeatureLookup` that includes the new features. Schema additions do not break existing models.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q036",
+      "domain": "feature-engineering",
+      "title": "Question 36",
+      "difficulty": "easy",
+      "question": "Which Spark ML evaluator class should be used with `CrossValidator` for a binary classification problem?",
+      "choices": {
+        "A": "`RegressionEvaluator`",
+        "B": "`MulticlassClassificationEvaluator`",
+        "C": "`BinaryClassificationEvaluator`",
+        "D": "`ClusteringEvaluator`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`BinaryClassificationEvaluator` is used for binary classification problems. It supports metrics such as `areaUnderROC` (AUC) and `areaUnderPR`. `MulticlassClassificationEvaluator` supports more than two classes with metrics like accuracy and F1. `RegressionEvaluator` is for regression tasks.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q037",
+      "domain": "feature-engineering",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "A data scientist trains a model with Feature Store features. They call `FeatureStoreClient.log_model()` instead of `mlflow.sklearn.log_model()`. What is the key advantage?",
+      "choices": {
+        "A": "The model is automatically deployed to a serving endpoint",
+        "B": "The model artifact includes feature lookup metadata, enabling `score_batch()` to automatically retrieve features during inference",
+        "C": "The model is stored in Delta Lake instead of the MLflow artifact store",
+        "D": "The model skips cross-validation and uses the full dataset for training"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "When you log a model with `FeatureStoreClient.log_model()`, the feature lookup metadata (table names, primary keys, feature names) is stored alongside the model artifact. This metadata is later used by `FeatureStoreClient.score_batch()` to automatically retrieve the correct features from the Feature Store during batch inference, preventing train-serve skew.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q038",
+      "domain": "feature-engineering",
+      "title": "Question 38",
+      "difficulty": "medium",
+      "question": "A data scientist applies `Normalizer(p=2.0)` to a feature vector. What transformation is applied?",
+      "choices": {
+        "A": "Each feature value is divided by the maximum value in the column",
+        "B": "Each row vector is scaled to have unit L2 norm",
+        "C": "Each feature value is transformed to have zero mean and unit variance",
+        "D": "Each feature value is scaled to the range [0, 1]"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`Normalizer` with `p=2.0` scales each **row** vector to unit L2 norm (Euclidean norm). This is row-wise normalization, not column-wise. `MinMaxScaler` scales to [0, 1], `StandardScaler` applies z-score normalization, and neither is `Normalizer`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q039",
+      "domain": "feature-engineering",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "A data scientist's `CrossValidator` is running slowly because the parameter grid has 100 combinations and 5 folds (500 total training runs). Which `CrossValidator` parameter reduces wall-clock time by training multiple combinations simultaneously?",
+      "choices": {
+        "A": "`numFolds=2` — reduces the number of folds",
+        "B": "`parallelism=8` — trains up to 8 combinations concurrently",
+        "C": "`seed=42` — enables deterministic caching",
+        "D": "`collectSubModels=True` — reduces memory overhead"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`parallelism` controls how many (hyperparameter combination, fold) pairs are trained concurrently. Setting `parallelism=8` can reduce wall-clock time by up to 8×. Reducing `numFolds` also reduces training runs but decreases estimate reliability. `seed` and `collectSubModels` do not affect parallelism.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q040",
+      "domain": "feature-engineering",
+      "title": "Question 40",
+      "difficulty": "hard",
+      "question": "A data scientist uses `Pipeline` with stages `[indexer, encoder, assembler, classifier]`. During `pipeline.fit(train_df)`, which stages call `.fit()` vs `.transform()`?",
+      "choices": {
+        "A": "All stages call `.fit()` then `.transform()` sequentially",
+        "B": "Only the classifier (last stage) calls `.fit()`; all others call only `.transform()`",
+        "C": "`Estimator` stages (e.g., indexer, classifier) call `.fit()` then `.transform()`; `Transformer` stages call only `.transform()`",
+        "D": "All stages call `.transform()` only; `.fit()` is called once at the pipeline level"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "During `Pipeline.fit()`, each stage is processed in order. `Estimator` stages (like `StringIndexer` and `RandomForestClassifier`) call `.fit(df)` to learn parameters, then `.transform(df)` to produce the output DataFrame for the next stage. `Transformer` stages (like `VectorAssembler` and `OneHotEncoderModel`) call only `.transform(df)` since they have no parameters to learn.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q041",
+      "domain": "feature-engineering",
+      "title": "Question 41",
+      "difficulty": "medium",
+      "question": "A data scientist wants to retrieve feature values from a Feature Store table for a list of customer IDs to prepare a batch scoring dataset. Which function retrieves features without performing model inference?",
+      "choices": {
+        "A": "`FeatureStoreClient.score_batch(model_uri, entity_df)`",
+        "B": "`FeatureStoreClient.read_table(table_name)`",
+        "C": "`FeatureStoreClient.create_training_set(df, feature_lookups, label=None)`",
+        "D": "`FeatureStoreClient.get_table(table_name)`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`FeatureStoreClient.create_training_set()` retrieves features from Feature Store tables by joining on primary keys, supporting point-in-time lookups if a timestamp key is provided. Setting `label=None` creates a feature dataset for scoring without a target column. `read_table()` reads the full table. `score_batch()` performs inference. `get_table()` returns table metadata only.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q042",
+      "domain": "mlflow-deployment",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "A data scientist wants to create a custom MLflow model that wraps a proprietary scoring library. Which MLflow class should they subclass?",
+      "choices": {
+        "A": "`mlflow.pyfunc.BaseModel`",
+        "B": "`mlflow.pyfunc.PythonModel`",
+        "C": "`mlflow.sklearn.SklearnModel`",
+        "D": "`mlflow.models.CustomModel`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.pyfunc.PythonModel` is the base class for custom MLflow models. By subclassing it and implementing the `predict(context, model_input)` method, data scientists can wrap any arbitrary Python logic, including proprietary libraries, as a deployable MLflow model. `BaseModel`, `SklearnModel`, and `CustomModel` do not exist in the MLflow API.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q043",
+      "domain": "mlflow-deployment",
+      "title": "Question 43",
+      "difficulty": "hard",
+      "question": "A model is in Production in the Model Registry. A new, better version has been trained and registered as version 5. A data scientist wants to promote version 5 to Production and archive version 4. What is the correct sequence of API calls?",
+      "choices": {
+        "A": "Call `transition_model_version_stage(version=5, stage=\"Production\")` only — version 4 is automatically archived",
+        "B": "Call `transition_model_version_stage(version=5, stage=\"Production\")` with `archive_existing_versions=True`",
+        "C": "Call `delete_model_version(version=4)` first, then `transition_model_version_stage(version=5, stage=\"Production\")`",
+        "D": "Call `transition_model_version_stage(version=5, stage=\"Staging\")` first, then promote to Production in a separate call"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`MlflowClient().transition_model_version_stage(name, version, stage, archive_existing_versions=True)` promotes the specified version to Production and automatically archives all existing Production versions in a single call. This is the recommended approach for clean Production transitions.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q044",
+      "domain": "mlflow-deployment",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "A data scientist loads a model using `mlflow.pyfunc.load_model(\"models:/my-model/Production\")` and calls `model.predict(df)`. The model was trained with scikit-learn. What type does `df` need to be?",
+      "choices": {
+        "A": "A Spark DataFrame",
+        "B": "A pandas DataFrame or numpy array (inputs compatible with the sklearn model's `predict()`)",
+        "C": "A Python list of dictionaries",
+        "D": "A Delta Lake table path string"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.pyfunc.load_model()` returns a `PyFuncModel` whose `predict()` method accepts pandas DataFrames or numpy arrays — the same inputs that the underlying sklearn model accepts. For Spark-based distributed scoring, use `mlflow.pyfunc.spark_udf()` instead.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-associate-mock-2-q045",
+      "domain": "mlflow-deployment",
+      "title": "Question 45",
+      "difficulty": "medium",
+      "question": "A data scientist registers the same model artifact to two different registered model names: `model-v1` and `model-v2`. Both point to `runs:/abc123/model`. Which statement is true?",
+      "choices": {
+        "A": "This raises an error — a run artifact can only be registered to one model name",
+        "B": "Both registrations succeed, each creating version 1 of their respective model names",
+        "C": "Only the first registration succeeds; the second is rejected as a duplicate",
+        "D": "The second registration automatically increments the version on `model-v1`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "MLflow allows registering the same run artifact to multiple model names. Each registration is independent and creates version 1 of the respective registered model. This is useful for A/B testing or maintaining separate staging and production model lineages from the same training run.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "ml-associate"
+}
diff --git a/practice/data/ml-associate.json b/practice/data/ml-associate.json
index fd08aac..346cf0b 100644
--- a/practice/data/ml-associate.json
+++ b/practice/data/ml-associate.json
@@ -2,7 +2,7 @@
   "cert": "ml-associate",
   "certTitle": "ML Associate",
   "blueprintVersion": "Mar 1, 2025",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "databricks-ml",
diff --git a/practice/data/ml-professional-mock-1.json b/practice/data/ml-professional-mock-1.json
new file mode 100644
index 0000000..4749b44
--- /dev/null
+++ b/practice/data/ml-professional-mock-1.json
@@ -0,0 +1,756 @@
+{
+  "cert": "ml-professional-mock-1",
+  "certTitle": "ML Professional — Mock Exam 1",
+  "blueprintVersion": "Sep 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "feature-engineering",
+      "name": "Feature Engineering",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "hyperparameter-optimization",
+      "name": "Hyperparameter Optimization",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "model-production-lifecycle",
+      "name": "Model Production Lifecycle",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam/questions.md",
+      "questionCount": 14
+    },
+    {
+      "id": "model-governance-mlops",
+      "name": "Model Governance & MLOps",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam/questions.md",
+      "questionCount": 13
+    }
+  ],
+  "questions": [
+    {
+      "id": "ml-professional-mock-1-q001",
+      "domain": "feature-engineering",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "**What primary key constraint must a feature table have for Databricks Feature Engineering in UC?**",
+      "choices": {
+        "A": "No constraint — any column can serve as the key",
+        "B": "Must declare a primary key column to enable point-in-time lookups and online serving",
+        "C": "Must be named `entity_id`",
+        "D": "Must be a numeric integer type"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Feature tables in UC require a declared primary key column. This enables entity-based lookups at serving time and supports point-in-time correct joins during training set creation.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q002",
+      "domain": "feature-engineering",
+      "title": "Question 2",
+      "difficulty": "easy",
+      "question": "**A team wants to compute and register features for reuse across multiple ML projects. Which API should they use?**",
+      "choices": {
+        "A": "`mlflow.MlflowClient`",
+        "B": "`databricks.feature_engineering.FeatureEngineeringClient`",
+        "C": "`pyspark.ml.Pipeline`",
+        "D": "`databricks.sdk.WorkspaceClient`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`FeatureEngineeringClient` is the correct API for managing Databricks Feature Engineering in Unity Catalog feature tables.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q003",
+      "domain": "feature-engineering",
+      "title": "Question 3",
+      "difficulty": "easy",
+      "question": "**`FeatureEngineeringClient.create_training_set()` returns which object?**",
+      "choices": {
+        "A": "A Spark DataFrame directly",
+        "B": "A `FeatureEngineeringTrainingSet` that must be converted with `.load_df()`",
+        "C": "An MLflow dataset object",
+        "D": "A pandas DataFrame"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`create_training_set()` returns a `FeatureEngineeringTrainingSet`. Call `.load_df()` on it to get the actual training DataFrame.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q004",
+      "domain": "feature-engineering",
+      "title": "Question 4",
+      "difficulty": "medium",
+      "question": "**A model deployed via `fe.log_model()` is served from an endpoint. How does the endpoint retrieve feature values for incoming requests?**",
+      "choices": {
+        "A": "The client application must include all feature values in every request",
+        "B": "The endpoint automatically retrieves features from the online store using the entity key in the request",
+        "C": "A separate feature computation pipeline must run before each prediction",
+        "D": "Features are cached at endpoint startup"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Feature Engineering in UC automatically links the model to its feature tables; at serving time, the endpoint retrieves features from the online store using only the entity key.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q005",
+      "domain": "feature-engineering",
+      "title": "Question 5",
+      "difficulty": "easy",
+      "question": "**What is \"point-in-time correct\" feature retrieval?**",
+      "choices": {
+        "A": "Retrieving the most recently computed feature values",
+        "B": "Retrieving feature values that were available at the time of each label's event timestamp, preventing future data leakage",
+        "C": "Retrieving features refreshed within the past hour",
+        "D": "Retrieving features at exactly midnight each day"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Point-in-time correct retrieval joins features to labels using timestamps so that only data available before the label's event time is used, preventing data leakage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q006",
+      "domain": "feature-engineering",
+      "title": "Question 6",
+      "difficulty": "easy",
+      "question": "**Which `FeatureLookup` parameter enables point-in-time correct retrieval?**",
+      "choices": {
+        "A": "`lookup_key`",
+        "B": "`feature_names`",
+        "C": "`timestamp_lookup_key`",
+        "D": "`event_time_col`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "`timestamp_lookup_key` specifies the column to use as the event timestamp for point-in-time joins.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q007",
+      "domain": "feature-engineering",
+      "title": "Question 7",
+      "difficulty": "easy",
+      "question": "**A feature requires < 10ms retrieval latency for real-time serving. Where should the feature values be published?**",
+      "choices": {
+        "A": "Delta Lake offline store only",
+        "B": "Online store (Redis-backed)",
+        "C": "Parquet files in ADLS",
+        "D": "MLflow artifact store"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The online store provides millisecond-latency access required for real-time inference. The Delta offline store is suitable for batch and training, not real-time serving.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q008",
+      "domain": "feature-engineering",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "**Train-serving skew is caused by:**",
+      "choices": {
+        "A": "The model being retrained too frequently",
+        "B": "Feature computation logic differing between the training pipeline and the serving pipeline",
+        "C": "The online store going offline during serving",
+        "D": "Using a stale version of the model"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Train-serving skew occurs when features are computed differently at training time vs serving time, causing the model to see different data distributions than it was trained on.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q009",
+      "domain": "feature-engineering",
+      "title": "Question 9",
+      "difficulty": "easy",
+      "question": "**A data scientist calls `fe.write_table(df=features_df, name=\"catalog.schema.user_features\")` and the table does not yet exist. What happens?**",
+      "choices": {
+        "A": "An error is raised — must call `create_table()` first",
+        "B": "The feature table is created automatically with schema inferred from the DataFrame",
+        "C": "The DataFrame is written as a regular unmanaged Delta table",
+        "D": "The call fails unless the online store is configured"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`write_table` creates the feature table if it doesn't exist, inferring the schema from the DataFrame.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q010",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 10",
+      "difficulty": "easy",
+      "question": "**A data scientist runs Hyperopt with `Trials()` on a 20-node Databricks cluster. How many trials run in parallel?**",
+      "choices": {
+        "A": "20 — one per worker",
+        "B": "1 — `Trials` runs locally on the driver node only",
+        "C": "Based on number of CPU cores on the driver",
+        "D": "Based on the `parallelism` parameter"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`Trials` is a local, single-process object. Use `SparkTrials` to distribute Hyperopt across the cluster.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q011",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "**What must the Hyperopt objective function return to signal a failed trial?**",
+      "choices": {
+        "A": "`None`",
+        "B": "`{'loss': float('inf'), 'status': STATUS_OK}`",
+        "C": "`{'status': STATUS_FAIL}`",
+        "D": "Raise an exception"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Return `{'status': STATUS_FAIL}` to signal a failed trial without crashing the entire search. The trial is skipped and the next configuration is tried.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q012",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "**Which `hp.*` function is best for tuning a learning rate over the range 1e-5 to 1e-1?**",
+      "choices": {
+        "A": "`hp.uniform('lr', 1e-5, 1e-1)`",
+        "B": "`hp.loguniform('lr', np.log(1e-5), np.log(1e-1))`",
+        "C": "`hp.choice('lr', [1e-5, 1e-4, 1e-3, 1e-2, 1e-1])`",
+        "D": "`hp.randint('lr', 5)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Log-uniform search allocates equal probability to each order of magnitude. `hp.uniform` would concentrate most trials near the upper end of the range.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q013",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "**`mlflow.autolog()` is enabled and Hyperopt runs 50 trials with `SparkTrials`. How are MLflow runs organized?**",
+      "choices": {
+        "A": "50 separate top-level runs",
+        "B": "1 parent run with 50 child runs (one per trial)",
+        "C": "1 run with 50 nested metrics",
+        "D": "No runs created — autolog doesn't support Hyperopt"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "MLflow autolog with Hyperopt creates a parent run for the `fmin()` call and a child run for each individual trial.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q014",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 14",
+      "difficulty": "easy",
+      "question": "**A `CrossValidator` with `numFolds=5` evaluates a parameter grid with 12 combinations. How many models are trained total?**",
+      "choices": {
+        "A": "12",
+        "B": "5",
+        "C": "60",
+        "D": "17"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Each of the 12 parameter combinations is trained on 5 folds = 60 models total.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q015",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 15",
+      "difficulty": "medium",
+      "question": "**When does Bayesian optimization (TPE) outperform random search most significantly?**",
+      "choices": {
+        "A": "When the search space is very small (< 10 combinations)",
+        "B": "When compute budget is limited relative to the search space size",
+        "C": "When all hyperparameters are categorical",
+        "D": "When the objective function is convex"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Bayesian optimization shines when you have limited trials: it uses results from past trials to prioritize promising regions, whereas random search wastes budget on unpromising areas.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q016",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 16",
+      "difficulty": "easy",
+      "question": "**What does `parallelism=8` in `SparkTrials(parallelism=8)` control?**",
+      "choices": {
+        "A": "Number of Spark partitions per trial",
+        "B": "Number of trials that run simultaneously across the cluster",
+        "C": "Number of MLflow child runs per trial",
+        "D": "Number of cross-validation folds"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`parallelism` in SparkTrials controls how many Hyperopt trials execute concurrently across the Spark cluster.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q017",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "**The `early_stop_fn` parameter in `fmin()` allows:**",
+      "choices": {
+        "A": "Stopping individual trials that exceed a time limit",
+        "B": "Stopping the entire search early if improvement has stalled",
+        "C": "Stopping cluster auto-scaling during tuning",
+        "D": "Stopping MLflow logging mid-search"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`early_stop_fn` is called after each trial and can signal `fmin()` to stop searching early based on custom logic (e.g., no improvement in last N trials).",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q018",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 18",
+      "difficulty": "medium",
+      "question": "**A team has budget for 30 trials to tune 6 hyperparameters. Which strategy is most efficient?**",
+      "choices": {
+        "A": "Grid search — guarantees coverage",
+        "B": "Random search",
+        "C": "Bayesian optimization (TPE via Hyperopt)",
+        "D": "Manual search based on intuition"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "With 30 trials over 6 parameters, Bayesian optimization uses previous results to guide the search, typically finding better configurations than random search in the same budget.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q019",
+      "domain": "model-production-lifecycle",
+      "title": "Question 19",
+      "difficulty": "easy",
+      "question": "**Which URI loads a model from the UC registry by alias?**",
+      "choices": {
+        "A": "`models:/fraud_classifier@champion`",
+        "B": "`models:/ml_catalog.fraud_models.fraud_classifier@champion`",
+        "C": "`uc://ml_catalog/fraud_models/fraud_classifier@champion`",
+        "D": "`mlflow://ml_catalog.fraud_models.fraud_classifier:champion`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "UC model URIs use the full three-level namespace followed by `@alias`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q020",
+      "domain": "model-production-lifecycle",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "**A serving endpoint with `scale_to_zero_enabled=True` hasn't received traffic for 45 minutes. What happens to the next request?**",
+      "choices": {
+        "A": "The request fails with a 503 error",
+        "B": "The request succeeds after a 60-120 second cold start delay",
+        "C": "The request returns from cache immediately",
+        "D": "Auto-scaling resumes within 1 second"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Scale-to-zero deprovisions compute when idle. The first request after idle must wait for cluster startup, typically 60-120 seconds.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q021",
+      "domain": "model-production-lifecycle",
+      "title": "Question 21",
+      "difficulty": "easy",
+      "question": "**`mlflow.pyfunc.spark_udf()` runs inference on which Spark component?**",
+      "choices": {
+        "A": "Driver node only",
+        "B": "Spark executors (distributed across the cluster)",
+        "C": "Databricks SQL warehouse",
+        "D": "A dedicated GPU cluster"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`spark_udf` distributes inference across Spark executors, enabling parallel scoring of millions of rows.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q022",
+      "domain": "model-production-lifecycle",
+      "title": "Question 22",
+      "difficulty": "medium",
+      "question": "**A model is registered to the workspace registry (no `set_registry_uri` call). Which UC feature is unavailable?**",
+      "choices": {
+        "A": "Model aliases",
+        "B": "Version tags",
+        "C": "UC lineage tracking and cross-catalog permissions",
+        "D": "Model descriptions"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "UC lineage and GRANT/REVOKE on model objects require the UC registry. The workspace registry supports aliases and tags but not UC governance features.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q023",
+      "domain": "model-production-lifecycle",
+      "title": "Question 23",
+      "difficulty": "medium",
+      "question": "**Which statement about model aliases is TRUE?**",
+      "choices": {
+        "A": "Each model can have only one alias at a time",
+        "B": "Aliases are named pointers — changing the pointed-to version doesn't require updating application code",
+        "C": "Aliases replace version numbers entirely",
+        "D": "Aliases are equivalent to legacy lifecycle stages"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "This is the core value of aliases: application code uses `models:/name@champion`, and promotion is just reassigning the alias to a different version.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q024",
+      "domain": "model-production-lifecycle",
+      "title": "Question 24",
+      "difficulty": "easy",
+      "question": "**An endpoint has champion at 80% and challenger at 10% traffic. Is this a valid configuration?**",
+      "choices": {
+        "A": "Yes — challenger traffic below 50% is fine",
+        "B": "No — percentages must sum to exactly 100%",
+        "C": "Yes — Databricks distributes the remaining 10% randomly",
+        "D": "No — only two served models are allowed per endpoint"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Traffic config percentages must sum to exactly 100%. The configuration described (80% + 10% = 90%) is invalid.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q025",
+      "domain": "model-production-lifecycle",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "**Which deployment pattern runs the challenger model in parallel without serving its predictions to users?**",
+      "choices": {
+        "A": "Canary deployment",
+        "B": "Blue-green deployment",
+        "C": "Shadow deployment",
+        "D": "A/B testing"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Shadow deployment sends all traffic to the champion but also runs the challenger silently, logging its predictions for offline comparison with zero user impact.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q026",
+      "domain": "model-production-lifecycle",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "**What enables automatic logging of all requests and responses from a serving endpoint to a Delta table?**",
+      "choices": {
+        "A": "`MonitorInferenceLog` in Lakehouse Monitoring",
+        "B": "`AutoCaptureConfigInput` in the endpoint configuration",
+        "C": "`mlflow.langchain.autolog()`",
+        "D": "Delta Streaming from the endpoint logs"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`AutoCaptureConfigInput` (inference tables) is configured on the serving endpoint and automatically logs all request/response payloads to a Delta table.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q027",
+      "domain": "model-production-lifecycle",
+      "title": "Question 27",
+      "difficulty": "medium",
+      "question": "**A `PythonModel` subclass needs to load a pre-trained tokenizer at serving time. The tokenizer is stored locally as a file. How should it be packaged with the model?**",
+      "choices": {
+        "A": "Hardcode the file path in the `predict()` method",
+        "B": "Pass it as an environment variable",
+        "C": "Include it in the `artifacts` dict in `mlflow.pyfunc.log_model()` and load it in `load_context()`",
+        "D": "Store it in DBFS and access it from the model"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `artifacts` dict in `log_model()` specifies local files to bundle with the model; `load_context()` receives the resolved paths via `context.artifacts`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q028",
+      "domain": "model-production-lifecycle",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "**Which task dependency setting ensures an integration test task runs only if the evaluation gate task succeeds?**",
+      "choices": {
+        "A": "`depends_on: [evaluation_gate]` only",
+        "B": "`run_if: ALL_SUCCESS` with `depends_on: [evaluation_gate]`",
+        "C": "`run_if: AT_LEAST_ONE_SUCCESS`",
+        "D": "No special configuration — tasks always wait for predecessors"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`run_if: ALL_SUCCESS` plus the `depends_on` dependency ensures the task runs only when all upstream tasks have completed successfully.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q029",
+      "domain": "model-production-lifecycle",
+      "title": "Question 29",
+      "difficulty": "medium",
+      "question": "**Drift-triggered retraining uses which mechanism to start a Databricks Job?**",
+      "choices": {
+        "A": "Scheduled cron expression",
+        "B": "SQL alert → webhook → Databricks Jobs REST API",
+        "C": "Auto-trigger based on MLflow metric threshold",
+        "D": "Git push to the model training branch"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Monitoring alerts (Databricks SQL alerts or Lakehouse Monitoring alerts) fire webhooks to external systems; the webhook calls the Databricks Jobs REST API to trigger a retraining run.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q030",
+      "domain": "model-production-lifecycle",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "**For real-time fraud detection requiring < 50ms response time, which deployment mode is correct?**",
+      "choices": {
+        "A": "Batch scoring with `spark_udf`",
+        "B": "REST endpoint with `scale_to_zero_enabled=False`",
+        "C": "Streaming inference with a 30-second trigger",
+        "D": "Scheduled scoring job every 5 minutes"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "REST endpoint provides sub-100ms latency; disabling scale_to_zero eliminates cold start risk for latency-sensitive workloads.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q031",
+      "domain": "model-production-lifecycle",
+      "title": "Question 31",
+      "difficulty": "hard",
+      "question": "**A custom pyfunc model returns predictions as a DataFrame with columns `[score, label]`. What should `result_type` be in `spark_udf()`?**",
+      "choices": {
+        "A": "`\"double\"`",
+        "B": "`\"string\"`",
+        "C": "`StructType([StructField(\"score\", DoubleType()), StructField(\"label\", StringType())])`",
+        "D": "`\"array<double>\"`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "When the pyfunc returns a multi-column DataFrame, `result_type` must be a Spark `StructType` matching the output columns.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q032",
+      "domain": "model-production-lifecycle",
+      "title": "Question 32",
+      "difficulty": "medium",
+      "question": "**What is the purpose of archiving the previous `champion` alias as `previous_champion` during promotion?**",
+      "choices": {
+        "A": "Required by MLflow API",
+        "B": "Enables quick rollback by setting `champion` back to the `previous_champion` version",
+        "C": "Prevents the old version from being deleted",
+        "D": "Required for UC audit compliance"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Keeping a `previous_champion` alias allows one-command rollback: `client.set_registered_model_alias(name, \"champion\", prev_version)`.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q033",
+      "domain": "model-governance-mlops",
+      "title": "Question 33",
+      "difficulty": "easy",
+      "question": "**Feature PSI = 0.05 this week. What action should you take?**",
+      "choices": {
+        "A": "Retrain the model immediately",
+        "B": "Investigate the upstream data pipeline",
+        "C": "No action — PSI < 0.10 indicates stable population",
+        "D": "Enable Lakehouse Monitoring"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "PSI < 0.10 means no significant population shift. Continue regular monitoring cadence.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q034",
+      "domain": "model-governance-mlops",
+      "title": "Question 34",
+      "difficulty": "medium",
+      "question": "**A model's AUC dropped from 0.92 to 0.84 over 3 weeks with ground truth labels available. Which drift type explains this?**",
+      "choices": {
+        "A": "Data drift — features changed",
+        "B": "Prediction drift — outputs changed",
+        "C": "Concept drift — the input-output relationship changed",
+        "D": "Label drift — target class balance shifted"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Measurable performance degradation (AUC drop) with ground truth labels indicates concept drift: the relationship between features and the target has changed.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q035",
+      "domain": "model-governance-mlops",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "**Which column in a Databricks inference table identifies which model version handled each request (for A/B analysis)?**",
+      "choices": {
+        "A": "`model_version`",
+        "B": "`served_model_name`",
+        "C": "`databricks_request_id`",
+        "D": "`endpoint_name`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The `served_model_name` field (extracted from the request JSON) identifies which served model configuration handled each request.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q036",
+      "domain": "model-governance-mlops",
+      "title": "Question 36",
+      "difficulty": "easy",
+      "question": "**Which Lakehouse Monitoring monitor type is appropriate for a static, snapshot Delta table with no timestamp column?**",
+      "choices": {
+        "A": "TimeSeries",
+        "B": "InferenceLog",
+        "C": "Snapshot",
+        "D": "DriftProfile"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Snapshot monitors compute statistics on the entire table as-is, without time-window partitioning.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q037",
+      "domain": "model-governance-mlops",
+      "title": "Question 37",
+      "difficulty": "easy",
+      "question": "**UC audit logs capture which ML-related event?**",
+      "choices": {
+        "A": "Model training duration",
+        "B": "Hyperopt trial results",
+        "C": "`updateModelVersionAlias` — alias changes (model promotions)",
+        "D": "MLflow autolog metrics"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "UC audit logs capture governance events including alias updates (promotions), permission grants, and model registrations.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q038",
+      "domain": "model-governance-mlops",
+      "title": "Question 38",
+      "difficulty": "easy",
+      "question": "**The GDPR Article 22 requirement that affects ML models is:**",
+      "choices": {
+        "A": "Data must be encrypted at rest",
+        "B": "Models must be retrained every 6 months",
+        "C": "Individuals have the right to meaningful explanation of automated decisions affecting them",
+        "D": "Predictions must be stored for 7 years"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Article 22 grants individuals the right to not be subject to solely automated decisions and requires meaningful explanation. SHAP values are the standard technical control.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q039",
+      "domain": "model-governance-mlops",
+      "title": "Question 39",
+      "difficulty": "medium",
+      "question": "**Equalized odds as a fairness metric requires:**",
+      "choices": {
+        "A": "Equal accuracy across demographic groups",
+        "B": "Equal true positive rates and equal false positive rates across groups",
+        "C": "Equal approval rates across groups",
+        "D": "Equal training data representation across groups"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Equalized odds (Hardt et al.) requires both TPR and FPR to be equal across protected groups, making it stricter than demographic parity (which only requires equal positive prediction rates).",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q040",
+      "domain": "model-governance-mlops",
+      "title": "Question 40",
+      "difficulty": "medium",
+      "question": "**A model has PSI = 0.28 on prediction scores (not features). What does this indicate?**",
+      "choices": {
+        "A": "The model is stable",
+        "B": "Input features have drifted",
+        "C": "Model output distribution has shifted significantly — potential concept drift or upstream data change",
+        "D": "The online store is returning stale values"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "High PSI on prediction scores indicates the model is producing very different outputs than it did against the baseline. Investigate whether upstream data or the concept has changed.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q041",
+      "domain": "model-governance-mlops",
+      "title": "Question 41",
+      "difficulty": "hard",
+      "question": "**Which UC permission allows a data scientist to register new model versions but NOT change the `champion` alias?**",
+      "choices": {
+        "A": "`EXECUTE ON MODEL`",
+        "B": "`SELECT ON MODEL`",
+        "C": "`MODIFY ON MODEL` (both registering and alias setting require MODIFY — use process controls)",
+        "D": "`CREATE ON SCHEMA`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Both registering new versions and setting aliases require `MODIFY`. There is no separate UC permission to separate these; process-level controls (PR review, approval workflows) enforce the distinction.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q042",
+      "domain": "model-governance-mlops",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "**A Delta table contains PII (email addresses) that must be hidden from data scientists but visible to the ML platform team. Which control should be used?**",
+      "choices": {
+        "A": "Row-level security",
+        "B": "Delta column masking policy",
+        "C": "Separate Delta table without PII",
+        "D": "Encrypt the column with a user-specific key"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Delta column masking applies a masking function at query time, showing masked values to unauthorized users while platform team queries see real values.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q043",
+      "domain": "model-governance-mlops",
+      "title": "Question 43",
+      "difficulty": "easy",
+      "question": "**Databricks Lakehouse Monitoring outputs a `_drift_metrics` table. What columns does this table contain?**",
+      "choices": {
+        "A": "Raw feature values from production",
+        "B": "Statistical drift measures (e.g., KS statistic, chi-square, PSI) per feature per time window compared to baseline",
+        "C": "Model hyperparameters",
+        "D": "MLflow run IDs for the monitored model"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The drift metrics table contains per-feature, per-window drift statistics comparing the current window profile to the baseline profile.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q044",
+      "domain": "model-governance-mlops",
+      "title": "Question 44",
+      "difficulty": "medium",
+      "question": "**After retraining a model and promoting it to champion, what must be updated in Lakehouse Monitoring?**",
+      "choices": {
+        "A": "The monitor type",
+        "B": "The baseline table — update it to reflect the new model's training distribution",
+        "C": "The alert thresholds",
+        "D": "Nothing — LHM automatically detects the new champion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The baseline table should be updated after a significant model change (new training data, new features) so that drift metrics compare against the new model's expected distribution, not the old one.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-1-q045",
+      "domain": "model-governance-mlops",
+      "title": "Question 45",
+      "difficulty": "medium",
+      "question": "**A compliance evidence package for a high-risk ML model must include which item?**",
+      "choices": {
+        "A": "Source code for all Spark jobs",
+        "B": "Bias test results demonstrating the model meets fairness thresholds",
+        "C": "A list of all MLflow experiments in the workspace",
+        "D": "Cloud infrastructure cost reports"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Bias and fairness test results are critical compliance evidence for high-risk models, demonstrating that the model was evaluated for discriminatory impact before deployment.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "ml-professional"
+}
diff --git a/practice/data/ml-professional-mock-2.json b/practice/data/ml-professional-mock-2.json
new file mode 100644
index 0000000..6b200c6
--- /dev/null
+++ b/practice/data/ml-professional-mock-2.json
@@ -0,0 +1,756 @@
+{
+  "cert": "ml-professional-mock-2",
+  "certTitle": "ML Professional — Mock Exam 2",
+  "blueprintVersion": "Sep 2025",
+  "generated": "2026-05-22",
+  "domains": [
+    {
+      "id": "feature-engineering",
+      "name": "Feature Engineering",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "hyperparameter-optimization",
+      "name": "Hyperparameter Optimization",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 9
+    },
+    {
+      "id": "model-production-lifecycle",
+      "name": "Model Production Lifecycle",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 14
+    },
+    {
+      "id": "model-governance-mlops",
+      "name": "Model Governance & MLOps",
+      "sourceFile": "certifications/ml-professional/resources/mock-exam-2/questions.md",
+      "questionCount": 13
+    }
+  ],
+  "questions": [
+    {
+      "id": "ml-professional-mock-2-q001",
+      "domain": "feature-engineering",
+      "title": "Question 1",
+      "difficulty": "easy",
+      "question": "**Which method in `FeatureEngineeringClient` retrieves feature table metadata?**",
+      "choices": {
+        "A": "`get_table()`",
+        "B": "`describe_table()`",
+        "C": "`read_table()`",
+        "D": "`inspect_table()`"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`fe.get_table(name=\"catalog.schema.feature_table\")` retrieves the FeatureTable metadata object including schema, primary keys, and timestamp column.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q002",
+      "domain": "feature-engineering",
+      "title": "Question 2",
+      "difficulty": "medium",
+      "question": "**A feature table has `user_id` as primary key and `event_time` as the timestamp column. Which `FeatureLookup` parameters are needed for point-in-time retrieval?**",
+      "choices": {
+        "A": "`lookup_key=\"user_id\"` only",
+        "B": "`lookup_key=\"user_id\"` and `timestamp_lookup_key=\"event_time\"`",
+        "C": "`timestamp_lookup_key=\"event_time\"` only",
+        "D": "`feature_names=[\"user_id\", \"event_time\"]`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Both lookup_key (for entity matching) and timestamp_lookup_key (for point-in-time join) are required for temporally correct feature retrieval.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q003",
+      "domain": "feature-engineering",
+      "title": "Question 3",
+      "difficulty": "medium",
+      "question": "**What is the relationship between the offline and online feature stores?**",
+      "choices": {
+        "A": "They are identical — same storage, different access patterns",
+        "B": "Offline (Delta) stores historical feature values; online (Redis-backed) stores the latest values for real-time serving",
+        "C": "Online store is a cache of the offline store with 24-hour TTL",
+        "D": "They are separate systems with no automatic synchronization"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The offline store (Delta Lake) holds all historical feature values for training and batch scoring. The online store holds the latest values for real-time inference. `publish_online_features()` syncs from offline to online.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q004",
+      "domain": "feature-engineering",
+      "title": "Question 4",
+      "difficulty": "medium",
+      "question": "**A team logs a model using `mlflow.sklearn.log_model()` instead of `fe.log_model()`. What is the consequence for feature lineage?**",
+      "choices": {
+        "A": "No consequence — both methods capture feature lineage",
+        "B": "Feature table dependencies are NOT automatically linked to the model version",
+        "C": "The model cannot be registered to the UC registry",
+        "D": "Point-in-time features will not work at serving time"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Only `fe.log_model()` (FeatureEngineeringClient) captures the feature table dependencies and enables automatic feature retrieval at serving. `mlflow.sklearn.log_model()` does not capture this lineage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q005",
+      "domain": "feature-engineering",
+      "title": "Question 5",
+      "difficulty": "easy",
+      "question": "**`publish_online_features()` is called on a feature table. What does this do?**",
+      "choices": {
+        "A": "Creates a new version of the offline feature table",
+        "B": "Synchronizes the latest feature values from Delta (offline) to the online store",
+        "C": "Runs feature engineering computation jobs",
+        "D": "Registers the feature table in the UC registry"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`publish_online_features()` pushes the latest feature values to the online (Redis-backed) store, making them available for real-time serving.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q006",
+      "domain": "feature-engineering",
+      "title": "Question 6",
+      "difficulty": "medium",
+      "question": "**A model at serving time needs to retrieve user features using only the `user_id` from the request. What is required in the feature table?**",
+      "choices": {
+        "A": "The feature table must have `user_id` as the primary key and be published to the online store",
+        "B": "The feature table must be a managed Delta table",
+        "C": "The model must include the feature computation logic internally",
+        "D": "The feature table must be co-located in the same catalog as the model"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "For automatic feature retrieval at serving, the feature table needs `user_id` as primary key (for lookup) and values in the online store (for low-latency access).",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q007",
+      "domain": "feature-engineering",
+      "title": "Question 7",
+      "difficulty": "medium",
+      "question": "**How does `FeatureEngineeringClient.create_training_set()` prevent data leakage?**",
+      "choices": {
+        "A": "It filters out test set records",
+        "B": "It uses `timestamp_lookup_key` to join feature values that were available before each label's event timestamp",
+        "C": "It randomly shuffles the training data",
+        "D": "It drops features that are correlated with the target"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The point-in-time join ensures features are joined only from the time period before the label's event occurred, preventing any future information from contaminating the training set.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q008",
+      "domain": "feature-engineering",
+      "title": "Question 8",
+      "difficulty": "medium",
+      "question": "**A data scientist needs feature lineage for compliance but does not need real-time serving. Which approach is correct?**",
+      "choices": {
+        "A": "Use `fe.log_model()` with only the offline store configured (no online store required)",
+        "B": "Use `mlflow.sklearn.log_model()` with manual lineage documentation",
+        "C": "Skip feature lineage — it's only needed for real-time serving",
+        "D": "Use a regular Delta table instead of a feature table"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`fe.log_model()` captures feature lineage (the connection between feature tables and the model) regardless of whether the online store is configured. The online store is only needed for real-time serving.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q009",
+      "domain": "feature-engineering",
+      "title": "Question 9",
+      "difficulty": "easy",
+      "question": "**What happens when two rows with the same primary key are written to a feature table using `fe.write_table()`?**",
+      "choices": {
+        "A": "An error is raised",
+        "B": "The existing row is updated (upserted) with the new values",
+        "C": "Both rows are retained (duplicates allowed)",
+        "D": "The new row is silently dropped"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Feature tables are designed for upsert semantics — writing a row with an existing primary key updates the existing record.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q010",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 10",
+      "difficulty": "medium",
+      "question": "**A data scientist defines `space = {'n_estimators': hp.quniform('n_estimators', 100, 1000, 100)}`. What values can `n_estimators` take?**",
+      "choices": {
+        "A": "Any float between 100 and 1000",
+        "B": "Integer multiples of 100 between 100 and 1000: 100, 200, ..., 1000",
+        "C": "Random floats between 0 and 1",
+        "D": "Only 100 and 1000"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`hp.quniform(label, low, high, q)` returns values rounded to the nearest multiple of `q`. With q=100, values are 100, 200, 300, ..., 1000.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q011",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 11",
+      "difficulty": "medium",
+      "question": "**A Spark ML `CrossValidator` with `numFolds=3` and `parallelism=3` trains a grid of 9 configurations. How many models train simultaneously?**",
+      "choices": {
+        "A": "3",
+        "B": "9",
+        "C": "27",
+        "D": "1"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "`parallelism=3` means 3 models train simultaneously. Total models = 9 × 3 = 27, trained in batches of 3.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q012",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 12",
+      "difficulty": "medium",
+      "question": "**What is the main advantage of `hp.loguniform` over `hp.uniform` for a regularization parameter like `alpha` ranging from 0.0001 to 1.0?**",
+      "choices": {
+        "A": "`hp.loguniform` is faster to compute",
+        "B": "`hp.loguniform` allocates equal probability to each order of magnitude (0.0001-0.001, 0.001-0.01, 0.01-0.1, 0.1-1.0), preventing bias toward large values",
+        "C": "`hp.loguniform` only works with positive values",
+        "D": "`hp.loguniform` is required for Bayesian optimization"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "On a linear scale, most trials would cluster near 1.0. Log scale ensures equal exploration across orders of magnitude, which matters for regularization and learning rate parameters.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q013",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 13",
+      "difficulty": "easy",
+      "question": "**AutoML is run on a classification task. Which outputs are produced?**",
+      "choices": {
+        "A": "Only the best model artifact",
+        "B": "A best-model notebook, a data exploration notebook, feature importance plots, and an MLflow experiment with all trial runs",
+        "C": "A hyperparameter configuration file only",
+        "D": "A trained model endpoint"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Databricks AutoML produces: a best-trial notebook (editable), a data exploration notebook, an MLflow experiment with runs for all tested algorithms, and the best model registered.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q014",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 14",
+      "difficulty": "medium",
+      "question": "**The objective function for Hyperopt returns `1 - accuracy`. Why not return `-accuracy`?**",
+      "choices": {
+        "A": "There is no practical difference",
+        "B": "Both are correct — either negation works because Hyperopt minimizes the returned loss",
+        "C": "`1 - accuracy` is more numerically stable",
+        "D": "`-accuracy` would cause Hyperopt to maximize, not minimize"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Both `1 - accuracy` and `-accuracy` correctly signal to Hyperopt to maximize accuracy (by minimizing the returned loss). Both are valid; the convention varies by team.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q015",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 15",
+      "difficulty": "hard",
+      "question": "**A team runs Hyperopt with `SparkTrials(parallelism=4)` and `max_evals=40`. Bayesian optimization (TPE) requires results from previous trials to suggest the next configuration. How does this work with parallelism?**",
+      "choices": {
+        "A": "Parallelism is disabled when using TPE",
+        "B": "TPE runs 4 random trials first (no history), then uses available results to suggest batches of 4 subsequent trials",
+        "C": "Each parallel trial accesses the same history simultaneously",
+        "D": "Parallelism only works with random search, not TPE"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "With parallelism > 1, TPE initially makes semi-random suggestions for the first batch, then incorporates completed trial results to suggest the next batch. This reduces but does not eliminate the Bayesian efficiency advantage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q016",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 16",
+      "difficulty": "medium",
+      "question": "**A model pipeline includes `VectorAssembler → StandardScaler → RandomForestClassifier`. A team wants to tune `RandomForestClassifier.numTrees` and `StandardScaler.withMean`. What object should wrap the tuning?**",
+      "choices": {
+        "A": "Tune only the `RandomForestClassifier` stage",
+        "B": "Wrap the entire `Pipeline` in `CrossValidator` — `ParamGridBuilder` can reference any stage's params",
+        "C": "Separate `CrossValidator` per stage",
+        "D": "Use Hyperopt on each stage independently"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`CrossValidator` wraps the full Pipeline. `ParamGridBuilder` uses `stage.paramName` syntax to reference params across any stage.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q017",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 17",
+      "difficulty": "easy",
+      "question": "**What does `no_progress_loss(n)` do in a Hyperopt early stopping function?**",
+      "choices": {
+        "A": "Stops if loss increases for n consecutive trials",
+        "B": "Stops if no improvement is seen in the best loss across the last n trials",
+        "C": "Stops after n total trials regardless of improvement",
+        "D": "Stops if any trial takes longer than n seconds"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`no_progress_loss(n)` is a built-in early stopping function that halts the search if the best observed loss hasn't improved in the last n trials.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q018",
+      "domain": "hyperparameter-optimization",
+      "title": "Question 18",
+      "difficulty": "easy",
+      "question": "**A data scientist wants to compare a fixed set of 8 hyperparameter combinations exhaustively. Which search strategy is most appropriate?**",
+      "choices": {
+        "A": "Bayesian optimization — always best",
+        "B": "Random search with max_evals=8",
+        "C": "Grid search — exhaustive when search space is fully enumerable and small",
+        "D": "AutoML"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "When the search space is small and fully known (8 combinations), grid search guarantees every combination is evaluated. Bayesian optimization overhead is unnecessary for such small spaces.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q019",
+      "domain": "model-production-lifecycle",
+      "title": "Question 19",
+      "difficulty": "easy",
+      "question": "**A model version is in the UC registry. What is the correct way to load the latest version tagged with alias `champion`?**",
+      "choices": {
+        "A": "`mlflow.sklearn.load_model(\"models:/catalog.schema.model/latest\")`",
+        "B": "`mlflow.pyfunc.load_model(\"models:/catalog.schema.model@champion\")`",
+        "C": "`MlflowClient().get_model_version_by_alias(name, \"champion\")`",
+        "D": "`mlflow.pyfunc.load_model(f\"models:/catalog.schema.model/{version_number}\")`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.pyfunc.load_model(\"models:/catalog.schema.model@champion\")` loads the version currently pointed to by the `champion` alias.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q020",
+      "domain": "model-production-lifecycle",
+      "title": "Question 20",
+      "difficulty": "medium",
+      "question": "**A team registers a model with `mlflow.sklearn.log_model(model, \"model\", registered_model_name=\"fraud_clf\")`. Which registry does this go to if `set_registry_uri` was not called?**",
+      "choices": {
+        "A": "UC registry in `main` catalog",
+        "B": "Workspace model registry",
+        "C": "The call fails — must call `set_registry_uri` first",
+        "D": "A temporary registry that expires after 30 days"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Without `mlflow.set_registry_uri(\"databricks-uc\")`, models are registered to the workspace registry (not UC). UC features like GRANT and lineage are unavailable.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q021",
+      "domain": "model-production-lifecycle",
+      "title": "Question 21",
+      "difficulty": "medium",
+      "question": "**A `ServedModelInput` is configured with `workload_size=SMALL` and a traffic of 100 RPS arrives. What happens?**",
+      "choices": {
+        "A": "Requests are queued until compute scales up",
+        "B": "The endpoint auto-scales to Medium/Large compute to handle the load",
+        "C": "Requests fail with 429 Too Many Requests until manually scaled",
+        "D": "SMALL size is fixed — it cannot auto-scale"
+      },
+      "correctAnswer": "A",
+      "shortAnswer": "Databricks Model Serving queues requests and auto-scales the serving compute based on traffic, with some queuing latency during scale-up.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q022",
+      "domain": "model-production-lifecycle",
+      "title": "Question 22",
+      "difficulty": "hard",
+      "question": "**Model signatures with `infer_signature()` are inferred from training data. Why might this cause a serving error?**",
+      "choices": {
+        "A": "Signatures are only valid for 30 days",
+        "B": "If the training data has extra columns (e.g., label column), the signature includes them; serving requests without those columns will fail schema validation",
+        "C": "`infer_signature` doesn't work for sklearn models",
+        "D": "Signatures with more than 10 features cause serving errors"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Always infer signature from the feature input (X) only, not the full training DataFrame including the label column.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q023",
+      "domain": "model-production-lifecycle",
+      "title": "Question 23",
+      "difficulty": "hard",
+      "question": "**In a multi-task Databricks Job, Task B `depends_on` Task A with `run_if: ALL_SUCCESS`. Task A is skipped because its condition was false. What happens to Task B?**",
+      "choices": {
+        "A": "Task B runs anyway",
+        "B": "Task B is also skipped",
+        "C": "Task B fails",
+        "D": "Task B waits indefinitely"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "If a dependency is skipped, downstream tasks with `ALL_SUCCESS` are also skipped (not failed), since the condition was \"skipped\" rather than \"failed\".",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q024",
+      "domain": "model-production-lifecycle",
+      "title": "Question 24",
+      "difficulty": "medium",
+      "question": "**A team wants to compare champion vs challenger performance using inference tables. Which SQL query approach identifies predictions from each model?**",
+      "choices": {
+        "A": "Query by `timestamp_ms` range",
+        "B": "Extract `served_model_name` from the request JSON field",
+        "C": "Filter by `model_version` column",
+        "D": "Join with the MLflow experiment table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "The inference table's `request` JSON contains the `served_model_name` field, which identifies which endpoint configuration (champion or challenger) served each request.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q025",
+      "domain": "model-production-lifecycle",
+      "title": "Question 25",
+      "difficulty": "easy",
+      "question": "**What is a \"blue-green deployment\" in the context of ML model serving?**",
+      "choices": {
+        "A": "Splitting traffic 50/50 between two model versions",
+        "B": "Running two full serving environments (blue=current production, green=new version), then switching all traffic from blue to green atomically",
+        "C": "Gradually increasing challenger traffic from 10% to 100%",
+        "D": "Running shadow deployment alongside champion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Blue-green switches the entire traffic to the new version in one step after the new environment is validated, providing instant rollback capability by switching back to blue.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q026",
+      "domain": "model-production-lifecycle",
+      "title": "Question 26",
+      "difficulty": "medium",
+      "question": "**A model registered with `fe.log_model()` is deployed. A request comes in with only `{\"user_id\": 12345}`. How does the endpoint respond?**",
+      "choices": {
+        "A": "Error — insufficient features in the request",
+        "B": "The endpoint looks up all required features from the online store using `user_id` and returns a prediction",
+        "C": "A prediction of null is returned",
+        "D": "The endpoint requests the missing features from the client"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "This is the key Feature Engineering in UC serving pattern: the model knows which features to retrieve and automatically looks them up from the online store using the entity key.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q027",
+      "domain": "model-production-lifecycle",
+      "title": "Question 27",
+      "difficulty": "easy",
+      "question": "**`mlflow.evaluate()` is called after training. What does it return?**",
+      "choices": {
+        "A": "A retrained model",
+        "B": "An `EvaluationResult` with metrics, artifacts, and a logged MLflow run",
+        "C": "A report in PDF format",
+        "D": "A serving endpoint configuration"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`mlflow.evaluate()` returns an `EvaluationResult` object containing computed metrics, generated artifacts (confusion matrix, etc.), and logs everything to MLflow.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q028",
+      "domain": "model-production-lifecycle",
+      "title": "Question 28",
+      "difficulty": "medium",
+      "question": "**A Python wheel task is preferred over a notebook task in a Databricks Job because:**",
+      "choices": {
+        "A": "Notebook tasks are deprecated",
+        "B": "Python wheel tasks are versioned, testable, and installable as library packages — better for production pipelines",
+        "C": "Notebook tasks cannot use cluster libraries",
+        "D": "Python wheels use less cluster memory"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Python wheel tasks encapsulate code as testable, versioned packages, making them more suitable for production ML pipelines than ad-hoc notebooks.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q029",
+      "domain": "model-production-lifecycle",
+      "title": "Question 29",
+      "difficulty": "medium",
+      "question": "**What should happen to the `previous_champion` alias after a successful canary completion and full traffic migration?**",
+      "choices": {
+        "A": "Keep it indefinitely for rollback",
+        "B": "Delete it once the new champion has been stable in production for your team's defined stability period (e.g., 2 weeks)",
+        "C": "Rename it to `archived`",
+        "D": "It is automatically deleted by Databricks after 30 days"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Keep `previous_champion` as a rapid rollback option initially. Once the new champion is stable, clean up stale aliases to avoid confusion. The retention period is team-defined.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q030",
+      "domain": "model-production-lifecycle",
+      "title": "Question 30",
+      "difficulty": "medium",
+      "question": "**Which configuration option on a serving endpoint helps ensure consistent low latency for a high-SLA fraud detection service?**",
+      "choices": {
+        "A": "`scale_to_zero_enabled=True`",
+        "B": "`scale_to_zero_enabled=False` with appropriate `workload_size`",
+        "C": "`max_concurrent_requests=1`",
+        "D": "`traffic_percentage=100` for the champion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Keeping compute always-on (scale_to_zero disabled) eliminates cold start latency. Appropriate workload size ensures enough capacity for peak traffic.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q031",
+      "domain": "model-production-lifecycle",
+      "title": "Question 31",
+      "difficulty": "easy",
+      "question": "**A serving endpoint receives 1,000 requests per second. 5 requests returned status 500. What is the error rate?**",
+      "choices": {
+        "A": "5%",
+        "B": "0.5%",
+        "C": "0.005% (5 out of 100,000 if measured over 100 seconds)",
+        "D": "Cannot calculate without knowing the time window"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "5 errors / 1000 requests = 0.5% error rate (for that specific second; requires time windowing for a meaningful rate metric).",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q032",
+      "domain": "model-production-lifecycle",
+      "title": "Question 32",
+      "difficulty": "medium",
+      "question": "**A team needs to implement a promotion gate that compares challenger AUC to champion AUC. The champion alias must be updated only if the challenger improves by ≥ 0.5%. Which tool runs this logic?**",
+      "choices": {
+        "A": "Databricks SQL alert",
+        "B": "A notebook task in a Databricks Job, using `MlflowClient` to compare metrics and `set_registered_model_alias` to promote",
+        "C": "MLflow autolog automatic promotion",
+        "D": "Lakehouse Monitoring auto-promotion"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Promotion gate logic is custom Python code in a Databricks Job task that: loads both models, evaluates on holdout, compares metrics, and promotes if the threshold is met.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q033",
+      "domain": "model-governance-mlops",
+      "title": "Question 33",
+      "difficulty": "medium",
+      "question": "**A team's model has PSI = 0.22 on the `income_bracket` feature. What is the recommended first step?**",
+      "choices": {
+        "A": "Immediately retrain with all available data",
+        "B": "Investigate why `income_bracket` has shifted — check upstream data pipeline and data quality",
+        "C": "Roll back to the previous model version",
+        "D": "Ignore — PSI above 0.2 is normal"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "PSI > 0.2 indicates significant drift, but the root cause must be determined first. If it's an upstream data pipeline issue (wrong data, schema change), retraining on bad data would make things worse.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q034",
+      "domain": "model-governance-mlops",
+      "title": "Question 34",
+      "difficulty": "easy",
+      "question": "**Which LHM output table stores per-window statistical profiles (mean, stddev, quantiles) of each feature?**",
+      "choices": {
+        "A": "`_drift_metrics`",
+        "B": "`_monitor_info`",
+        "C": "`_profile_metrics`",
+        "D": "`_alert_history`"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "The `_profile_metrics` table stores statistical profiles (mean, std, min, max, quantiles, null counts) per feature per time window.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q035",
+      "domain": "model-governance-mlops",
+      "title": "Question 35",
+      "difficulty": "medium",
+      "question": "**A compliance officer asks: \"Who changed the `champion` alias for `ml_catalog.fraud_models.fraud_classifier` on Jan 15?\" Where is this information found?**",
+      "choices": {
+        "A": "MLflow experiment runs",
+        "B": "`system.access.audit` filtered by `actionName = 'updateModelVersionAlias'` and date",
+        "C": "Databricks cluster logs",
+        "D": "The model's `description` field"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "UC audit logs in `system.access.audit` record all alias update events with user identity, timestamp, and the specific model name.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q036",
+      "domain": "model-governance-mlops",
+      "title": "Question 36",
+      "difficulty": "medium",
+      "question": "**A team runs bias testing before deployment and finds disparate impact = 0.73. What should happen next?**",
+      "choices": {
+        "A": "Deploy the model — 0.73 is close enough to 0.80",
+        "B": "Block deployment — investigate and remediate the bias before promoting to production",
+        "C": "Deploy with a disclaimer in the model card",
+        "D": "Retrain with twice the minority group data"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Disparate impact of 0.73 is below the four-fifths rule threshold of 0.80. Deployment should be blocked until the bias is investigated and remediated to meet the fairness threshold.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q037",
+      "domain": "model-governance-mlops",
+      "title": "Question 37",
+      "difficulty": "medium",
+      "question": "**An MLflow run logs `mlflow.log_input(dataset, context=\"training\")`. What does this enable?**",
+      "choices": {
+        "A": "Automatic retraining when the dataset changes",
+        "B": "UC data lineage: the Delta table version used for training is linked to the model version in the lineage graph",
+        "C": "Dataset versioning in the MLflow artifact store",
+        "D": "Automatic data quality monitoring"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "`log_input` with a `DeltaDatasetSource` creates a UC lineage link between the specific Delta table version and the model version, enabling auditors to trace exactly which data trained which model.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q038",
+      "domain": "model-governance-mlops",
+      "title": "Question 38",
+      "difficulty": "easy",
+      "question": "**Lakehouse Monitoring is configured with `granularities=[\"1 day\", \"1 week\"]`. What does this mean?**",
+      "choices": {
+        "A": "Monitoring runs once per day and once per week",
+        "B": "Drift and profile metrics are computed at both daily and weekly time windows",
+        "C": "Alerts fire every day and every week",
+        "D": "Data is retained for 1 day or 1 week depending on the monitor type"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Granularities specify the time windows over which metrics are computed. `[\"1 day\", \"1 week\"]` produces both daily and weekly aggregated metrics in the output tables.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q039",
+      "domain": "model-governance-mlops",
+      "title": "Question 39",
+      "difficulty": "easy",
+      "question": "**Model cards provide which compliance benefit?**",
+      "choices": {
+        "A": "Reduce model training costs",
+        "B": "Document intended use, limitations, evaluation metrics, and fairness considerations — required for regulatory model risk management",
+        "C": "Automatically generate audit reports",
+        "D": "Replace manual code review"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Model cards (stored as MLflow registered model descriptions and version tags) provide structured documentation about the model's purpose, performance, and risks — essential for SR 11-7 and similar frameworks.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q040",
+      "domain": "model-governance-mlops",
+      "title": "Question 40",
+      "difficulty": "hard",
+      "question": "**After a model is promoted to production, the baseline table for LHM should be updated. When is the right time?**",
+      "choices": {
+        "A": "Immediately when any new data arrives",
+        "B": "After the new model has been stable in production for a defined period (e.g., 1-2 weeks), and updated to reflect the new model's distribution",
+        "C": "Never — the original baseline should always be the training data",
+        "D": "Daily, automatically"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Update the baseline after the new model is confirmed stable. Updating too early may mask genuine drift; updating too late means drift is compared against the wrong reference distribution.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q041",
+      "domain": "model-governance-mlops",
+      "title": "Question 41",
+      "difficulty": "hard",
+      "question": "**A model uses PII (social security numbers) as a training feature. GDPR requires the right to erasure for a specific user. What is the correct approach?**",
+      "choices": {
+        "A": "Delete the model — it was trained on PII",
+        "B": "Document that the training data included the user's PII but the model artifact itself doesn't store individual records; apply Delta column masking for future feature access and document the data source in the model card",
+        "C": "Retrain the model without the user's data",
+        "D": "Encrypt the user's records in the feature table"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Standard ML practice: document which data was used, apply masking to prevent future access to deleted records, and retain the model artifact (which is an aggregation, not a record). Retraining is optional and resource-intensive.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q042",
+      "domain": "model-governance-mlops",
+      "title": "Question 42",
+      "difficulty": "medium",
+      "question": "**Which drift type can be detected WITHOUT ground truth labels?**",
+      "choices": {
+        "A": "Concept drift",
+        "B": "Performance drift",
+        "C": "Data drift and prediction drift",
+        "D": "Label drift"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Data drift (input distribution comparison) and prediction drift (output distribution comparison) require only historical feature/prediction distributions. Concept drift requires labels to compute performance metrics.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q043",
+      "domain": "model-governance-mlops",
+      "title": "Question 43",
+      "difficulty": "medium",
+      "question": "**A governance team requires that every production ML model be explainable. Which MLflow feature enables storing explainability artifacts with each model version?**",
+      "choices": {
+        "A": "`mlflow.set_tag(\"explainable\", \"true\")`",
+        "B": "`mlflow.log_artifact(\"shap_summary.png\")` within the training run, linked to the registered model version via the run ID",
+        "C": "The MLflow Model Registry automatically generates SHAP plots",
+        "D": "`mlflow.pyfunc.log_model(explainability=True)`"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "SHAP artifacts (summary plots, values CSV) are logged as run artifacts. Since model versions link to their training run, auditors can access explainability artifacts via the run ID stored in the model version metadata.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q044",
+      "domain": "model-governance-mlops",
+      "title": "Question 44",
+      "difficulty": "easy",
+      "question": "**A UC model object has the alias `champion` pointing to version 5. A new `champion` alias is set to version 6. What happens to version 5?**",
+      "choices": {
+        "A": "Version 5 is automatically deleted",
+        "B": "Version 5 remains in the registry but no longer has the `champion` alias — it becomes an \"unaliased\" version",
+        "C": "Version 5's `champion` alias is renamed to `previous_champion` automatically",
+        "D": "Version 5 is archived (moved to Archived stage)"
+      },
+      "correctAnswer": "B",
+      "shortAnswer": "Setting an alias to a new version simply moves the pointer. The old version remains in the registry with all its other tags/metadata, just without that alias.",
+      "explanation": ""
+    },
+    {
+      "id": "ml-professional-mock-2-q045",
+      "domain": "model-governance-mlops",
+      "title": "Question 45",
+      "difficulty": "hard",
+      "question": "**A serving endpoint's p99 latency has been increasing by 15ms per week for 4 weeks. AUC is stable. What is the most likely cause?**",
+      "choices": {
+        "A": "Concept drift",
+        "B": "Data drift",
+        "C": "Operational degradation — possibly growing request payload size, feature store latency, or endpoint compute fragmentation",
+        "D": "Model version mismatch"
+      },
+      "correctAnswer": "C",
+      "shortAnswer": "Stable AUC with increasing latency indicates a non-model-quality issue: operational factors like growing feature retrieval time, larger request payloads, or serving compute degradation are most likely.",
+      "explanation": ""
+    }
+  ],
+  "kind": "mock",
+  "sourceCert": "ml-professional"
+}
diff --git a/practice/data/ml-professional.json b/practice/data/ml-professional.json
index 145f58c..91f464f 100644
--- a/practice/data/ml-professional.json
+++ b/practice/data/ml-professional.json
@@ -2,7 +2,7 @@
   "cert": "ml-professional",
   "certTitle": "ML Professional",
   "blueprintVersion": "Sep 2025",
-  "generated": "2026-05-21",
+  "generated": "2026-05-22",
   "domains": [
     {
       "id": "feature-engineering",
diff --git a/practice/index.html b/practice/index.html
index bce049b..c5903f6 100644
--- a/practice/index.html
+++ b/practice/index.html
@@ -5,113 +5,291 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>Databricks Certification Practice</title>
   <link rel="icon" type="image/svg+xml" href="favicon.svg">
-  <link rel="stylesheet" href="styles.css?v=3">
+
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link rel="stylesheet"
+        href="https://fonts.googleapis.com/css2?family=Geist:wght@300..700&family=Geist+Mono:wght@400..600&display=swap">
+
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css" crossorigin="anonymous">
+  <link rel="stylesheet" href="styles.css?v=35">
 </head>
 <body>
-  <header>
-    <div class="brand">
-      <svg class="brand-icon" width="40" height="40" viewBox="0 0 32 32"
-           aria-hidden="true" style="width:40px;height:40px;flex-shrink:0">
-        <rect x="2" y="2" width="28" height="28" rx="6" fill="#FF3621"/>
-        <path d="M9 16.5 L14 21.5 L23 11.5" stroke="#ffffff" stroke-width="3.2" fill="none"
-              stroke-linecap="round" stroke-linejoin="round"/>
-      </svg>
-      <div class="brand-text">
-        <h1>Databricks Certification Practice</h1>
-        <p class="subtitle">Adaptive practice questions with localStorage progress tracking. <a href="https://github.com/kengio/databricks-certification-study-guide">View on GitHub</a></p>
-      </div>
-    </div>
-    <div class="brand-actions">
-      <button type="button" id="btn-theme" title="Toggle theme (auto / light / dark)" aria-label="Toggle theme">
-        <span id="btn-theme-icon" aria-hidden="true">🖥️</span>
+  <a class="skip-link" href="#main">Skip to content</a>
+
+  <!-- ============== STICKY TOP BAR ============== -->
+  <header class="masthead" id="masthead">
+    <div class="masthead-inner">
+      <button type="button" class="brand-cluster" id="brand-link"
+              title="Back to all certifications"
+              aria-label="Back to all certifications">
+        <span class="brand-mark" aria-hidden="true">
+          <svg viewBox="0 0 40 40">
+            <rect x="1" y="1" width="38" height="38" rx="2" fill="none" stroke="currentColor" stroke-width="1.5"/>
+            <path d="M11 21 L17 27 L29 13" stroke="currentColor" stroke-width="2" fill="none"
+                  stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </span>
+        <span class="brand-title">DBX Practice</span>
       </button>
+
+      <!-- Quiz meta strip: only visible while a quiz is active.
+           The cert name doubles as a "back to certifications" link
+           with a confirm prompt. -->
+      <div class="quiz-meta-strip" id="quiz-meta-strip" hidden>
+        <button type="button" id="quiz-cert" class="cert-link"
+                title="Back to certifications"
+                aria-label="Back to certifications"></button>
+        <span class="rh-sep">/</span>
+        <span id="quiz-domain"></span>
+      </div>
+
+      <div class="masthead-actions">
+        <span id="quiz-clock" title="Current time" aria-label="Current time"></span>
+        <button type="button" id="btn-theme"
+                title="Cycle theme — auto, light, dark"
+                aria-label="Cycle theme">
+          <span id="btn-theme-label">Auto</span>
+        </button>
+      </div>
     </div>
   </header>
 
-  <main id="app">
+  <!-- ============== MAIN SCROLL AREA ============== -->
+  <main id="main">
     <section id="setup">
-      <h2>Pick a question bank</h2>
-      <p>Loading…</p>
+      <p class="loading">Loading question banks…</p>
     </section>
 
     <section id="quiz" hidden>
-      <div class="quiz-header">
-        <div class="quiz-meta">
-          <span id="quiz-cert"></span>
-          <span class="separator">·</span>
-          <span id="quiz-counter"></span>
-          <span class="separator">·</span>
-          <span id="quiz-domain"></span>
-          <span class="separator">·</span>
-          <span id="quiz-difficulty" class="difficulty"></span>
-        </div>
-        <div class="quiz-controls">
-          <button type="button" id="btn-stats">Stats</button>
-          <button type="button" id="btn-settings">Settings</button>
-          <button type="button" id="btn-reset-top" class="danger" title="Reset all progress for this cert bank">Reset</button>
-          <button type="button" id="btn-exit">Switch bank</button>
-        </div>
+      <div class="question-header">
+        <span id="quiz-counter" class="q-counter"></span>
+        <span class="rh-sep">·</span>
+        <span id="quiz-difficulty" class="difficulty"></span>
       </div>
-
-      <div class="question-card">
+      <article class="question-card">
+        <span id="quiz-watermark" class="q-watermark" aria-hidden="true"></span>
         <p id="quiz-question"></p>
-        <fieldset id="quiz-choices"></fieldset>
-        <div class="quiz-actions">
-          <button type="button" id="btn-submit" disabled>Submit answer</button>
-          <button type="button" id="btn-next" hidden>Next question →</button>
-        </div>
-        <div id="quiz-feedback" hidden></div>
-      </div>
-
-      <div class="session-bar">
-        <span id="session-stats">Session: 0 / 0</span>
-        <span id="bank-stats"></span>
-      </div>
+        <fieldset id="quiz-choices" aria-label="Answer choices"></fieldset>
+        <div id="quiz-feedback" hidden role="status" aria-live="polite"></div>
+      </article>
     </section>
 
     <section id="stats" hidden>
+      <button type="button" id="btn-stats-back" class="back-button">← Back to quiz</button>
       <h2>Stats</h2>
       <div id="stats-content"></div>
       <div class="stats-actions">
-        <button type="button" id="btn-stats-back">← Back to quiz</button>
-        <button type="button" id="btn-export">Export progress (JSON)</button>
-        <button type="button" id="btn-reset" class="danger">Reset history (this bank)</button>
+        <button type="button" id="btn-export" class="ghost">Export progress</button>
+        <button type="button" id="btn-reset" class="ghost danger">Reset history</button>
       </div>
     </section>
 
+    <section id="summary" hidden>
+      <!-- Populated by renderSummary() in app.js. Shown when the user has
+           answered every question in the current bank (or timer expired). -->
+    </section>
+
     <section id="settings" hidden>
+      <button type="button" id="btn-settings-cancel" class="back-button">← Back to quiz</button>
       <h2>Settings</h2>
-      <label>Mode
-        <select id="setting-mode">
-          <option value="adaptive">Adaptive (default) — weight toward never-seen + recently-wrong</option>
-          <option value="random">Random — uniform sampling, no history weighting</option>
-          <option value="sequential">Sequential — go through every question in order</option>
-        </select>
-      </label>
-      <label>Domain filter
-        <select id="setting-domain">
-          <option value="">All domains</option>
-        </select>
-      </label>
-      <label>Difficulty filter
-        <select id="setting-difficulty">
-          <option value="">All difficulties</option>
-          <option value="easy">Easy</option>
-          <option value="medium">Medium</option>
-          <option value="hard">Hard</option>
-        </select>
-      </label>
+      <p class="section-intro">Customize how you practice — selection order, filters, and exam timing.</p>
+
+      <div class="settings-panel">
+        <div class="settings-row">
+          <div class="settings-row-meta">
+            <h4 id="lbl-setting-mode">Selection mode</h4>
+            <p id="lbl-setting-mode-desc">Adaptive surfaces questions you've missed; sequential walks the bank in order.</p>
+          </div>
+          <div class="settings-field">
+            <select id="setting-mode"
+                    aria-labelledby="lbl-setting-mode"
+                    aria-describedby="lbl-setting-mode-desc">
+              <option value="adaptive">Adaptive — weight toward gaps</option>
+              <option value="random">Random — uniform sampling</option>
+              <option value="sequential">Sequential — in source order</option>
+            </select>
+          </div>
+        </div>
+
+        <div class="settings-row">
+          <div class="settings-row-meta">
+            <h4 id="lbl-setting-domain">Filter by domain</h4>
+            <p id="lbl-setting-domain-desc">Drill a specific exam domain instead of the whole bank.</p>
+          </div>
+          <div class="settings-field">
+            <select id="setting-domain"
+                    aria-labelledby="lbl-setting-domain"
+                    aria-describedby="lbl-setting-domain-desc">
+              <option value="">All domains</option>
+            </select>
+          </div>
+        </div>
+
+        <div class="settings-row">
+          <div class="settings-row-meta">
+            <h4 id="lbl-setting-difficulty">Filter by difficulty</h4>
+            <p id="lbl-setting-difficulty-desc">Restrict to easy, medium, or hard questions only.</p>
+          </div>
+          <div class="settings-field">
+            <select id="setting-difficulty"
+                    aria-labelledby="lbl-setting-difficulty"
+                    aria-describedby="lbl-setting-difficulty-desc">
+              <option value="">All difficulties</option>
+              <option value="easy">Easy</option>
+              <option value="medium">Medium</option>
+              <option value="hard">Hard</option>
+            </select>
+          </div>
+        </div>
+
+        <div class="settings-row">
+          <div class="settings-row-meta">
+            <h4 id="lbl-setting-timer">Exam timer</h4>
+            <p id="lbl-setting-timer-desc">Simulate the real exam by setting a countdown timer. Timer resets when you switch banks.</p>
+          </div>
+          <div class="settings-field">
+            <select id="setting-timer"
+                    aria-labelledby="lbl-setting-timer"
+                    aria-describedby="lbl-setting-timer-desc">
+              <option value="0">None — practice mode</option>
+              <option value="30">30 minutes</option>
+              <option value="60">60 minutes</option>
+              <option value="90">90 minutes — Associate exam length</option>
+              <option value="120">120 minutes — Professional exam length</option>
+            </select>
+          </div>
+        </div>
+      </div>
+
       <div class="settings-actions">
-        <button type="button" id="btn-settings-apply">Apply</button>
-        <button type="button" id="btn-settings-cancel">Cancel</button>
+        <button type="button" id="btn-settings-cancel-2" class="ghost">Cancel</button>
+        <button type="button" id="btn-settings-apply" class="primary">Apply settings</button>
       </div>
     </section>
   </main>
 
-  <footer>
-    <p>This is study material, not the official Databricks exam. Question banks are generated from the markdown practice-question files in this repo. <a href="./README.md">Read the docs</a> · <a href="./format.md">Format spec</a></p>
+  <!-- ============== PAUSE OVERLAY ==============
+       Shown when the user pauses the exam timer. Blurs the background
+       so the page isn't readable while the user steps away, and offers
+       a Resume button + Esc/Enter/Space keyboard return path. -->
+  <div class="pause-overlay" id="pause-overlay" hidden
+       role="alertdialog" aria-modal="true" aria-labelledby="pause-title">
+    <div class="pause-card">
+      <p class="pause-eyebrow">Exam on hold</p>
+      <h2 id="pause-title" class="pause-title">Paused</h2>
+      <p class="pause-message">
+        Your timer is frozen and the questions are blurred. Take your time —
+        nothing counts against your effort while you're away.
+      </p>
+      <button type="button" id="btn-resume" class="primary">Resume exam</button>
+      <p class="pause-hint">
+        <kbd>Esc</kbd> / <kbd>Enter</kbd> / <kbd>Space</kbd> · or tap anywhere
+      </p>
+    </div>
+  </div>
+
+  <!-- ============== CONFIRM MODAL (theme-aware, focus-trapped) ============== -->
+  <div class="modal-backdrop" id="modal-backdrop" hidden>
+    <div class="modal" role="alertdialog" aria-modal="true"
+         aria-labelledby="modal-title" aria-describedby="modal-message"
+         tabindex="-1">
+      <h3 id="modal-title" class="modal-title">Confirm</h3>
+      <p id="modal-message" class="modal-message"></p>
+      <div class="modal-actions">
+        <button type="button" id="modal-cancel" class="ghost">Cancel</button>
+        <button type="button" id="modal-confirm" class="primary">Confirm</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- ============== STICKY BOTTOM ACTION BAR (quiz mode only) ==============
+       Row 1 is a 3-column grid:
+         [Timer (left)]   [kbd-hint (center)]   [Next/Skip/Submit (right)]
+       Row 2 spans all columns:
+         [session · bank stats · Stats Settings Reset Switch bank]
+
+       The kbd-hint sits in the centre column (independent of timer/buttons)
+       so it stays optically centred regardless of timer state. On mobile
+       the centre column is hidden entirely. -->
+  <div class="actionbar" id="actionbar" hidden>
+    <div class="actionbar-inner">
+      <button type="button" id="quiz-timer" class="actionbar-timer" hidden
+              title="Click to pause / resume the exam timer (P)"
+              aria-label="Exam timer — click to pause or resume">
+        <span class="timer-icon" aria-hidden="true">
+          <svg viewBox="0 0 16 16" width="14" height="14" fill="none"
+               stroke="currentColor" stroke-width="1.5"
+               stroke-linecap="round" stroke-linejoin="round">
+            <circle cx="8" cy="9" r="5.25"/>
+            <path d="M8 6.5V9l1.6 1.2"/>
+            <path d="M6.25 2h3.5M8 2v1.5"/>
+          </svg>
+        </span>
+        <span class="timer-value">00:00</span>
+        <span class="timer-pause-glyph" aria-hidden="true">
+          <svg viewBox="0 0 12 12" width="10" height="10" fill="currentColor">
+            <rect x="2.5" y="2" width="2.5" height="8" rx="0.5"/>
+            <rect x="7" y="2" width="2.5" height="8" rx="0.5"/>
+          </svg>
+        </span>
+        <span class="timer-resume-glyph" aria-hidden="true">
+          <svg viewBox="0 0 12 12" width="10" height="10" fill="currentColor">
+            <path d="M3 2 L10 6 L3 10 Z"/>
+          </svg>
+        </span>
+      </button>
+      <span class="kbd-hint" aria-hidden="true" id="kbd-hint-pre">
+        <kbd>1</kbd><kbd>2</kbd><kbd>3</kbd><kbd>4</kbd> or <kbd>↑</kbd><kbd>↓</kbd> select &nbsp;
+        <kbd>↵</kbd> / <kbd>Space</kbd> submit &nbsp;
+        <kbd>S</kbd> skip
+      </span>
+      <span class="kbd-hint" aria-hidden="true" id="kbd-hint-post" hidden>
+        <kbd>↵</kbd> / <kbd>Space</kbd> / <kbd>N</kbd> / <kbd>→</kbd> next question
+      </span>
+      <div class="actionbar-left">
+        <!-- Source order is "Next, Skip, Submit" so the rightmost visible
+             button is always the primary action: Submit before submit,
+             Next after. -->
+        <button type="button" id="btn-next" class="primary" hidden>Next question</button>
+        <button type="button" id="btn-skip" class="ghost">Skip</button>
+        <button type="button" id="btn-submit" class="primary" disabled>Submit</button>
+      </div>
+      <div class="actionbar-right">
+        <span id="session-stats">0/0</span>
+        <span class="rh-sep">·</span>
+        <span id="bank-stats"></span>
+        <span class="actionbar-divider"></span>
+        <button type="button" id="btn-stats" class="link">Stats</button>
+        <button type="button" id="btn-settings" class="link">Settings</button>
+        <button type="button" id="btn-reset-top" class="link danger" title="Reset progress for this bank">Reset</button>
+        <button type="button" id="btn-exit" class="link">Switch bank</button>
+      </div>
+    </div>
+  </div>
+
+  <footer class="page-footer">
+    <p class="footer-tag">A study aid, not the official exam.</p>
+    <p class="footer-meta">
+      <a href="https://github.com/kengio/databricks-certification-study-guide">Source on GitHub</a>
+      <span class="rh-sep">·</span>
+      <span class="colophon">MIT</span>
+      <span class="rh-sep">·</span>
+      © 2026 <a href="https://github.com/kengio">@kengio</a>
+    </p>
+    <p class="footer-colophon">
+      Set in <span class="colophon-mark">Geist</span> &amp;
+      <span class="colophon-mark">Geist Mono</span>
+      &nbsp;·&nbsp; No tracking
+      &nbsp;·&nbsp; Progress stays in your browser
+    </p>
   </footer>
 
-  <script src="app.js?v=3"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"
+          data-manual crossorigin="anonymous"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js" crossorigin="anonymous"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-sql.min.js" crossorigin="anonymous"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-scala.min.js" crossorigin="anonymous"></script>
+  <script src="app.js?v=35"></script>
 </body>
 </html>
diff --git a/practice/styles.css b/practice/styles.css
index fef0bda..caa6c74 100644
--- a/practice/styles.css
+++ b/practice/styles.css
@@ -1,432 +1,2520 @@
-/* Theme variables.
- * Default = light. `[data-theme="dark"]` forces dark.
- * `[data-theme="auto"]` (default if no manual override) uses prefers-color-scheme. */
+/* ============================================================
+   Databricks Certification Practice — design system
+   Typography:  Geist (everything) · Geist Mono (code + labels)
+   Palette:     warm neutral · vivid coral accent · per-cert gradients
+   ============================================================ */
 
 :root {
-  --color-bg: #fafafa;
-  --color-fg: #1a1a1a;
-  --color-muted: #666;
-  --color-border: #d0d0d0;
-  --color-accent: #FF3621;
-  --color-correct: #1f8b4c;
-  --color-incorrect: #c52b2b;
-  --color-correct-bg: #e8f6ed;
-  --color-incorrect-bg: #fbeaea;
-  --color-card-bg: #ffffff;
-  --color-link: #0066cc;
-  --color-medium-bg: #fff2cc;
-  --color-medium-fg: #8a6a00;
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.08);
-  --radius: 6px;
-  --font-mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
-  --font-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-}
-
-/* System dark mode: only applied when theme = auto (no manual override) */
+  /* Light theme — WCAG AAA contrast tokens (≥7:1 normal text, ≥4.5:1 large).
+     --muted bumped from #71717A (4.45:1, AA Large only) to #52525B (7.1:1
+     AAA pass). --positive / --negative likewise darkened for small-text
+     contexts. --accent stays vivid for graphic/large-display use only —
+     small-text usages of accent route through --accent-text. */
+  --bg:            #FAFAF7;
+  --surface:       #FFFFFF;
+  --surface-soft:  #F4F3EF;
+  --fg:            #18181B;            /* 17:1 on bg  — AAA */
+  --fg-soft:       #3F3F46;            /* 10:1 on bg  — AAA */
+  --muted:         #52525B;            /* 7.1:1 on bg — AAA */
+  --hairline:      #E5E5E2;
+  --hairline-soft: #EFEFED;
+  --accent:        #FF4F2C;            /* graphic only — 3.8:1 on bg */
+  --accent-text:   #9A3412;            /* 7.1:1 on bg — for accent-coloured small text */
+  --accent-soft:   rgba(255,79,44,0.08);
+  --selected:      #1D4ED8;            /* 8.6:1 on bg — was #2563EB at 5.7:1 */
+  --selected-soft: rgba(29,78,216,0.08);
+  --positive:      #14532D;            /* 9.0:1 on bg — was #15803D at 4.6:1 */
+  --positive-soft: #DCFCE7;
+  --negative:      #991B1B;            /* 8.2:1 on bg — was #B91C1C at 6.4:1 */
+  --negative-soft: #FBEAEA;
+  --warn:          #92400E;            /* 7.5:1 on bg — new token for AAA warn text */
+  --warn-soft:     rgba(217,119,6,0.10);
+  --code-bg:       #F1F1ED;
+
+  --shadow-1: 0 1px 0 var(--hairline);
+  --shadow-2: 0 1px 0 var(--hairline), 0 8px 24px -12px rgba(24,24,27,0.08);
+  --shadow-3: 0 1px 0 var(--hairline), 0 16px 40px -16px rgba(24,24,27,0.16);
+
+  --sans: "Geist", -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  --mono: "Geist Mono", ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+
+  --radius:    8px;
+  --radius-lg: 12px;
+  --content-w: 760px;
+
+  --ease: cubic-bezier(0.32, 0.72, 0, 1);
+}
+
 @media (prefers-color-scheme: dark) {
   :root[data-theme="auto"], :root:not([data-theme]) {
-    --color-bg: #161616;
-    --color-fg: #f0f0f0;
-    --color-muted: #aaa;
-    --color-border: #333;
-    --color-card-bg: #1f1f1f;
-    --color-correct-bg: #16341e;
-    --color-incorrect-bg: #3a1717;
-    --color-link: #5cb3ff;
-    --color-medium-bg: #3a3105;
-    --color-medium-fg: #e7c83e;
-    --shadow-card: 0 1px 3px rgba(0,0,0,0.5);
+    --bg:            #0A0A0C;
+    --surface:       #131316;
+    --surface-soft:  #1B1B1F;
+    --fg:            #FAFAFA;            /* 18:1 on bg — AAA */
+    --fg-soft:       #D4D4D8;            /* 13:1 on bg — AAA */
+    --muted:         #A1A1AA;            /* 7.4:1 on bg — AAA (was #8B8B95 at 5.8:1) */
+    --hairline:      #26262C;
+    --hairline-soft: #1D1D22;
+    --accent:        #FF7A5C;            /* graphic — was #FF6240 */
+    --accent-text:   #FFA88B;            /* 7.2:1 on bg — for accent text */
+    --accent-soft:   rgba(255,122,92,0.14);
+    --selected:      #93C5FD;            /* 10.4:1 on bg — AAA */
+    --selected-soft: rgba(147,197,253,0.14);
+    --positive:      #6EE7B7;            /* 11.2:1 on bg — AAA */
+    --positive-soft: rgba(110,231,183,0.12);
+    --negative:      #FCA5A5;            /* 9.7:1 on bg — AAA */
+    --negative-soft: rgba(252,165,165,0.12);
+    --warn:          #FBBF24;            /* 11.5:1 on bg — AAA */
+    --warn-soft:     rgba(251,191,36,0.14);
+    --code-bg:       #1A1A1F;
+
+    --shadow-2: 0 1px 0 var(--hairline), 0 12px 36px -16px rgba(0,0,0,0.6);
+    --shadow-3: 0 1px 0 var(--hairline), 0 20px 48px -18px rgba(0,0,0,0.8);
   }
 }
 
-/* Manual dark override: works regardless of system preference */
 :root[data-theme="dark"] {
-  --color-bg: #161616;
-  --color-fg: #f0f0f0;
-  --color-muted: #aaa;
-  --color-border: #333;
-  --color-card-bg: #1f1f1f;
-  --color-correct-bg: #16341e;
-  --color-incorrect-bg: #3a1717;
-  --color-link: #5cb3ff;
-  --color-medium-bg: #3a3105;
-  --color-medium-fg: #e7c83e;
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.5);
-}
-
-/* Manual light override: defaults already light, but explicit for completeness
-   so the toggle reaches a stable third state regardless of system preference */
+  --bg:            #0A0A0C;
+  --surface:       #131316;
+  --surface-soft:  #1B1B1F;
+  --fg:            #FAFAFA;
+  --fg-soft:       #D4D4D8;
+  --muted:         #A1A1AA;            /* 7.4:1 on bg — AAA */
+  --hairline:      #26262C;
+  --hairline-soft: #1D1D22;
+  --accent:        #FF7A5C;
+  --accent-text:   #FFA88B;            /* 7.2:1 on bg — AAA */
+  --accent-soft:   rgba(255,122,92,0.14);
+  --selected:      #93C5FD;            /* 10.4:1 on bg — AAA */
+  --selected-soft: rgba(147,197,253,0.14);
+  --positive:      #6EE7B7;            /* 11.2:1 on bg — AAA */
+  --positive-soft: rgba(110,231,183,0.12);
+  --negative:      #FCA5A5;            /* 9.7:1 on bg — AAA */
+  --negative-soft: rgba(252,165,165,0.12);
+  --warn:          #FBBF24;            /* 11.5:1 on bg — AAA */
+  --warn-soft:     rgba(251,191,36,0.14);
+  --code-bg:       #1A1A1F;
+
+  --shadow-2: 0 1px 0 var(--hairline), 0 12px 36px -16px rgba(0,0,0,0.6);
+  --shadow-3: 0 1px 0 var(--hairline), 0 20px 48px -18px rgba(0,0,0,0.8);
+}
+
 :root[data-theme="light"] {
-  --color-bg: #fafafa;
-  --color-fg: #1a1a1a;
-  --color-muted: #666;
-  --color-border: #d0d0d0;
-  --color-card-bg: #ffffff;
-  --color-correct-bg: #e8f6ed;
-  --color-incorrect-bg: #fbeaea;
-  --color-link: #0066cc;
-  --color-medium-bg: #fff2cc;
-  --color-medium-fg: #8a6a00;
-  --shadow-card: 0 1px 3px rgba(0,0,0,0.08);
+  --bg:            #FAFAF7;
+  --surface:       #FFFFFF;
+  --surface-soft:  #F4F3EF;
+  --fg:            #18181B;
+  --fg-soft:       #3F3F46;
+  --muted:         #52525B;            /* 7.1:1 on bg — AAA */
+  --hairline:      #E5E5E2;
+  --hairline-soft: #EFEFED;
+  --accent:        #FF4F2C;
+  --accent-text:   #9A3412;            /* 7.1:1 on bg — AAA */
+  --accent-soft:   rgba(255,79,44,0.08);
+  --selected:      #1D4ED8;            /* 8.6:1 on bg — AAA */
+  --selected-soft: rgba(29,78,216,0.08);
+  --positive:      #14532D;            /* 9.0:1 on bg — AAA */
+  --positive-soft: #DCFCE7;
+  --negative:      #991B1B;            /* 8.2:1 on bg — AAA */
+  --negative-soft: #FBEAEA;
+  --warn:          #92400E;            /* 7.5:1 on bg — AAA */
+  --warn-soft:     rgba(217,119,6,0.10);
+  --code-bg:       #F1F1ED;
 }
 
+/* ---------- Base ---------- */
+
 * { box-sizing: border-box; }
 
+/* The HTML `hidden` attribute must always win, even against button.primary
+   { display: inline-flex } which has higher specificity than the built-in
+   `[hidden] { display: none }` user-agent rule. Without this, btn-next
+   stays visually clickable before the user submits. */
+[hidden] { display: none !important; }
+
+html { -webkit-text-size-adjust: 100%; }
+
 body {
   margin: 0;
-  font-family: var(--font-sans);
-  background: var(--color-bg);
-  color: var(--color-fg);
+  font-family: var(--sans);
+  font-weight: 400;
+  font-size: 16px;
   line-height: 1.55;
+  letter-spacing: -0.005em;
+  /* Soft warm glow at the top of the page — keeps the bg from reading
+     as a flat single tone. Layered above the solid --bg so per-theme
+     swapping still works. background-attachment: fixed keeps the glow
+     anchored to the viewport while content scrolls beneath. */
+  background:
+    radial-gradient(ellipse 90% 50% at 50% -10%,
+      color-mix(in srgb, var(--accent) 6%, transparent),
+      transparent 70%),
+    var(--bg);
+  background-attachment: fixed;
+  color: var(--fg);
+  font-feature-settings: "cv11", "ss01";
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-rendering: optimizeLegibility;
 }
 
-header {
-  padding: 1rem 1.5rem;
-  border-bottom: 1px solid var(--color-border);
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  gap: 1rem;
+/* Improve line balance on big display text — keeps headings from
+   leaving a one-word orphan on the last line. Supported in Chrome,
+   Safari, Firefox; gracefully ignored elsewhere. */
+h2, .cert-card strong, .bank-card strong, .modal-title,
+#quiz-feedback h4, .lead {
+  text-wrap: balance;
 }
 
-footer {
-  padding: 1rem 1.5rem;
-  border-top: 1px solid var(--color-border);
-  font-size: 0.85em;
-  color: var(--color-muted);
-  margin-top: 2rem;
+.skip-link {
+  position: absolute;
+  left: -9999px;
+  top: 0;
+  padding: 0.5rem 1rem;
+  background: var(--fg);
+  color: var(--bg);
+  font: 500 0.875rem var(--sans);
+  border-radius: 0 0 var(--radius) 0;
+}
+.skip-link:focus { left: 0; z-index: 100; }
+
+a {
+  color: var(--fg);
+  text-decoration: underline;
+  text-decoration-color: var(--hairline);
+  text-decoration-thickness: 1px;
+  text-underline-offset: 3px;
+  transition: text-decoration-color 0.15s var(--ease);
+}
+a:hover { text-decoration-color: var(--accent); }
+
+/* Drop the paper-grain — it doesn't match the modern aesthetic */
+.paper-grain { display: none; }
+
+/* ---------- Sticky top masthead ---------- */
+
+.masthead {
+  position: sticky;
+  top: 0;
+  z-index: 50;
+  background: color-mix(in srgb, var(--bg) 88%, transparent);
+  backdrop-filter: saturate(180%) blur(12px);
+  -webkit-backdrop-filter: saturate(180%) blur(12px);
+  border-bottom: 1px solid var(--hairline);
 }
 
-.brand {
+.masthead-inner {
+  max-width: 1080px;
+  margin: 0 auto;
+  padding: 0.65rem 1.5rem;
   display: flex;
   align-items: center;
-  gap: 0.85rem;
-  min-width: 0;
+  gap: 1.25rem;
+  min-height: 52px;
 }
 
-.brand-icon {
+/* Brand cluster doubles as "back to all certifications" link. Hover
+   tints the title and rotates the mark; confirm dialog handled in JS. */
+button.brand-cluster {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.6rem;
   flex-shrink: 0;
-  width: 40px;
-  height: 40px;
-  filter: drop-shadow(0 1px 2px rgba(0,0,0,0.15));
+  padding: 0.25rem 0.5rem 0.25rem 0.25rem;
+  background: none;
+  border: 1px solid transparent;
+  border-radius: var(--radius);
+  cursor: pointer;
+  font: inherit;
+  color: inherit;
+  transition: background 0.15s, border-color 0.15s;
 }
+button.brand-cluster:hover {
+  background: var(--surface-soft);
+  border-color: var(--hairline);
+}
+button.brand-cluster:hover .brand-mark { transform: rotate(-8deg) scale(1.08); }
+button.brand-cluster:hover .brand-title { color: var(--accent-text); }
+/* Custom focus indicator: an OUTLINE here would extend below the
+   masthead boundary and get clipped by the next section's background
+   (sticky masthead has its own stacking context + border-bottom). Using
+   the existing transparent border slot keeps the indicator inside the
+   button's painted area, so nothing ever gets cut off. */
+button.brand-cluster:focus-visible {
+  outline: none;
+  border-color: var(--accent);
+  background: var(--surface-soft);
+}
+button.brand-cluster:focus-visible .brand-title { color: var(--accent); }
 
-.brand-text { min-width: 0; }
+.brand-mark {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  flex-shrink: 0;
+  color: var(--accent);
+  transition: transform 0.2s var(--ease);
+}
+.brand-mark svg { width: 22px; height: 22px; display: block; }
+.brand-title { transition: color 0.15s; }
 
-.brand h1 {
-  margin: 0 0 0.15rem 0;
-  font-size: 1.35rem;
-  line-height: 1.2;
+.brand-title {
+  font-family: var(--sans);
+  font-weight: 600;
+  font-size: 0.95rem;
+  letter-spacing: -0.02em;
+  color: var(--fg);
+  white-space: nowrap;
 }
 
-.brand .subtitle {
-  margin: 0;
-  font-size: 0.85em;
-  color: var(--color-muted);
+.quiz-meta-strip {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex: 1;
+  min-width: 0;
+  padding-left: 1rem;
+  border-left: 1px solid var(--hairline);
+  margin-left: 0.25rem;
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  color: var(--muted);
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.quiz-meta-strip[hidden] { display: none; }
+.quiz-meta-strip #quiz-cert,
+.quiz-meta-strip .cert-link {
+  color: var(--fg);
+  font-weight: 600;
+  background: none;
+  border: none;
+  padding: 0;
+  font: inherit;
+  cursor: pointer;
+  text-transform: inherit;
+  letter-spacing: inherit;
+  transition: color 0.15s;
+}
+.quiz-meta-strip .cert-link:hover {
+  color: var(--accent-text);
+  text-decoration: underline;
+  text-decoration-thickness: 1px;
+  text-underline-offset: 3px;
+}
+/* Same reasoning as button.brand-cluster:focus-visible above —
+   keep the focus indicator inside the element so it can't be clipped
+   by the sticky masthead's boundary. */
+.quiz-meta-strip .cert-link:focus-visible {
+  outline: none;
+  color: var(--accent-text);
+  text-decoration: underline;
+  text-decoration-thickness: 2px;
+  text-underline-offset: 4px;
 }
+.quiz-meta-strip #quiz-domain { color: var(--fg-soft); }
+.quiz-meta-strip .rh-sep { color: var(--hairline); padding: 0 0.15rem; }
 
-.brand-actions {
-  display: flex;
+.masthead-actions {
+  display: inline-flex;
   gap: 0.5rem;
   flex-shrink: 0;
+  margin-left: auto;
+  align-items: center;
 }
 
-#btn-theme {
-  font-size: 1.15rem;
-  padding: 0.3rem 0.55rem;
-  line-height: 1;
+/* Wall clock in masthead — minimal, ambient. No pill, no border;
+   just plain mono text in a muted tone so it stays clearly secondary
+   to the timer (which lives in the action bar). */
+#quiz-clock {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  font-weight: 500;
+  letter-spacing: 0.02em;
+  color: var(--muted);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  padding-right: 0.25rem;
 }
 
-@media (max-width: 600px) {
-  header { flex-direction: column; align-items: flex-start; gap: 0.75rem; }
-  .brand h1 { font-size: 1.15rem; }
-  .brand .subtitle { font-size: 0.8em; }
+/* Exam timer in the masthead quiz-meta-strip — lives RIGHT AFTER the
+   question counter so "Q6 this session · 22:27 remaining" reads as a
+   single line of session state. Subtle pill with monospace value;
+   warning state pulses accent-coloured, expired locks negative-red. */
+/* Exam timer — large pill in the action bar, far right. Designed to
+   be clearly visible during a timed practice. */
+.actionbar-timer {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+  padding: 0.5rem 0.9rem 0.5rem 0.75rem;
+  border: 1px solid var(--hairline);
+  border-radius: 99px;
+  background: var(--surface);
+  font-family: var(--mono);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  transition: color 0.15s, border-color 0.15s, background 0.15s;
+  flex-shrink: 0;
 }
+.actionbar-timer .timer-icon {
+  font-size: 0.95rem;
+  color: var(--muted);
+}
+.actionbar-timer .timer-value {
+  font-size: 1.05rem;
+  font-weight: 600;
+  color: var(--fg);
+  letter-spacing: 0;
+}
+.actionbar-timer.warning {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  animation: timer-pulse 1s ease-in-out infinite;
+}
+.actionbar-timer.warning .timer-icon,
+.actionbar-timer.warning .timer-value { color: var(--accent-text); }
+.actionbar-timer.expired {
+  border-color: var(--negative);
+  background: var(--negative-soft);
+  animation: none;
+}
+.actionbar-timer.expired .timer-icon,
+.actionbar-timer.expired .timer-value { color: var(--negative); }
 
-a { color: var(--color-link); }
-
-main {
-  max-width: 800px;
-  margin: 1.5rem auto;
-  padding: 0 1.5rem;
+/* Timer pill is a button that toggles pause. Show the appropriate
+   pause/play glyph; hide both when the timer is in passive states. */
+button.actionbar-timer { cursor: pointer; }
+button.actionbar-timer:disabled { cursor: default; }
+.actionbar-timer .timer-pause-glyph,
+.actionbar-timer .timer-resume-glyph {
+  display: none;
+  color: var(--muted);
+  margin-left: 0.1rem;
+}
+@media (hover: hover) {
+  /* On hover, surface the pause glyph as an affordance */
+  button.actionbar-timer:not(.expired):not(.paused):hover .timer-pause-glyph { display: inline-flex; }
+  button.actionbar-timer:not(.expired):not(.paused):hover { border-color: var(--fg-soft); }
+}
+@media (hover: none) {
+  /* Touch devices have no hover state — surface the pause glyph faded so
+     mobile users can discover the timer is interactive without tapping
+     blind. Full opacity on press feedback. */
+  button.actionbar-timer:not(.expired):not(.paused) .timer-pause-glyph {
+    display: inline-flex;
+    opacity: 0.45;
+  }
+  button.actionbar-timer:not(.expired):not(.paused):active .timer-pause-glyph { opacity: 1; }
+}
+button.actionbar-timer.paused {
+  border-color: var(--fg-soft);
+  background: var(--surface-soft);
+}
+button.actionbar-timer.paused .timer-icon,
+button.actionbar-timer.paused .timer-value { color: var(--fg-soft); }
+button.actionbar-timer.paused .timer-resume-glyph { display: inline-flex; color: var(--fg-soft); }
+button.actionbar-timer.paused .timer-pause-glyph { display: none; }
+button.actionbar-timer:focus-visible {
+  outline: none;
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+@keyframes timer-pulse {
+  0%, 100% { opacity: 1; }
+  50%      { opacity: 0.6; }
 }
 
-h2 {
-  margin-top: 0;
-  font-size: 1.25rem;
+@media (max-width: 720px) {
+  #quiz-clock { display: none; }  /* save room on mobile */
 }
 
-button {
-  font: inherit;
-  padding: 0.5rem 1rem;
-  border: 1px solid var(--color-border);
-  background: var(--color-card-bg);
-  color: var(--color-fg);
-  border-radius: var(--radius);
+#btn-theme {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  padding: 0.4rem 0.8rem 0.4rem 0.7rem;
+  background: var(--surface);
+  color: var(--fg-soft);
+  border: 1px solid var(--hairline);
+  border-radius: 99px;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
   cursor: pointer;
-  transition: border-color 0.15s, background 0.15s;
+  transition: all 0.15s var(--ease);
 }
-
-button:hover:not(:disabled) {
-  border-color: var(--color-accent);
+#btn-theme::before {
+  content: "";
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--accent);
+  flex-shrink: 0;
+  box-shadow: 0 0 0 2px var(--accent-soft);
 }
-
-button:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
+#btn-theme:hover {
+  color: var(--fg);
+  border-color: var(--fg-soft);
+}
+#btn-theme:focus-visible {
+  outline: none;
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  color: var(--fg);
 }
 
-button.danger {
-  color: var(--color-incorrect);
-  border-color: var(--color-incorrect);
+@media (max-width: 720px) {
+  .masthead-inner { padding: 0.55rem 1rem; gap: 0.75rem; }
+  .brand-title { display: none; }  /* keep just the logo on small screens */
+  .quiz-meta-strip {
+    font-size: 0.65rem;
+    padding-left: 0.6rem;
+    margin-left: 0;
+  }
 }
 
-button.danger:hover { background: var(--color-incorrect-bg); }
+/* ---------- Main column ---------- */
 
-/* Setup */
-#setup .bank-list {
-  display: grid;
-  gap: 0.75rem;
-  margin-top: 1rem;
+main {
+  max-width: var(--content-w);
+  margin: 0 auto;
+  padding: 3rem 2rem 4rem;
+  position: relative;
 }
 
-#setup .bank-card {
-  text-align: left;
-  padding: 1rem 1.25rem;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius);
-  background: var(--color-card-bg);
+@media (max-width: 640px) {
+  main { padding: 2rem 1.25rem 3rem; }
 }
 
-#setup .bank-card strong { display: block; font-size: 1.05rem; margin-bottom: 0.25rem; }
-#setup .bank-card .bank-meta { font-size: 0.85em; color: var(--color-muted); }
+h2 {
+  font-family: var(--sans);
+  font-weight: 600;
+  font-size: clamp(1.75rem, 4vw, 2.5rem);
+  letter-spacing: -0.03em;
+  line-height: 1.05;
+  margin: 0 0 2rem 0;
+  color: var(--fg);
+}
 
-/* Quiz */
-.quiz-header {
-  display: flex;
-  justify-content: space-between;
+/* Editorial eyebrow — a small accent-coloured kicker that sits above
+   the main heading on picker pages. Uses --accent-text (the AAA-safe
+   darker variant) for the type itself; the decorative dash keeps the
+   vivid --accent since it's a graphic. */
+.eyebrow {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 600;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+  color: var(--accent-text);
+  margin: 0 0 0.85rem 0;
+  display: inline-flex;
   align-items: center;
-  gap: 1rem;
-  flex-wrap: wrap;
-  font-size: 0.85em;
-  color: var(--color-muted);
-  margin-bottom: 0.75rem;
+  gap: 0.5rem;
 }
-
-.quiz-controls {
-  display: flex;
-  gap: 0.4rem;
-  flex-wrap: wrap;
+.eyebrow::before {
+  content: "";
+  width: 18px;
+  height: 1.5px;
+  background: var(--accent);
+  display: inline-block;
 }
 
-.quiz-controls button {
-  padding: 0.3rem 0.6rem;
-  font-size: 0.85em;
+/* Lead paragraph — the friendly orientation line under the page title.
+   Generous size, muted colour, balanced wrapping so two-line leads
+   don't leave orphans. */
+.lead {
+  font-family: var(--sans);
+  font-size: 1.05rem;
+  line-height: 1.55;
+  color: var(--fg-soft);
+  margin: -1.25rem 0 2.25rem 0;
+  max-width: 56ch;
+  font-weight: 400;
+}
+@media (max-width: 540px) {
+  .lead { font-size: 0.98rem; margin-top: -1rem; margin-bottom: 1.75rem; }
+  .eyebrow { font-size: 0.65rem; }
 }
 
-.quiz-meta .separator { margin: 0 0.4rem; opacity: 0.4; }
+/* ---------- Buttons ---------- */
 
-.difficulty {
-  padding: 0.1rem 0.5rem;
+button {
+  font: inherit;
+  cursor: pointer;
+  border: none;
+  background: none;
+  color: inherit;
+}
+
+button.primary {
+  background: var(--fg);
+  color: var(--bg);              /* AAA — black-on-white / inverted in dark */
+  padding: 0.85rem 1.5rem;
   border-radius: 99px;
-  font-size: 0.8em;
-  font-weight: 600;
-  text-transform: capitalize;
+  font-family: var(--sans);
+  font-size: 0.92rem;
+  font-weight: 500;
+  letter-spacing: -0.005em;
+  transition: transform 0.15s var(--ease), box-shadow 0.15s var(--ease);
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+/* Hover keeps the idle (AAA-strong) background and just adds elevation
+   + an accent-coloured glow. Swapping the bg to vivid accent broke AAA
+   because white-on-coral is ~2.7:1 in dark mode and ~3.8:1 in light. */
+button.primary:hover:not(:disabled) {
+  transform: translateY(-1px);
+  box-shadow: 0 10px 28px -10px var(--accent);
+}
+button.primary:active:not(:disabled) { transform: translateY(0); box-shadow: none; }
+button.primary:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
 }
-.difficulty.easy { background: var(--color-correct-bg); color: var(--color-correct); }
-.difficulty.medium { background: var(--color-medium-bg); color: var(--color-medium-fg); }
-.difficulty.hard { background: var(--color-incorrect-bg); color: var(--color-incorrect); }
 
-.question-card {
-  background: var(--color-card-bg);
-  padding: 1.5rem;
-  border-radius: var(--radius);
-  box-shadow: var(--shadow-card);
+button.ghost {
+  background: transparent;
+  color: var(--fg);
+  padding: 0.7rem 1.3rem;
+  border: 1px solid var(--hairline);
+  border-radius: 99px;
+  font-family: var(--sans);
+  font-size: 0.88rem;
+  font-weight: 500;
+  transition: border-color 0.15s var(--ease), background 0.15s var(--ease);
+}
+button.ghost:hover {
+  border-color: var(--fg-soft);
+  background: var(--surface-soft);
+}
+button.ghost.danger { color: var(--negative); border-color: var(--negative-soft); }
+button.ghost.danger:hover {
+  border-color: var(--negative);
+  background: var(--negative-soft);
 }
 
-.question-card h3 {
-  margin-top: 0;
-  font-size: 1.05rem;
-  color: var(--color-muted);
+button.link {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--muted);
+  padding: 0.25rem 0;
+  transition: color 0.15s var(--ease);
 }
+button.link:hover { color: var(--fg); }
+button.link.danger { color: var(--negative); }
+button.link.danger:hover { color: var(--negative); }
 
-.question-card #quiz-question {
-  font-size: 1.05rem;
+.back-button {
+  font-family: var(--sans);
+  font-size: 0.85rem;
   font-weight: 500;
+  color: var(--muted);
+  padding: 0;
+  margin-bottom: 1.5rem;
+  transition: color 0.15s var(--ease);
 }
+.back-button:hover { color: var(--fg); }
+
+/* ---------- Loading ---------- */
 
-.question-card #quiz-question p {
-  margin: 0.5rem 0;
+.loading {
+  font-family: var(--mono);
+  font-size: 0.85rem;
+  color: var(--muted);
+  text-align: center;
+  padding: 4rem 0;
 }
 
-.question-card #quiz-question p:first-child {
-  margin-top: 0;
+/* ---------- Step 1: Certification picker ---------- */
+
+#setup .cert-list {
+  display: grid;
+  gap: 1.25rem;
+  grid-template-columns: 1fr;
+  margin-top: 1.5rem;
 }
 
-fieldset#quiz-choices {
-  border: none;
-  padding: 0;
-  margin: 1rem 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
+@media (min-width: 720px) {
+  #setup .cert-list { grid-template-columns: 1fr 1fr; }
 }
 
-fieldset#quiz-choices label {
-  display: flex;
-  align-items: flex-start;
-  gap: 0.5rem;
-  padding: 0.75rem 1rem;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius);
+.cert-card {
+  --gradient: linear-gradient(135deg, var(--accent), #FFAB1F);
+
+  display: block;
+  text-align: left;
+  padding: 1.75rem;
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-2);
+  position: relative;
   cursor: pointer;
-  transition: border-color 0.15s, background 0.15s;
+  overflow: hidden;
+  transition: transform 0.25s var(--ease), box-shadow 0.25s var(--ease), border-color 0.15s var(--ease);
+  font-family: var(--sans);
+  isolation: isolate;
 }
 
-fieldset#quiz-choices label:hover {
-  border-color: var(--color-accent);
-}
+/* Distinctive per-cert accent gradients */
+.cert-card[data-cert="data-engineer-associate"]     { --gradient: linear-gradient(135deg, #FF4F2C, #FFAB1F); }
+.cert-card[data-cert="data-engineer-professional"]  { --gradient: linear-gradient(135deg, #6366F1, #4F46E5); }
+.cert-card[data-cert="data-analyst-associate"]      { --gradient: linear-gradient(135deg, #10B981, #14B8A6); }
+.cert-card[data-cert="ml-associate"]                { --gradient: linear-gradient(135deg, #A855F7, #EC4899); }
+.cert-card[data-cert="ml-professional"]             { --gradient: linear-gradient(135deg, #F59E0B, #DC2626); }
+.cert-card[data-cert="genai-engineer-associate"]    { --gradient: linear-gradient(135deg, #06B6D4, #3B82F6); }
 
-fieldset#quiz-choices label.disabled { cursor: default; }
+.cert-card::before {
+  content: "";
+  position: absolute;
+  inset: 0 0 auto 0;
+  height: 4px;
+  background: var(--gradient);
+  border-radius: var(--radius-lg) var(--radius-lg) 0 0;
+}
 
-fieldset#quiz-choices input[type=radio] { margin-top: 0.3rem; }
+.cert-card::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: var(--radius-lg);
+  background: var(--gradient);
+  opacity: 0;
+  z-index: -1;
+  filter: blur(40px);
+  transition: opacity 0.3s var(--ease);
+}
 
-fieldset#quiz-choices label.correct {
-  background: var(--color-correct-bg);
-  border-color: var(--color-correct);
+.cert-card:hover {
+  transform: translateY(-3px);
+  box-shadow: var(--shadow-3);
+  border-color: transparent;
 }
+.cert-card:hover::after { opacity: 0.15; }
 
-fieldset#quiz-choices label.incorrect {
-  background: var(--color-incorrect-bg);
-  border-color: var(--color-incorrect);
+.cert-card .cert-card-arrow {
+  position: absolute;
+  top: 1.5rem;
+  right: 1.5rem;
+  font-family: var(--mono);
+  font-size: 1.2rem;
+  color: var(--muted);
+  transition: transform 0.2s var(--ease), color 0.2s var(--ease);
+}
+.cert-card:hover .cert-card-arrow {
+  transform: translate(2px, -2px);
+  color: var(--fg);
 }
 
-fieldset#quiz-choices .choice-letter {
+.cert-card strong {
+  display: block;
+  font-family: var(--sans);
   font-weight: 600;
-  margin-right: 0.25rem;
-  min-width: 1.2em;
+  font-size: 1.45rem;
+  letter-spacing: -0.02em;
+  line-height: 1.15;
+  margin: 0.5rem 0 1.5rem 0;
+  color: var(--fg);
+  padding-right: 2rem;
 }
 
-.quiz-actions {
+.cert-card .cert-card-stats {
   display: flex;
+  align-items: baseline;
   gap: 0.5rem;
-  margin-top: 1rem;
+  margin-bottom: 0.85rem;
+}
+.cert-card .cert-card-stats .stat-num {
+  font-family: var(--sans);
+  font-weight: 600;
+  font-size: 2.5rem;
+  letter-spacing: -0.03em;
+  line-height: 1;
+  color: var(--fg);
+  font-variant-numeric: tabular-nums;
+}
+.cert-card .cert-card-stats .stat-label {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--muted);
+  line-height: 1.2;
 }
 
-#quiz-feedback {
-  margin-top: 1rem;
-  padding: 1rem;
-  border-radius: var(--radius);
-  background: var(--color-bg);
-  border: 1px solid var(--color-border);
+.cert-card .cert-card-meta {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.04em;
+  color: var(--fg-soft);
+  margin-bottom: 0.4rem;
+  font-variant-numeric: tabular-nums;
 }
 
-#quiz-feedback h4 {
-  margin: 0 0 0.5rem 0;
-  font-size: 0.95rem;
+.cert-card .cert-card-blueprint {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 400;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--muted);
+  padding-top: 1rem;
+  margin-top: 1rem;
+  border-top: 1px solid var(--hairline-soft);
+  font-variant-numeric: tabular-nums;
 }
 
-#quiz-feedback.correct h4 { color: var(--color-correct); }
-#quiz-feedback.incorrect h4 { color: var(--color-incorrect); }
+/* ---------- Step 2: Bank picker ---------- */
 
-#quiz-feedback p { margin: 0.4rem 0; }
-#quiz-feedback p:first-of-type { font-weight: 500; }
-#quiz-feedback p.fb-topic {
-  font-weight: normal;
-  font-size: 0.9em;
-  color: var(--color-muted);
-  margin-top: 0;
+#setup .cert-subtitle {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--muted);
+  margin: -1rem 0 2rem 0;
 }
 
-.session-bar {
-  display: flex;
-  justify-content: space-between;
-  font-size: 0.85em;
-  color: var(--color-muted);
-  margin-top: 1rem;
-  flex-wrap: wrap;
-  gap: 0.5rem;
+#setup .bank-list {
+  display: grid;
+  gap: 1rem;
+  grid-template-columns: 1fr;
 }
 
-/* Stats */
-#stats table {
-  width: 100%;
-  border-collapse: collapse;
-  margin: 1rem 0;
-  font-size: 0.95em;
+@media (min-width: 700px) {
+  #setup .bank-list { grid-template-columns: repeat(3, 1fr); }
 }
 
-#stats th, #stats td {
-  padding: 0.5rem 0.75rem;
+.bank-card {
+  display: block;
   text-align: left;
-  border-bottom: 1px solid var(--color-border);
+  padding: 1.5rem;
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  cursor: pointer;
+  transition: all 0.15s var(--ease);
+  font-family: var(--sans);
+  position: relative;
+}
+.bank-card:hover {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+  transform: translateY(-2px);
 }
 
-#stats th {
+.bank-card strong {
+  display: block;
+  font-family: var(--sans);
   font-weight: 600;
-  color: var(--color-muted);
-  font-size: 0.85em;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
+  font-size: 1.05rem;
+  letter-spacing: -0.01em;
+  margin-bottom: 1rem;
+  color: var(--fg);
 }
 
-#stats td.numeric { text-align: right; font-variant-numeric: tabular-nums; }
+.bank-card .bank-meta {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  letter-spacing: 0;
+  color: var(--fg-soft);
+  margin-bottom: 0.35rem;
+  font-variant-numeric: tabular-nums;
+}
 
-.stats-actions, .settings-actions {
-  display: flex;
-  gap: 0.5rem;
-  flex-wrap: wrap;
-  margin-top: 1rem;
+.bank-card .bank-purpose {
+  font-size: 0.82rem;
+  color: var(--muted);
+  font-weight: 400;
 }
 
-/* Settings */
-#settings label {
-  display: block;
-  margin: 1rem 0;
+/* ---------- Question header (above the question card) ---------- */
+
+.question-header {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin-bottom: 0.85rem;
+  font-family: var(--mono);
+  font-size: 0.72rem;
   font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--muted);
 }
-
-#settings select {
-  display: block;
-  width: 100%;
-  margin-top: 0.4rem;
-  padding: 0.5rem;
-  font: inherit;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius);
-  background: var(--color-card-bg);
-  color: var(--color-fg);
+.question-header .q-counter {
+  color: var(--fg);
+  font-weight: 600;
 }
+.question-header .rh-sep { color: var(--hairline); }
 
-code {
-  font-family: var(--font-mono);
-  font-size: 0.92em;
-  background: rgba(125,125,125,0.15);
-  padding: 0.1rem 0.3rem;
-  border-radius: 3px;
+/* ---------- Difficulty pill ---------- */
+
+.difficulty {
+  padding: 0.15rem 0.5rem;
+  border-radius: 99px;
+  font-family: var(--mono);
+  font-size: 0.62rem;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  display: inline-block;
 }
+.difficulty.easy    { background: var(--positive-soft); color: var(--positive); }
+.difficulty.medium  { background: var(--accent-soft);   color: var(--accent-text); }
+.difficulty.hard    { background: var(--negative-soft); color: var(--negative); }
 
-pre {
-  background: rgba(125,125,125,0.15);
-  padding: 0.75rem 1rem;
+/* ---------- Question card ---------- */
+
+.question-card {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  padding: 2rem;
+  box-shadow: var(--shadow-2);
+  /* Prevent unbreakable inline content from making the card wider than its
+     container. min-width:0 lets the box shrink past its intrinsic width. */
+  min-width: 0;
+  overflow-wrap: break-word;
+  position: relative;        /* so .q-watermark can absolute-position inside */
+}
+
+/* "Q.N" watermark — a faded oversized numeral in the card's top-right
+   that signals "this is item N in a sequence". Editorial pull-quote
+   feel. Pure decoration, aria-hidden in the markup. */
+.q-watermark {
+  position: absolute;
+  top: 0.85rem;
+  right: 1.25rem;
+  font-family: var(--mono);
+  font-weight: 500;
+  /* Cap the font-size lower so 3-digit Q-numbers (Q.100, Q.150 …) still
+     fit inside the reserved padding zone on #quiz-question without
+     overlapping the wrapped text. */
+  font-size: clamp(1.55rem, 3.2vw, 2.1rem);
+  letter-spacing: -0.05em;
+  line-height: 1;
+  /* Light theme: dark ink on a near-white surface — needs more opacity
+     than the dark theme to read at all. 0.035 was visually invisible. */
+  color: var(--fg);
+  opacity: 0.08;
+  pointer-events: none;
+  user-select: none;
+  font-variant-numeric: tabular-nums;
+  z-index: 0;
+  /* Anchor right edge so widths stay bounded as N grows */
+  max-width: 6rem;
+  text-align: right;
+  white-space: nowrap;
+}
+/* Dark theme: bright ink on a near-black surface — same opacity would
+   pop too much, so we dial it back. */
+:root[data-theme="dark"] .q-watermark { opacity: 0.06; }
+@media (prefers-color-scheme: dark) {
+  :root[data-theme="auto"] .q-watermark,
+  :root:not([data-theme]) .q-watermark { opacity: 0.06; }
+}
+.question-card > *:not(.q-watermark) { position: relative; z-index: 1; }
+@media (max-width: 540px) {
+  .q-watermark { top: 0.5rem; right: 0.85rem; font-size: 1.3rem; opacity: 0.07; max-width: 4rem; }
+  :root[data-theme="dark"] .q-watermark { opacity: 0.055; }
+  @media (prefers-color-scheme: dark) {
+    :root[data-theme="auto"] .q-watermark { opacity: 0.055; }
+  }
+}
+
+#quiz-feedback {
+  min-width: 0;
+  overflow-wrap: break-word;
+}
+
+@media (max-width: 640px) {
+  .question-card { padding: 1.5rem 1.25rem; }
+}
+
+#quiz-question {
+  font-family: var(--sans);
+  font-weight: 500;
+  font-size: 1.15rem;
+  line-height: 1.55;
+  letter-spacing: -0.012em;
+  color: var(--fg);
+  margin: 0 0 1.75rem 0;
+  /* Reserve right-side space for the Q.N watermark in the card corner.
+     Sized to clear up to "Q.150" comfortably (5 chars at the capped
+     watermark font-size + right offset). */
+  padding-right: 6rem;
+}
+@media (max-width: 540px) {
+  #quiz-question { padding-right: 4rem; }
+}
+#quiz-question p { margin: 0.5rem 0; }
+#quiz-question p:first-child { margin-top: 0; }
+#quiz-question p:last-child { margin-bottom: 0; }
+#quiz-question code {
+  font-size: 0.92em;
+  font-weight: 500;
+}
+
+/* ---------- Choices ---------- */
+
+fieldset#quiz-choices {
+  border: none;
+  padding: 0;
+  margin: 0 0 1.75rem 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+fieldset#quiz-choices label {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.85rem;
+  padding: 1rem 1.15rem;
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius);
+  cursor: pointer;
+  background: var(--surface);
+  transition: all 0.15s var(--ease);
+  position: relative;
+}
+/* Hover gives no visual cue — only an actual selection (click, arrow
+   keys, or 1-4) changes a row's appearance. This prevents leftover
+   mouse position from looking like a selection. The mouse cursor turns
+   into a pointer on hover, which is enough affordance that the row is
+   clickable. */
+
+/* Selected — uses a distinct blue (not the red accent) so the
+   "I picked this" state can never be confused with the red "incorrect"
+   state after submit. Green = correct, red = incorrect, blue = picked. */
+fieldset#quiz-choices label:has(input[type=radio]:checked):not(.correct):not(.incorrect) {
+  border-color: var(--selected);
+  background: var(--selected-soft);
+}
+fieldset#quiz-choices label.disabled {
+  cursor: default;
+  pointer-events: none;
+}
+
+fieldset#quiz-choices input[type=radio] {
+  appearance: none;
+  width: 18px;
+  height: 18px;
+  border: 1.5px solid var(--hairline);
+  border-radius: 50%;
+  margin: 0.15rem 0 0 0;
+  flex-shrink: 0;
+  background: var(--surface);
+  cursor: pointer;
+  transition: all 0.15s var(--ease);
+  position: relative;
+}
+fieldset#quiz-choices input[type=radio]:hover { border-color: var(--fg-soft); }
+fieldset#quiz-choices input[type=radio]:checked {
+  border-color: var(--fg);
+  background: var(--fg);
+  box-shadow: inset 0 0 0 4px var(--surface);
+}
+fieldset#quiz-choices input[type=radio]:disabled { opacity: 0.5; cursor: default; }
+
+fieldset#quiz-choices .choice-letter {
+  font-family: var(--mono);
+  font-weight: 600;
+  font-size: 0.85rem;
+  color: var(--muted);
+  margin: 0.15rem 0 0 0;
+  flex-shrink: 0;
+  min-width: 1.25em;
+  text-transform: uppercase;
+  transition: color 0.15s var(--ease);
+}
+
+fieldset#quiz-choices label:hover .choice-letter { color: var(--fg); }
+fieldset#quiz-choices label input[type=radio]:checked ~ .choice-letter { color: var(--fg); }
+
+fieldset#quiz-choices label .choice-text {
+  flex: 1;
+  font-size: 0.95rem;
+  line-height: 1.55;
+  color: var(--fg);
+}
+
+fieldset#quiz-choices label.correct {
+  background: var(--positive-soft);
+  border-color: var(--positive);
+}
+fieldset#quiz-choices label.correct .choice-letter,
+fieldset#quiz-choices label.correct .choice-text { color: var(--positive); }
+fieldset#quiz-choices label.correct input[type=radio] { border-color: var(--positive); }
+
+fieldset#quiz-choices label.incorrect {
+  background: var(--negative-soft);
+  border-color: var(--negative);
+}
+fieldset#quiz-choices label.incorrect .choice-letter,
+fieldset#quiz-choices label.incorrect .choice-text { color: var(--negative); }
+
+/* ---------- Sticky bottom action bar (quiz mode only) ---------- */
+
+.actionbar {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 50;
+  background: color-mix(in srgb, var(--bg) 92%, transparent);
+  backdrop-filter: saturate(180%) blur(12px);
+  -webkit-backdrop-filter: saturate(180%) blur(12px);
+  border-top: 1px solid var(--hairline);
+}
+.actionbar[hidden] { display: none; }
+
+/* 3-column grid for row 1 keeps the kbd-hint optically centred no matter
+   how wide the timer or button cluster grows. Row 2 (actionbar-right)
+   spans all columns via grid-column: 1 / -1. */
+.actionbar-inner {
+  max-width: 1080px;
+  margin: 0 auto;
+  padding: 0.85rem 1.5rem;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
+  align-items: center;
+  gap: 0.5rem 1rem;
+  min-height: 64px;
+}
+
+#quiz-timer.actionbar-timer {
+  grid-column: 1;
+  justify-self: start;
+}
+
+.actionbar-inner > .kbd-hint {
+  grid-column: 2;
+  justify-self: center;
+  text-align: center;
+  margin-left: 0;          /* override the inline-flow margin-left */
+  white-space: nowrap;
+}
+
+.actionbar-left {
+  grid-column: 3;
+  justify-self: end;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.75rem;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.actionbar-right {
+  grid-column: 1 / -1;     /* row 2 spans the full width */
+  display: inline-flex;
+  align-items: center;
+  gap: 0.85rem;
+  flex-wrap: wrap;
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.02em;
+  color: var(--muted);
+  font-variant-numeric: tabular-nums;
+}
+.actionbar-right #session-stats,
+.actionbar-right #bank-stats { color: var(--fg-soft); }
+.actionbar-right .rh-sep { color: var(--hairline); }
+.actionbar-right .actionbar-divider {
+  width: 1px;
+  height: 16px;
+  background: var(--hairline);
+  margin: 0 0.15rem;
+}
+
+/* When quiz is active, leave room at the bottom of main so the fixed
+   actionbar doesn't cover the last few choices / feedback rows.
+   --actionbar-h is updated by a ResizeObserver in app.js whenever the
+   actionbar's height changes (wrap onto a second row, viewport resize,
+   feedback visibility, etc). +1.5rem of breathing room. */
+body.quiz-active main {
+  padding-bottom: calc(var(--actionbar-h, 7rem) + 1.5rem);
+}
+body.quiz-active .page-footer { display: none; }
+
+.kbd-hint {
+  font-family: var(--mono);
+  font-size: 0.68rem;
+  font-weight: 400;
+  color: var(--muted);
+  letter-spacing: 0.02em;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  flex-wrap: wrap;
+  margin-left: 0.5rem;
+}
+.kbd-hint[hidden] { display: none; }
+.kbd-hint kbd {
+  display: inline-block;
+  min-width: 1.5em;
+  padding: 0.1rem 0.4rem;
+  border: 1px solid var(--hairline);
+  border-bottom-width: 2px;
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--fg);
+  font-family: var(--mono);
+  font-weight: 500;
+  font-size: 0.7rem;
+  text-align: center;
+}
+
+@media (max-width: 720px) {
+  .actionbar-inner { padding: 0.65rem 1rem; gap: 0.6rem; }
+  .actionbar-right { font-size: 0.65rem; gap: 0.5rem; }
+  .actionbar-right .actionbar-divider { display: none; }
+  .actionbar-right #bank-stats { display: none; }  /* save room */
+  .kbd-hint { display: none; }  /* hide kbd hints on small screens */
+}
+
+/* ---------- Feedback ---------- */
+
+#quiz-feedback {
+  margin-top: 1.5rem;
+  padding: 1.5rem;
+  background: var(--surface-soft);
+  border-radius: var(--radius);
+  border-left: 3px solid var(--positive);
+}
+#quiz-feedback.incorrect { border-left-color: var(--negative); }
+
+/* Verdict heading — large + confident sans, not the small mono-uppercase
+   it used to be. Pairs a coloured circular badge with the verdict label
+   so the post-submit moment lands with weight, like a stamp. */
+#quiz-feedback h4 {
+  margin: 0 0 0.9rem 0;
+  font-family: var(--sans);
+  font-size: 1.35rem;
+  font-weight: 600;
+  letter-spacing: -0.02em;
+  line-height: 1.2;
+  color: var(--positive);
+  display: inline-flex;
+  align-items: center;
+  gap: 0.55rem;
+  text-transform: none;
+}
+#quiz-feedback.incorrect h4 { color: var(--negative); }
+@media (max-width: 540px) {
+  #quiz-feedback h4 { font-size: 1.15rem; }
+}
+
+#quiz-feedback p { margin: 0.5rem 0; font-size: 0.95rem; line-height: 1.6; }
+
+#quiz-feedback p.fb-short {
+  font-family: var(--sans);
+  font-size: 1.02rem;
+  font-weight: 500;
+  color: var(--fg);
+  margin-bottom: 0.85rem;
+  letter-spacing: -0.005em;
+}
+
+#quiz-feedback p.fb-topic {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 500;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--muted);
+  margin-top: 0;
+  margin-bottom: 0.85rem;
+}
+
+#quiz-feedback pre { margin: 0.85rem 0; }
+
+/* (quiz-footer removed — replaced by sticky bottom actionbar) */
+
+/* ---------- Stats view ---------- */
+
+#stats table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 1.5rem 0;
+  font-size: 0.92rem;
+}
+#stats th, #stats td {
+  padding: 0.75rem 0.85rem;
+  text-align: left;
+  border-bottom: 1px solid var(--hairline);
+}
+#stats th {
+  font-family: var(--mono);
+  font-weight: 600;
+  font-size: 0.7rem;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  border-bottom-color: var(--fg-soft);
+}
+#stats td.numeric {
+  text-align: right;
+  font-family: var(--mono);
+  font-variant-numeric: tabular-nums;
+}
+#stats tr:last-child td {
+  font-weight: 600;
+  border-bottom: none;
+  border-top: 1px solid var(--fg-soft);
+}
+#stats h3 {
+  font-family: var(--sans);
+  font-weight: 600;
+  font-size: 1.2rem;
+  letter-spacing: -0.015em;
+  margin: 2rem 0 0.75rem;
+}
+#stats ul {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+#stats ul li {
+  padding: 0.65rem 0;
+  border-bottom: 1px solid var(--hairline-soft);
+  font-size: 0.92rem;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+
+.stats-actions, .settings-actions {
+  display: flex;
+  gap: 0.75rem;
+  flex-wrap: wrap;
+  margin-top: 1.5rem;
+}
+
+/* Past-attempts header row on the stats page — heading + clear button */
+.stats-history-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+}
+.stats-history-head h3 { flex: 1; }
+
+/* ---------- Settings ---------- */
+
+#settings .section-intro {
+  margin: -1rem 0 1.75rem 0;
+  color: var(--muted);
+  font-size: 0.95rem;
+  line-height: 1.55;
+}
+
+.settings-panel {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-2);
+  overflow: hidden;
+}
+
+.settings-row {
+  display: grid;
+  grid-template-columns: 1fr minmax(280px, 360px);
+  gap: 2rem;
+  padding: 1.5rem 1.75rem;
+  align-items: center;
+  border-bottom: 1px solid var(--hairline);
+}
+.settings-row:last-child { border-bottom: none; }
+
+.settings-row-meta { min-width: 0; }
+.settings-row-meta h4 {
+  margin: 0 0 0.3rem 0;
+  font-family: var(--sans);
+  font-size: 1rem;
+  font-weight: 600;
+  letter-spacing: -0.01em;
+  color: var(--fg);
+}
+.settings-row-meta p {
+  margin: 0;
+  color: var(--muted);
+  font-size: 0.85rem;
+  line-height: 1.55;
+}
+
+/* Custom-styled select — native chevron replaced with a CSS arrow so
+   it picks up the theme color and stays consistent across browsers. */
+.settings-field {
+  position: relative;
+}
+.settings-field::after {
+  content: "";
+  position: absolute;
+  right: 1rem;
+  top: 50%;
+  width: 8px;
+  height: 8px;
+  border-right: 1.5px solid var(--fg-soft);
+  border-bottom: 1.5px solid var(--fg-soft);
+  transform: translateY(-70%) rotate(45deg);
+  pointer-events: none;
+  transition: border-color 0.15s;
+}
+.settings-field:hover::after { border-color: var(--fg); }
+
+.settings-field select {
+  display: block;
+  width: 100%;
+  padding: 0.7rem 2.5rem 0.7rem 0.95rem;
+  font: inherit;
+  font-family: var(--sans);
+  font-size: 0.92rem;
+  background: var(--bg);
+  color: var(--fg);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius);
+  cursor: pointer;
+  appearance: none;
+  -webkit-appearance: none;
+  transition: border-color 0.15s, background 0.15s;
+}
+.settings-field select:hover {
+  border-color: var(--fg-soft);
+  background: var(--surface);
+}
+.settings-field select:focus {
+  outline: none;
+  border-color: var(--selected);
+  box-shadow: 0 0 0 3px var(--selected-soft);
+}
+
+@media (max-width: 700px) {
+  .settings-row {
+    grid-template-columns: 1fr;
+    gap: 0.85rem;
+    padding: 1.25rem 1.25rem;
+  }
+}
+
+/* ============================================================
+   Session-summary screen
+   ============================================================
+   Shown when the user has visited every question in the current
+   bank and answered at least one. Hero score, per-module breakdown,
+   weak-area callout, time + streak stats, past-attempt history,
+   and HTML/CSV export.
+   ============================================================ */
+
+#summary { padding-bottom: 2rem; }
+
+.summary-timestamp {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  letter-spacing: 0.04em;
+  color: var(--muted);
+  margin: -1rem 0 2rem 0;
+  font-variant-numeric: tabular-nums;
+}
+
+/* --- Hero --- */
+.summary-hero {
+  display: flex;
+  align-items: center;
+  gap: 2.5rem;
+  padding: 2rem 2rem;
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-2);
+  margin-bottom: 1.5rem;
+  position: relative;
+  overflow: hidden;
+}
+.summary-hero::before {
+  content: "";
+  position: absolute;
+  inset: 0 0 auto 0;
+  height: 4px;
+  background: var(--accent);
+}
+.summary-hero[data-tone="great"]::before { background: linear-gradient(90deg, var(--positive), #14B8A6); }
+.summary-hero[data-tone="good"]::before  { background: var(--positive); }
+.summary-hero[data-tone="warn"]::before  { background: var(--warn); }
+.summary-hero[data-tone="weak"]::before  { background: var(--negative); }
+
+.summary-num-wrap {
+  display: flex;
+  align-items: baseline;
+  font-family: var(--sans);
+  font-weight: 600;
+  letter-spacing: -0.05em;
+  line-height: 1;
+  font-variant-numeric: tabular-nums;
+  flex-shrink: 0;
+}
+.summary-num {
+  font-size: clamp(3.5rem, 11vw, 5.5rem);
+  color: var(--fg);
+}
+.summary-hero[data-tone="great"] .summary-num { color: var(--positive); }
+.summary-hero[data-tone="good"]  .summary-num { color: var(--positive); }
+.summary-hero[data-tone="warn"]  .summary-num { color: var(--warn); }
+.summary-hero[data-tone="weak"]  .summary-num { color: var(--negative); }
+.summary-num-pct {
+  font-size: 1.75rem;
+  color: var(--muted);
+  margin-left: 0.05em;
+  font-weight: 500;
+}
+
+.summary-hero-meta {
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+  min-width: 0;
+}
+.summary-fraction {
+  font-family: var(--sans);
+  font-size: 1.2rem;
+  font-weight: 500;
+  letter-spacing: -0.01em;
+  color: var(--fg);
+}
+.summary-verdict {
+  font-family: var(--mono);
+  font-size: 0.85rem;
+  font-weight: 600;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  color: var(--fg-soft);
+  margin-top: 0.4rem;
+}
+.summary-verdict[data-tone="great"] { color: var(--positive); }
+.summary-verdict[data-tone="good"]  { color: var(--positive); }
+.summary-verdict[data-tone="warn"]  { color: var(--warn); }
+.summary-verdict[data-tone="weak"]  { color: var(--negative); }
+.summary-verdict-sub {
+  font-family: var(--sans);
+  font-size: 0.88rem;
+  color: var(--muted);
+  margin-top: 0.1rem;
+}
+
+@media (max-width: 540px) {
+  .summary-hero {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 0.85rem;
+    padding: 1.5rem 1.25rem;
+  }
+  .summary-num { font-size: 3.5rem; }
+  .summary-num-pct { font-size: 1.35rem; }
+  .summary-fraction { font-size: 1.05rem; }
+}
+
+/* --- Weak-area callout --- */
+.summary-callout {
+  padding: 1.15rem 1.25rem;
+  border-radius: var(--radius);
+  margin-bottom: 1.75rem;
+  border-left: 3px solid var(--negative);
+  background: var(--negative-soft);
+}
+.summary-callout-title {
+  font-family: var(--sans);
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--negative);
+  margin-bottom: 0.5rem;
+  letter-spacing: -0.005em;
+}
+.summary-callout-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+.summary-callout-list li {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  padding: 0.3rem 0;
+  gap: 1rem;
+}
+.summary-callout-list .wk-name {
+  font-family: var(--sans);
+  font-size: 0.92rem;
+  color: var(--fg);
+  flex: 1;
+  min-width: 0;
+}
+.summary-callout-list .wk-pct {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  color: var(--negative);
+  font-variant-numeric: tabular-nums;
+  font-weight: 500;
+  flex-shrink: 0;
+}
+
+/* --- Section titles (between summary blocks) --- */
+.summary-section-title {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  font-weight: 600;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--muted);
+  margin: 2rem 0 0.85rem;
+}
+
+/* --- Per-module domain breakdown --- */
+.summary-domains {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  overflow: hidden;
+  margin-bottom: 1.5rem;
+}
+.summary-domain-row {
+  padding: 1rem 1.25rem;
+  border-bottom: 1px solid var(--hairline-soft);
+}
+.summary-domain-row:last-child { border-bottom: none; }
+.summary-domain-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  margin-bottom: 0.55rem;
+  gap: 1rem;
+}
+.summary-domain-name {
+  font-family: var(--sans);
+  font-size: 0.95rem;
+  font-weight: 500;
+  color: var(--fg);
+  flex: 1;
+  min-width: 0;
+}
+.summary-domain-stat {
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  color: var(--fg-soft);
+  font-variant-numeric: tabular-nums;
+  flex-shrink: 0;
+}
+.summary-meter {
+  height: 6px;
+  background: var(--hairline-soft);
+  border-radius: 99px;
+  overflow: hidden;
+}
+.summary-meter-fill {
+  height: 100%;
+  border-radius: 99px;
+  background: var(--fg-soft);
+  transition: width 0.5s var(--ease);
+}
+.summary-meter-fill[data-tone="great"] { background: linear-gradient(90deg, var(--positive), #14B8A6); }
+.summary-meter-fill[data-tone="good"]  { background: var(--positive); }
+.summary-meter-fill[data-tone="warn"]  { background: var(--warn); }
+.summary-meter-fill[data-tone="weak"]  { background: var(--negative); }
+
+/* --- Stats grid (time / streak metric cards) --- */
+.summary-stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  gap: 0.85rem;
+  margin-bottom: 1.75rem;
+}
+.summary-metric {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius);
+  padding: 1rem 1.15rem;
+}
+.summary-metric-label {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 500;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--muted);
+  margin-bottom: 0.35rem;
+}
+.summary-metric-value {
+  font-family: var(--sans);
+  font-size: 1.5rem;
+  font-weight: 600;
+  letter-spacing: -0.015em;
+  color: var(--fg);
+  font-variant-numeric: tabular-nums;
+}
+.summary-metric-sub {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  color: var(--muted);
+  margin-top: 0.2rem;
+  letter-spacing: 0.02em;
+}
+
+/* --- Actions row --- */
+.summary-actions {
+  display: flex;
+  gap: 0.75rem;
+  flex-wrap: wrap;
+  margin-top: 2rem;
+  margin-bottom: 1.5rem;
+}
+.summary-actions button.primary,
+.summary-actions button.ghost {
+  flex: 0 1 auto;
+}
+
+/* --- Export bar (HTML / CSV) --- */
+.summary-export {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 1.15rem 0 0;
+  border-top: 1px solid var(--hairline);
+  font-family: var(--mono);
+  font-size: 0.78rem;
+  color: var(--muted);
+  flex-wrap: wrap;
+}
+.summary-export-label {
+  color: var(--muted);
+  margin-right: 0.35rem;
+}
+.summary-export button.link {
+  font-family: var(--mono);
+  font-size: 0.74rem;
+  letter-spacing: 0.04em;
+  text-transform: none;
+  color: var(--fg-soft);
+  padding: 0.4rem 0.75rem;
+  border-radius: 99px;
+  border: 1px solid var(--hairline);
+  background: var(--surface);
+  cursor: pointer;
+  transition: border-color 0.15s, color 0.15s, background 0.15s;
+}
+.summary-export button.link:hover {
+  border-color: var(--accent);
+  color: var(--accent-text);
+  background: var(--accent-soft);
+}
+
+/* --- Past-attempts list --- */
+.attempt-list {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  overflow: hidden;
+  margin-bottom: 1.5rem;
+}
+.attempt-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.4fr) auto auto auto auto auto;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.85rem 1.15rem;
+  background: transparent;
+  border: none;
+  border-bottom: 1px solid var(--hairline-soft);
+  text-align: left;
+  cursor: pointer;
+  transition: background 0.15s var(--ease);
+  font-family: var(--mono);
+  font-size: 0.82rem;
+  color: var(--fg-soft);
+  width: 100%;
+}
+.attempt-row:last-child { border-bottom: none; }
+@media (hover: hover) {
+  .attempt-row:hover { background: var(--surface-soft); }
+  .attempt-row:hover .attempt-arrow { color: var(--accent); transform: translateX(2px); }
+}
+.attempt-when { font-variant-numeric: tabular-nums; display: inline-flex; gap: 0.5rem; align-items: baseline; }
+.attempt-date { color: var(--fg); font-weight: 500; }
+.attempt-time { color: var(--muted); }
+.attempt-pct {
+  font-family: var(--sans);
+  font-size: 1.05rem;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  color: var(--fg-soft);
+  justify-self: end;
+}
+.attempt-pct[data-tone="great"] { color: var(--positive); }
+.attempt-pct[data-tone="good"]  { color: var(--positive); }
+.attempt-pct[data-tone="warn"]  { color: var(--warn); }
+.attempt-pct[data-tone="weak"]  { color: var(--negative); }
+.attempt-fraction, .attempt-duration { font-variant-numeric: tabular-nums; color: var(--muted); }
+.attempt-duration.muted { color: var(--hairline); }
+.attempt-verdict {
+  font-size: 0.65rem;
+  font-weight: 600;
+  letter-spacing: 0.1em;
+  padding: 0.18rem 0.55rem;
+  border-radius: 99px;
+  text-transform: uppercase;
+}
+.attempt-verdict[data-tone="good"] { background: var(--positive-soft); color: var(--positive); }
+.attempt-verdict[data-tone="weak"] { background: var(--negative-soft); color: var(--negative); }
+.attempt-verdict.muted { background: transparent; color: var(--muted); border: 1px solid var(--hairline-soft); font-weight: 500; }
+.attempt-arrow {
+  font-family: var(--mono);
+  color: var(--muted);
+  font-size: 1rem;
+  transition: transform 0.15s var(--ease), color 0.15s;
+}
+
+@media (max-width: 720px) {
+  .attempt-row {
+    grid-template-columns: 1fr auto auto;
+    grid-template-rows: auto auto;
+    gap: 0.4rem 0.85rem;
+    padding: 0.75rem 1rem;
+  }
+  .attempt-when { grid-column: 1 / -1; font-size: 0.72rem; }
+  .attempt-pct { grid-column: 1; grid-row: 2; justify-self: start; }
+  .attempt-fraction { grid-column: 2; grid-row: 2; }
+  .attempt-duration { grid-column: 3; grid-row: 2; }
+  .attempt-verdict { display: none; }
+  .attempt-arrow { display: none; }
+}
+
+/* ---------- Pause overlay ----------
+   Full-screen blur + "Paused" card. Blocks interaction with the quiz
+   underneath so the user can step away without accidentally answering.
+   When body.timer-paused is set, the main column gets a strong blur. */
+
+body.timer-paused main {
+  filter: blur(8px) saturate(85%) brightness(0.95);
+  transition: filter 0.25s var(--ease);
+  pointer-events: none;
+  user-select: none;
+}
+
+.pause-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 1050;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1.5rem;
+  background: color-mix(in srgb, var(--bg) 70%, transparent);
+  backdrop-filter: blur(12px) saturate(140%);
+  -webkit-backdrop-filter: blur(12px) saturate(140%);
+  animation: modal-backdrop-in 0.2s var(--ease);
+}
+.pause-overlay[hidden] { display: none !important; }
+
+.pause-card {
+  width: 100%;
+  max-width: 480px;
+  text-align: center;
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  box-shadow:
+    0 1px 0 var(--hairline),
+    0 24px 64px -16px rgba(0, 0, 0, 0.35);
+  padding: 2.25rem 2rem 1.75rem;
+  animation: modal-pop 0.25s cubic-bezier(0.16, 0.84, 0.44, 1);
+}
+.pause-eyebrow {
+  font-family: var(--mono);
+  font-size: 0.7rem;
+  font-weight: 600;
+  letter-spacing: 0.16em;
+  text-transform: uppercase;
+  color: var(--accent);
+  margin: 0 0 0.65rem;
+}
+.pause-title {
+  font-family: var(--sans);
+  font-size: 2.1rem;
+  font-weight: 600;
+  letter-spacing: -0.025em;
+  color: var(--fg);
+  margin: 0 0 0.85rem;
+  line-height: 1.1;
+}
+.pause-message {
+  font-family: var(--sans);
+  font-size: 0.95rem;
+  line-height: 1.55;
+  color: var(--fg-soft);
+  margin: 0 auto 1.5rem;
+  max-width: 36ch;
+}
+.pause-card #btn-resume {
+  min-width: 200px;
+  padding: 0.85rem 1.75rem;
+  font-size: 0.95rem;
+}
+.pause-hint {
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  color: var(--muted);
+  margin: 1.25rem 0 0;
+  letter-spacing: 0.02em;
+}
+.pause-hint kbd {
+  display: inline-block;
+  min-width: 1.5em;
+  padding: 0.1rem 0.4rem;
+  border: 1px solid var(--hairline);
+  border-bottom-width: 2px;
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--fg);
+  font-family: var(--mono);
+  font-weight: 500;
+  font-size: 0.7rem;
+  text-align: center;
+  margin: 0 0.15rem;
+}
+
+@media (max-width: 540px) {
+  .pause-card { padding: 1.75rem 1.5rem 1.5rem; }
+  .pause-title { font-size: 1.7rem; }
+  .pause-message { font-size: 0.9rem; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .pause-overlay, .pause-card { animation: none; }
+  body.timer-paused main { transition: none; }
+}
+
+/* ---------- Custom confirm modal (theme-aware, focus-trapped) ----------
+   Replaces native window.confirm() with a styled dialog that matches the
+   rest of the design. Backdrop blur + scale-in animation; respects
+   prefers-reduced-motion. Focus is trapped between Cancel/Confirm and
+   restored to the trigger element on close (see customConfirm in app.js). */
+
+.modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 1100;            /* above masthead (50) + actionbar (50) + toasts (1000) */
+  background: color-mix(in srgb, var(--fg) 38%, transparent);
+  backdrop-filter: blur(8px) saturate(140%);
+  -webkit-backdrop-filter: blur(8px) saturate(140%);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1.5rem;
+  animation: modal-backdrop-in 0.16s var(--ease);
+}
+.modal-backdrop[hidden] { display: none !important; }
+
+.modal {
+  width: 100%;
+  max-width: 440px;
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius-lg);
+  box-shadow:
+    0 1px 0 var(--hairline),
+    0 20px 60px -20px rgba(0,0,0,0.4),
+    0 8px 16px -8px rgba(0,0,0,0.2);
+  padding: 1.5rem 1.5rem 1.25rem;
+  transform-origin: center;
+  animation: modal-pop 0.2s cubic-bezier(0.16, 0.84, 0.44, 1);
+}
+.modal:focus { outline: none; }
+
+.modal-title {
+  margin: 0 0 0.5rem 0;
+  font-family: var(--sans);
+  font-size: 1.15rem;
+  font-weight: 600;
+  letter-spacing: -0.015em;
+  color: var(--fg);
+  line-height: 1.3;
+}
+
+.modal-message {
+  margin: 0 0 1.5rem 0;
+  font-family: var(--sans);
+  font-size: 0.95rem;
+  line-height: 1.55;
+  color: var(--fg-soft);
+}
+
+.modal-actions {
+  display: flex;
+  gap: 0.6rem;
+  justify-content: flex-end;
+  align-items: center;
+}
+.modal-actions button {
+  min-height: 44px;            /* touch target */
+}
+/* Danger-flavored primary button (used for destructive confirms like
+   "Reset progress?" and "Leave timed exam?"). Hardcoded dark red so
+   white text stays ≥8:1 contrast in BOTH themes — the semantic
+   `--negative` token is too light in dark mode (it's calibrated for
+   text on dark bg, not button bg). */
+.modal-actions .primary.danger {
+  background: #991B1B;
+  color: #FFFFFF;
+}
+@media (hover: hover) {
+  .modal-actions .primary.danger:hover:not(:disabled) {
+    background: #7F1D1D;
+    box-shadow: 0 8px 24px -10px rgba(153, 27, 27, 0.5);
+  }
+}
+
+@keyframes modal-backdrop-in {
+  from { opacity: 0; }
+  to   { opacity: 1; }
+}
+@keyframes modal-pop {
+  from { opacity: 0; transform: scale(0.94) translateY(10px); }
+  to   { opacity: 1; transform: scale(1) translateY(0); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .modal-backdrop, .modal { animation: none; }
+}
+
+/* ---------- Code blocks (Prism syntax highlighting) ---------- */
+
+code {
+  font-family: var(--mono);
+  font-size: 0.86em;
+  font-weight: 500;
+  background: var(--code-bg);
+  padding: 0.12rem 0.4rem;
+  border-radius: 4px;
+  color: var(--fg);
+  /* Long unbroken strings like spark.sql.streaming.stateStore.providerClass
+     are a single "word" with no word-break points. Allow the renderer to
+     break anywhere when there's no better option, otherwise the inline
+     code overflows the right edge of the question/feedback container. */
+  overflow-wrap: anywhere;
+  word-break: break-word;
+}
+
+/* Code blocks (pre > code) handle long lines with horizontal scroll
+   instead — preserving whitespace + indentation is more important there
+   than fitting in the container. */
+pre code, pre[class*="language-"] code {
+  overflow-wrap: normal;
+  word-break: normal;
+}
+
+pre, pre[class*="language-"] {
+  background: var(--code-bg);
+  padding: 1rem 1.15rem;
   border-radius: var(--radius);
   overflow-x: auto;
-  font-size: 0.88em;
-  margin: 0.75rem 0;
-  font-family: var(--font-mono);
-  line-height: 1.45;
+  font-size: 0.82rem;
+  margin: 1rem 0;
+  font-family: var(--mono);
+  line-height: 1.55;
   white-space: pre;
-  border: 1px solid var(--color-border);
+  border: 1px solid var(--hairline);
+  color: var(--fg);
+  text-shadow: none;
 }
-
-pre code {
+pre code, pre[class*="language-"] code {
   background: none;
   padding: 0;
   font-size: inherit;
+  font-weight: 400;
   border-radius: 0;
+  color: inherit;
+  text-shadow: none;
 }
 
-#quiz-question pre,
-#quiz-feedback pre {
-  white-space: pre;
+/* Light-mode Prism overrides */
+:root[data-theme="light"] .token.comment,
+:root[data-theme="light"] .token.prolog,
+:root[data-theme="light"] .token.doctype,
+:root[data-theme="light"] .token.cdata { color: #8a8a85; font-style: italic; }
+:root[data-theme="light"] .token.punctuation { color: #52525B; }
+:root[data-theme="light"] .token.keyword,
+:root[data-theme="light"] .token.boolean,
+:root[data-theme="light"] .token.null { color: #DC2626; }
+:root[data-theme="light"] .token.string,
+:root[data-theme="light"] .token.char,
+:root[data-theme="light"] .token.attr-value { color: #15803D; }
+:root[data-theme="light"] .token.number { color: #B45309; }
+:root[data-theme="light"] .token.function,
+:root[data-theme="light"] .token.class-name { color: #1D4ED8; }
+:root[data-theme="light"] .token.operator { color: #52525B; }
+
+@media (prefers-color-scheme: light) {
+  :root[data-theme="auto"] .token.comment,
+  :root:not([data-theme]) .token.comment { color: #8a8a85; font-style: italic; }
+  :root[data-theme="auto"] .token.keyword,
+  :root:not([data-theme]) .token.keyword { color: #DC2626; }
+  :root[data-theme="auto"] .token.string,
+  :root:not([data-theme]) .token.string { color: #15803D; }
+  :root[data-theme="auto"] .token.number,
+  :root:not([data-theme]) .token.number { color: #B45309; }
+  :root[data-theme="auto"] .token.function,
+  :root:not([data-theme]) .token.function { color: #1D4ED8; }
+}
+
+/* ---------- Page footer — refined as a colophon ----------
+   Three rhythmic lines of decreasing weight:
+     1. plain-language tagline (what the site is)
+     2. source / license / copyright (the meta line)
+     3. set notes (typeface, privacy)
+   Treated as a printer's mark below the content stream. */
+
+.page-footer {
+  max-width: var(--content-w);
+  margin: 5rem auto 0;
+  padding: 2rem 2rem 3rem;
+  border-top: 1px solid var(--hairline);
+  font-family: var(--mono);
+  font-size: 0.72rem;
+  letter-spacing: 0.02em;
+  color: var(--muted);
+  line-height: 1.65;
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+}
+.page-footer p { margin: 0; }
+.page-footer .footer-tag {
+  color: var(--fg-soft);
+  font-weight: 500;
+  font-size: 0.78rem;
+  letter-spacing: 0;
+  font-family: var(--sans);
+}
+.page-footer .footer-meta { color: var(--muted); }
+.page-footer .footer-meta a {
+  color: var(--fg-soft);
+  text-decoration-color: var(--hairline);
+}
+.page-footer .footer-meta a:hover { text-decoration-color: var(--accent); color: var(--accent-text); }
+.page-footer .footer-colophon {
+  margin-top: 0.5rem;
+  color: var(--muted);
+  font-size: 0.68rem;
+  font-style: italic;
+  letter-spacing: 0.015em;
+}
+.page-footer .footer-colophon .colophon-mark {
+  font-style: normal;
+  font-weight: 500;
+  color: var(--fg-soft);
+  letter-spacing: 0;
+}
+.page-footer .colophon { font-style: italic; }
+.page-footer .rh-sep { color: var(--hairline); padding: 0 0.25rem; }
+@media (max-width: 540px) {
+  .page-footer { padding: 1.5rem 1rem 2.25rem; margin-top: 3.5rem; }
+  .page-footer .footer-tag { font-size: 0.74rem; }
+  .page-footer .footer-colophon { font-size: 0.64rem; }
+}
+
+/* ---------- Focus ---------- */
+
+:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
+button:focus-visible { outline-offset: 3px; }
+
+/* The choice label uses a subtle background tint (matching hover) for both
+   mouse-click and keyboard-arrow selection — see :has(input:checked) above.
+   Drop the loud orange focus outline so the choice row never looks "stuck"
+   after keyboard navigation. The `!important` is intentional: it overrides
+   the global `:focus-visible` rule plus any browser-default focus indicator
+   the UA might draw on appearance:none radios. */
+fieldset#quiz-choices label:focus-within,
+fieldset#quiz-choices label:focus-within * {
+  outline: none !important;
+}
+fieldset#quiz-choices input[type=radio]:focus,
+fieldset#quiz-choices input[type=radio]:focus-visible {
+  outline: none !important;
+  outline-offset: 0 !important;
+  box-shadow: none;
+}
+/* Preserve the filled-center indicator on the currently-checked radio
+   even while it has keyboard focus (the rule above stripped its
+   box-shadow). */
+fieldset#quiz-choices input[type=radio]:checked,
+fieldset#quiz-choices input[type=radio]:checked:focus,
+fieldset#quiz-choices input[type=radio]:checked:focus-visible {
+  box-shadow: inset 0 0 0 4px var(--surface);
+}
+
+/* ---------- Motion & micro-interactions ---------- */
+
+@media (prefers-reduced-motion: no-preference) {
+  /* Entrance fade-up for cards */
+  .cert-card, .bank-card, .question-card {
+    animation: fadeUp 0.4s var(--ease) backwards;
+  }
+  .cert-card:nth-child(1) { animation-delay: 0s; }
+  .cert-card:nth-child(2) { animation-delay: 0.05s; }
+  .cert-card:nth-child(3) { animation-delay: 0.1s; }
+  .cert-card:nth-child(4) { animation-delay: 0.15s; }
+  .cert-card:nth-child(5) { animation-delay: 0.2s; }
+  .cert-card:nth-child(6) { animation-delay: 0.25s; }
+
+  /* Answer reveal: green pulse + glow on the correct choice */
+  fieldset#quiz-choices label.correct {
+    animation: pulse-correct 0.7s var(--ease);
+  }
+  /* Red shake on whichever choice the user picked wrong */
+  fieldset#quiz-choices label.incorrect {
+    animation: shake-incorrect 0.4s var(--ease);
+  }
+
+  /* Feedback panel slides in from above */
+  #quiz-feedback:not([hidden]) {
+    animation: slideDown 0.35s var(--ease);
+  }
+
+  /* Question card transitions in cleanly between questions */
+  .question-card { transition: none; }
+
+  /* Brief tint flash on the whole question card */
+  .question-card.flash-correct  { animation: flash-correct 0.6s var(--ease); }
+  .question-card.flash-incorrect { animation: flash-incorrect 0.5s var(--ease); }
+}
+
+@keyframes fadeUp {
+  from { opacity: 0; transform: translateY(8px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
+
+/* Question-to-question slide transition. 0.85s — slow enough that you
+   clearly see "new question arriving from the right". Both the
+   question-header (Q# · difficulty) and the question-card animate
+   together so the whole row reads as a single unit moving in. */
+@media (prefers-reduced-motion: no-preference) {
+  .question-card.slide-in,
+  .question-header.slide-in {
+    animation: question-slide 0.85s cubic-bezier(0.16, 0.84, 0.32, 1);
+  }
+  .question-header.slide-in { animation-duration: 0.7s; }  /* arrives slightly earlier */
+}
+@keyframes question-slide {
+  0% {
+    opacity: 0;
+    transform: translateX(40px);
+  }
+  20% {
+    opacity: 0.25;
+  }
+  100% {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@keyframes pulse-correct {
+  0%   { transform: scale(1);    box-shadow: 0 0 0 0   rgba(21,128,61,0); }
+  35%  { transform: scale(1.015); box-shadow: 0 0 0 6px rgba(21,128,61,0.18); }
+  70%  { transform: scale(1.005); box-shadow: 0 0 0 3px rgba(21,128,61,0.08); }
+  100% { transform: scale(1);    box-shadow: 0 0 0 0   rgba(21,128,61,0); }
+}
+
+@keyframes shake-incorrect {
+  0%, 100% { transform: translateX(0); }
+  15%      { transform: translateX(-6px); }
+  30%      { transform: translateX(6px); }
+  45%      { transform: translateX(-4px); }
+  60%      { transform: translateX(4px); }
+  75%      { transform: translateX(-2px); }
+  90%      { transform: translateX(2px); }
+}
+
+@keyframes slideDown {
+  from { opacity: 0; transform: translateY(-6px); max-height: 0; }
+  to   { opacity: 1; transform: translateY(0);    max-height: 1000px; }
+}
+
+@keyframes flash-correct {
+  0%, 100% { background: var(--surface); }
+  20%      { background: var(--positive-soft); }
+}
+
+@keyframes flash-incorrect {
+  0%, 100% { background: var(--surface); }
+  20%      { background: var(--negative-soft); }
+}
+
+/* ---------- Streak indicator (appears briefly on a correct streak) ---------- */
+
+.streak-toast {
+  position: fixed;
+  top: 5rem;
+  left: 50%;
+  transform: translateX(-50%) translateY(-30px);
+  background: var(--fg);
+  color: var(--bg);
+  padding: 0.75rem 1.5rem;
+  border-radius: 99px;
+  font-family: var(--mono);
+  font-size: 0.85rem;
+  font-weight: 600;
+  letter-spacing: -0.005em;
+  z-index: 1000;
+  pointer-events: none;
+  opacity: 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.6rem;
+  box-shadow: 0 12px 32px -8px rgba(0,0,0,0.25);
+}
+.streak-toast.show {
+  animation: streakIn 1.6s var(--ease);
+}
+.streak-toast .streak-num {
+  background: var(--accent);
+  color: #FFFFFF;
+  padding: 0.1rem 0.55rem;
+  border-radius: 99px;
+  font-variant-numeric: tabular-nums;
+}
+
+@keyframes streakIn {
+  0%   { opacity: 0; transform: translateX(-50%) translateY(-30px); }
+  20%  { opacity: 1; transform: translateX(-50%) translateY(0); }
+  80%  { opacity: 1; transform: translateX(-50%) translateY(0); }
+  100% { opacity: 0; transform: translateX(-50%) translateY(-20px); }
+}
+
+/* ---------- "+1" floating indicator on correct answer ---------- */
+
+.float-plus {
+  position: absolute;
+  right: 1rem;
+  top: 50%;
+  transform: translateY(-50%);
+  font-family: var(--mono);
+  font-weight: 600;
+  font-size: 0.95rem;
+  color: var(--positive);
+  pointer-events: none;
+  opacity: 0;
+  animation: floatPlus 1.1s var(--ease);
+}
+@keyframes floatPlus {
+  0%   { opacity: 0; transform: translateY(-50%); }
+  20%  { opacity: 1; transform: translate(0, calc(-50% - 8px)); }
+  100% { opacity: 0; transform: translate(0, calc(-50% - 36px)); }
+}
+
+/* ---------- Confetti burst on correct answer ---------- */
+
+.confetti-container {
+  position: fixed;
+  inset: 0;
+  pointer-events: none;
+  z-index: 1000;
+  overflow: hidden;
+}
+
+.confetti-particle {
+  position: absolute;
+  width: 8px;
+  height: 12px;
+  border-radius: 1.5px;
+  pointer-events: none;
+  transform: translate(-50%, -50%);
+  animation: confetti-arc 1.4s cubic-bezier(0.2, 0.6, 0.35, 1) forwards;
+  will-change: transform, opacity;
+}
+
+@keyframes confetti-arc {
+  0% {
+    transform: translate(-50%, -50%) rotate(0);
+    opacity: 1;
+  }
+  10% { opacity: 1; }
+  50% {
+    transform: translate(
+      calc(-50% + var(--mid-dx)),
+      calc(-50% + var(--mid-dy))
+    ) rotate(calc(var(--rot) / 2));
+    opacity: 1;
+  }
+  100% {
+    transform: translate(
+      calc(-50% + var(--end-dx)),
+      calc(-50% + var(--end-dy))
+    ) rotate(var(--rot));
+    opacity: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .confetti-container { display: none; }
+}
+
+/* ============================================================
+   Touch device safeguards — prevent "sticky hover" lingering on
+   mobile after a tap. Coarse-pointer devices don't have real hover,
+   but :hover styles get applied briefly on tap and stay until
+   another tap elsewhere, which looks like a glitchy selection.
+   ============================================================ */
+@media (hover: none) {
+  .cert-card:hover { transform: none; box-shadow: var(--shadow-2); border-color: var(--hairline); }
+  .cert-card:hover::after { opacity: 0; }
+  .cert-card:hover .cert-card-arrow { transform: none; color: var(--muted); }
+  .bank-card:hover { transform: none; background: var(--surface); border-color: var(--hairline); }
+  button.primary:hover:not(:disabled) { transform: none; background: var(--fg); color: var(--bg); box-shadow: none; }
+  button.ghost:hover { background: transparent; border-color: var(--hairline); }
+  button.brand-cluster:hover { background: none; border-color: transparent; }
+  button.brand-cluster:hover .brand-mark { transform: none; }
+  button.brand-cluster:hover .brand-title { color: var(--fg); }
+  .quiz-meta-strip .cert-link:hover { color: var(--fg); text-decoration: none; }
+  #btn-theme:hover { color: var(--fg-soft); border-color: var(--hairline); }
+  button.link:hover { color: var(--muted); }
+  .back-button:hover { color: var(--muted); }
+}
+
+/* ============================================================
+   Mobile portrait + small phones — touch targets, font sizes,
+   spacing reductions. Stacks the actionbar so primary controls
+   stay reachable with the thumb.
+   ============================================================ */
+
+@media (max-width: 720px) {
+  /* All "link"-style buttons in the actionbar need ≥44px tap area */
+  button.link {
+    padding: 0.7rem 0.5rem;
+    min-height: 44px;
+    display: inline-flex;
+    align-items: center;
+  }
+  /* Theme pill stays compact but reaches 36px minimum */
+  #btn-theme { padding: 0.55rem 0.85rem; min-height: 36px; }
+  /* Brand cluster gets a real tap area even though the title hides */
+  button.brand-cluster {
+    min-height: 44px;
+    min-width: 44px;
+    padding: 0.5rem;
+    justify-content: center;
+  }
+  /* Cert-link button (back to bank picker) — bigger tap area */
+  .quiz-meta-strip .cert-link {
+    padding: 0.45rem 0;
+    min-height: 36px;
+    display: inline-flex;
+    align-items: center;
+  }
+  /* Difficulty pill slightly larger so the colour band reads clearly */
+  .difficulty { padding: 0.2rem 0.55rem; font-size: 0.65rem; }
+}
+
+@media (max-width: 540px) {
+  main { padding: 1.75rem 1rem 2.5rem; }
+  h2 { font-size: 1.65rem; margin-bottom: 1.5rem; letter-spacing: -0.025em; }
+
+  /* Cert picker cards — full-width, slightly less padding, but still
+     visually distinct with the gradient bar at the top */
+  .cert-card { padding: 1.4rem 1.25rem; }
+  .cert-card strong { font-size: 1.2rem; margin-bottom: 1rem; padding-right: 1rem; }
+  .cert-card .cert-card-meta { font-size: 0.68rem; }
+  .cert-card .cert-card-blueprint { font-size: 0.66rem; padding-top: 0.85rem; margin-top: 0.85rem; }
+
+  /* Bank cards — denser */
+  .bank-card { padding: 1.15rem 1rem; }
+  .bank-card strong { font-size: 1rem; margin-bottom: 0.65rem; }
+  .bank-card .bank-meta { font-size: 0.72rem; }
+  .bank-card .bank-purpose { font-size: 0.78rem; }
+
+  /* Question card — tighter padding, 16px choice text to prevent iOS
+     auto-zoom on focus and improve readability at arm's length */
+  .question-card { padding: 1.25rem 1rem; border-radius: 10px; }
+  #quiz-question { font-size: 1.05rem; margin-bottom: 1.5rem; }
+  fieldset#quiz-choices label { padding: 0.95rem 0.95rem; gap: 0.75rem; }
+  fieldset#quiz-choices label .choice-text { font-size: 1rem; }    /* 16px — readable + no iOS zoom */
+  fieldset#quiz-choices .choice-letter { font-size: 0.9rem; min-width: 1.5em; }
+
+  /* Feedback panel — match card padding */
+  #quiz-feedback { padding: 1.15rem 1rem; }
+  #quiz-feedback p.fb-short { font-size: 0.98rem; }
+
+  /* Stats table — horizontal scroll instead of squishing */
+  #stats { overflow-x: auto; }
+  #stats table { font-size: 0.85rem; }
+  #stats th, #stats td { padding: 0.6rem 0.55rem; }
+
+  /* On mobile the kbd-hint hides (centre column not needed), so the grid
+     collapses to a 2-column layout: timer left + buttons right. When the
+     timer is also off (practice mode), col1 collapses to 0 and buttons
+     get the full width — no awkward empty half. */
+  .actionbar-inner {
+    padding: 0.55rem 0.9rem;
+    gap: 0.5rem;
+    min-height: 56px;
+    grid-template-columns: auto 1fr;
+  }
+  #quiz-timer.actionbar-timer { grid-column: 1; }
+  .actionbar-left {
+    grid-column: 2;
+    gap: 0.5rem;
+    justify-content: flex-end;
+  }
+  .actionbar-right { grid-column: 1 / -1; }
+  .actionbar-left button.primary { padding: 0.75rem 1.1rem; font-size: 0.9rem; }
+  .actionbar-left button.ghost { padding: 0.65rem 1rem; font-size: 0.85rem; }
+  .actionbar-timer { padding: 0.4rem 0.75rem 0.4rem 0.6rem; }
+  .actionbar-timer .timer-value { font-size: 0.95rem; }
+  .actionbar-right { gap: 0.4rem; font-size: 0.6rem; }
+  .actionbar-right .actionbar-divider,
+  .actionbar-right #bank-stats,
+  .actionbar-right .rh-sep { display: none; }   /* only session-stats + nav controls fit */
+
+  /* Question header — tighter */
+  .question-header { font-size: 0.65rem; gap: 0.4rem; margin-bottom: 0.7rem; }
+}
+
+@media (max-width: 380px) {
+  main { padding: 1.25rem 0.85rem 2rem; }
+  .masthead-inner { padding: 0.5rem 0.85rem; gap: 0.5rem; }
+  .quiz-meta-strip { font-size: 0.6rem; }
+  .quiz-meta-strip .rh-sep { display: none; }     /* gain a few precious pixels */
+  .quiz-meta-strip #quiz-domain { display: none; } /* keep just the cert name */
+  .actionbar-inner { padding: 0.5rem 0.7rem; }
+  .actionbar-right #session-stats { font-size: 0.7rem; }
+}
+
+/* Landscape phones — keep the actionbar slim so most of the viewport
+   is for the question card. */
+@media (max-width: 920px) and (orientation: landscape) and (max-height: 500px) {
+  .masthead-inner { min-height: 44px; padding: 0.4rem 1rem; }
+  .actionbar-inner { padding: 0.5rem 1rem; min-height: 52px; }
+  main { padding: 1.25rem 1.25rem 2rem; }
+  .streak-toast { top: 3rem; }
 }