CertScroll

Ten AI certifications share most of one syllabus. This is a scroll feed that treats that overlap as the product rather than a coincidence.

The Problem

Preparation for these exams is scattered across provider portals, YouTube and static study guides. The certifications in a cluster share 60 to 80 percent of their foundation, so studying for one should reduce the work for the next. It does not, because nothing is organised around the overlap.

The obvious fix is a large question bank. The obvious way to build one is the reason most free certification questions cannot be used: they are braindumps, meaning real exam items, which are copyrighted and prohibited by every provider’s terms. This site carries the Wanessa Labs name at its own domain, so that route was closed from the start.

What It Is

A feed of questions you answer by tapping, with a spaced-repetition schedule underneath. Miss one and it comes back. Get it right twice and it goes away for a week. Tapping a term in a question opens a concept panel whose definition stays locked until you answer, because for a lot of questions the definition is the answer.

Everything is stored in your own browser. There is no account, nothing is uploaded, and a different browser starts over.

Core Capabilities

• Bazantic Model Context Protocol (MCP) & Developer Portal (/mcp): Public MCP server endpoint (https://ai-cert-questions.bazgateway.com/mcp) and live Bazantic Gateway marketplace listing (https://bazantic.com/gateways/d5uuzskoyjdedbboomfgcxxwti). Exposes syllabus-verified questions, blueprint mock exam generators, diagnostic indices, and cross-cert overlap matrices directly to Claude Desktop, Cursor, LangChain, and autonomous evaluation harnesses with automated x402-mpp USDC micropayments ($0.005/question) on Base.
• Viral Shareable Readiness Scorecard: Branded 1200x630 dark-mode SVG scorecard generator rendering calibrated Pass Probability, Diagnostic Index, Accuracy, and Domain Coverage with 1-click sharing to X/Twitter and LinkedIn.
• Keyboard-First Power User Controls: Instant multiple-choice answering with keys 1–4 / A–D, feed scrolling with J/K/↑/↓, Space to auto-advance, and ? modal cheatsheet.
• Daily Goal Engine & Milestone Confetti: 5 reps/day habit tracker featuring real-time HUD progress (🎯 Goal: X/5) and celebratory confetti burst upon completion.
• Hands-Free Voice / Audio Study Mode: Full Web Speech API text-to-speech integration narrating question stems, options 1-4, and explanation rationales. Includes variable speech rates (0.8x-1.5x), auto-advance on answering, replay hotkeys (V, R, 1-4), and on-demand card audio buttons.
• Service Worker Offline PWA: Built-in /sw.js precaching shell assets, icons, manifest, and static pages with automatic connectivity recovery and offline indicator badge.
• Calibrated Exam Readiness Diagnostic Score: Mathematical mastery engine computing domain-weighted performance, 4-tier cognitive ladder depth, and logistic calibrated pass probability against official 70% exam benchmarks.
• Adaptive Practice Feed & Spaced Repetition: Continuous card feed with 2,050 total cards (2,005 scenario & conceptual questions + 45 concept cards). Missed questions cycle back immediately, while mastered cards defer for 7 days. Locked concept definitions prevent premature answer spoilers during active recall.
• 4-Tier Cognitive Ladder (100% Matrix Coverage): Complete 765 of 765 reachable matrix cells filled across 9 certification tracks and 45 shared core AI concepts, structured across four cognitive difficulty tiers:
  • Level 1 (Recall & Primitives): Core terminology, parameter mechanics (temperature, top-p, penalties), API primitives, and tokenization basics.
  • Level 2 (Discrimination): Disambiguating adjacent techniques (LoRA vs. QLoRA, RAG vs. fine-tuning, dense vs. sparse embeddings, vector distance metrics).
  • Level 3 (Application & Scenarios): Realistic multi-step deployment architectures, prompt injection defenses, cost-latency trade-offs, and orchestration pipelines.
  • Level 4 (Diagnosis & Edge Cases): Root-cause debugging of production failures (catastrophic forgetting, attention degradation, context drift, safety filter circumvention).
• Interactive 3D Three.js Question Bank (/bank/): WebGL graph visualization of all 45 concepts and 2,050 questions in 3D space. Features OrbitControls, smooth fly-to camera focus, typeahead search, a slide-out inspector drawer with instant question previews, accessible 2D list view fallback, and three distinct layout projections:
  • Constellation: Spring-physics force simulation clustering related concepts.
  • Cert Galaxy: Planar certification orbits highlighting cross-syllabus overlap.
  • Difficulty Rings: Concentric radial tiers stratified by cognitive difficulty level.
• Stratified Blueprint Mock Exams Hub (/exams/): Dedicated mock test center with configurable 15, 25, and 50 question presets. Questions are stratified dynamically according to official certification domain weightings and cognitive difficulty proportions (~25% Recall, ~35% Discrimination, ~30% Application, ~10% Diagnosis). Includes interactive in-page test navigation, countdown timer, and end-of-exam concept mastery diagnostics.
• What’s New Timeline & Product Roadmap (/about): Full development history log featuring 4 stat tiles, monthly shipping volume bar graph, classified milestone entries, and forward-looking product roadmap.
• Human Curation & Review Queue Tooling: Automated question quality diagnostics checking option cardinality, distractor traps, stem lengths, and leaf spine citations; plus batch graduation from derived to read with reviewer sign-off metadata.
• Zero-Account Local Privacy: All state, mastery ratings, streaks, and mock exam results persist locally in IndexedDB via Dexie. Zero sign-up forms, zero telemetry, zero analytics tracking, zero cloud dependencies.
• Strict Citation Spine & Invariant Verification: Every card programmatically verified against committed official provider syllabus trees. Clean, trademark-compliant design with plain-text certification names and zero provider logos.

Bazantic Gateway & The x402 Machine Payment Protocol (MPP)

Most developer APIs assume a human with a web browser, an email address, and a corporate credit card. Autonomous coding agents (like Claude Desktop, Cursor, Goose, and LLM evaluation harnesses) have none of those. When an agent needs to pull domain-stratified test items to benchmark a new model or verify its own answers, requiring account sign-up and pre-shared API keys creates immediate friction.

CertScroll solves this by exposing its Model Context Protocol (MCP) server through the Bazantic Gateway (https://ai-cert-questions.bazgateway.com) with native x402 / Machine Payment Protocol (MPP) support.

The Dual-Surface Architecture: Human App vs. Agent Gateway

CertScroll runs as a decoupled dual-surface system:

[Human Learner] ──────────► study.wanessalabs.com 
                              └─ Astro 5 SSG + Cloudflare Pages (100% Client-Side IndexedDB)

[AI Agent / IDE] ─────────► ai-cert-questions.bazgateway.com 
                              └─ Bazantic Edge Gateway (Rate limiting, auth, x402-mpp)
                                   ├─ JSON-RPC 2.0 /mcp (Model Context Protocol endpoint)
                                   └─ REST API /api/v1/* (Questions, Grade, Mock Exams)

1. Human Surface (study.wanessalabs.com): Free, zero backend, zero accounts, no tracking cookies, running entirely on-device via Dexie/IndexedDB.
2. Agent Surface (ai-cert-questions.bazgateway.com): Reverse-proxied via the Bazantic Gateway marketplace (bazantic.com/gateways/d5uuzskoyjdedbboomfgcxxwti). Exposes structured tool declarations directly to LLMs while metering usage and monetizing autonomous queries without human intervention.

How x402 Machine Payments Work

Instead of traditional monthly subscriptions or human credit card checkouts, Bazantic implements the standard HTTP 402 Payment Required specification over the Base L2 blockchain:

Agent Request (No Token) ──► GET /api/v1/questions?cert=aws-mla-c01
                         ◄── HTTP 402 Payment Required
                             Headers: x402-price: 0.005, x402-asset: USDC, x402-network: base
Agent Signs & Broadcasts ──► Micro-USDC settlement on Base L2 (<$0.001 gas, sub-2s finality)
Agent Retries with Proof ──► GET /api/v1/questions + Authorization: x402 <receipt>
Bazantic Gateway Validates ──► HTTP 200 OK + Verified Syllabus Questions JSON

For developer testing in Claude Desktop or Cursor, Bazantic also supports standard Bearer API key authentication (Authorization: Bearer <key>) with 10 free queries per day for exploratory schema inspection.

Five Core MCP Primitives

The gateway exposes five tool definitions to language models:

Preventing Evaluation Contamination (maskAnswers)

A persistent vulnerability in AI benchmarking is data contamination: if an LLM is tested on a question whose correct answer or explanation is present in the payload, the evaluation measures prompt retrieval rather than model capability.

CertScroll’s MCP server provides evaluation integrity through blind evaluation:

• Calling get_questions or generate_mock_exam with maskAnswers: true strips the correct index and rationale fields from the output.
• The candidate model formulates its answer choice (0–3) and chain-of-thought reasoning independently.
• The evaluation harness calls grade_question with the candidate’s selection.
• The engine computes accuracy, verifies the leaf spine citation, and returns the official explanation and syllabus domain weighting for calibration.

1-Click Agent Configuration

Agents connect through standard declarative configurations:

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "certscroll": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-fetch",
        "https://ai-cert-questions.bazgateway.com/mcp"
      ]
    }
  }
}

Cursor IDE (.cursor/mcp.json):

{
  "mcpServers": {
    "certscroll": {
      "url": "https://ai-cert-questions.bazgateway.com/mcp"
    }
  }
}

Every Question Names Its Source

The constraint that shapes the whole project: a card must cite the published guide section it derives from, and the build refuses one that cannot.

That is enforced twice, in two different ways, because one of them is not something software can do.

The build holds a committed copy of each readable guide’s published section tree. A citation has to resolve against a real leaf of that tree, so a question naming a task number that does not exist fails the build rather than shipping. On the first run this caught two questions that had been reviewed by hand, both citing an abbreviated version of a real AWS task title. A gate written to police machine output audited the human on its way past.

The second gate is a person reading the question and confirming it is original. No build can judge that, so it does not pretend to. Machine-written cards ship marked as derived, and the build rejects the reviewer field on them outright: the pipeline is structurally incapable of claiming somebody read something they did not.

The Metric That Charged For Its Own Premise

Coverage is tracked as a matrix of concept by certification by difficulty. Filling it went from 21 questions to 226, and then stalled at 110 empty cells.

Ninety-six of those cells already contained a written question. The matrix counted each certification separately, so a question about temperature filed under one exam was invisible to somebody studying another, and the cell read as empty. The measurement assumed the certifications do not overlap, which is the exact opposite of the premise the site exists to prove.

Marking a question as shared foundation, so it serves every certification its concepts belong to, closed those cells without writing anything new. It also gave the seven certifications whose guides are not machine-readable their first questions: they had zero, permanently, because nothing could be cited against them.

What Testing Did Not Catch

The progress page was rebuilt as an instrument readout: first-try accuracy against how much of the bank it covers, what you got wrong, which concepts are shaky. It shipped with 380 passing tests and a clean type check, and four defects that all died the moment somebody opened the page in a browser.

A class name collided with one further down the same stylesheet and lost the cascade. A media query sized a 600 pixel column against a 2133 pixel window. Question text printed its own link markup on screen. And a card that grows when you answer it sat inside a slide that could not grow, so on a phone the explanation overflowed by up to 492 pixels and scrolling down snapped past to the next question instead of revealing it.

The first attempt at that last one was worse than the bug in a way the bug never was: letting every slide size itself to its contents forces the browser to lay out all 270 of them instead of none. The fix that shipped grows only the slides you have actually answered.

Tradeoffs

The bank grows only as fast as it can be cited. Questions derived with AI assistance ship flagged with an unreviewed indicator on screen until verified line-by-line by a human, which is the honest version of shipping them rather than pretending someone checked what they did not.

Mock exams do not simulate arbitrary 65-question multi-hour slogs: they focus on high-yield 15, 25, and 50 question stratified checkpoints with instant concept remediation loops, maximizing knowledge retention over test-center stamina.

Stack