What the Claude Certified Developer – Foundations exam actually asks.

• 53 questions in 120 minutes — about 2 minutes 15 seconds each. The prompts are scenario-based, so the pace comes from reading, not arithmetic.
• It sits at the Foundations level of the Claude certification path, and tests building and integrating with Claude rather than training models or designing architectures.
• All 53 are scored. Unlike exams that seed unscored trial items, every question here counts.
• 720 out of 1000 to pass, on a scaled score. Because it is scaled, the raw number of correct answers you need is not fixed or published.
• Question formats: multiple choice and multiple response. A multiple-response item tells you how many to select and expects exactly that many.
• Answer everything. A blank scores nothing, so flag the long ones, bank the quick ones, and return before time runs out.
• $125 USD to sit.
• Available to the Claude Partner Network. The exam is offered to member organisations rather than to anyone; eligibility sits with your employer's partner status, not with you individually. Confirm your organisation's access before you plan a date.

Two hours is enough for fifty-three questions only if you keep moving. Decide early how long a scenario may take before you flag it and move on.

• Domain 1 — Agents and Workflows (14.7%). When a workflow beats an agent, building agents with the Claude Agent SDK and with custom loops on the Messages API, and the standard patterns: tool-use loops, subagents with isolated context, memory and context-window management.
• Domain 2 — Applications and Integration (33.1%). The largest domain by far. Turning requirements into constraints, the Messages API request and response shape, streaming, caching, batching, software engineering practice around a Claude integration, and configuration management from CLAUDE.md scopes to model version pinning.
• Domain 3 — Claude Code (3.1%). Core components, session and mode features, the CLAUDE.md hierarchy, and settings.json.
• Domain 4 — Eval, Testing, and Debugging (2.6%). Telling an integration-layer problem from a model-output problem, choosing a recovery strategy, and reading traces across the agentic loop.
• Domain 5 — Model Selection and Optimization (16.8%). Tokens, sampling and non-determinism, Opus versus Sonnet versus Haiku trade-offs, and cost and token management from cache_control breakpoints to compaction.
• Domain 6 — Prompt and Context Engineering (11%). Context window management and isolation, instruction clarity and placement, and making output a program can trust through schemas and validation.
• Domain 7 — Security and Safety (8.1%). Prompt injection direct and indirect, layered guardrails, hooks as deterministic gates, and secrets and identity across environments.
• Domain 8 — Tools and MCPs (10.6%). Tool schemas and description quality, client-side versus server-side tools, building and deploying MCP servers, and choosing among built-in tools, custom tools, Skills and MCP servers.

Domain 2 alone carries a third of the paper, and the top three domains — Applications and Integration, Model Selection and Optimization, Agents and Workflows — together make up nearly 65%. The two smallest domains, Claude Code and Eval, Testing, and Debugging, are worth 8 and 7 questions across the full pool combined; they are cheap marks if you know the mechanics precisely.

Expect a short scenario — an integration, an agent, a configuration — followed by a question about the best design, the next step, or the right mechanism. More than one option may work in isolation; the exam asks for the one that satisfies every stated constraint. The guide names the production roles the items are drawn from: application developer, integration engineer, agent builder, and tool and workflow developer. Anthropic publishes the exact task statements in the exam guide, so confirm them there before you sit the paper.

Read the last sentence first, then the scenario, then the options. Qualifiers to look for:

• "Deterministic" → Prefer a hook or a program check over asking the model to remember.
• "A program must consume it" → Prefer a schema the model is constrained by over parsing prose.
• "Within budget" or "at scale" → Ask where the tokens or the latency actually go before reaching for a bigger model.
• "From fetched content" or "user-supplied" → Treat the text as untrusted and look for the enforcement point outside the prompt.

This exam tests code you ship, so the questions reward knowing mechanics exactly: which parameter terminates a turn, which hook fires before a tool runs, which cache breakpoint invalidates a prefix. Vague familiarity is what the wrong options are written against.

Three habits that work:

• Build a small agent end to end. The Agent SDK, a tool with a clear schema, a hook, and structured output touch most of the domains and make the questions concrete.
• Read the Anthropic documentation alongside the guide. The Messages API, the Agent SDK, Claude Code, and MCP each have their own reference; the guide names the topics but the documentation settles the detail.
• Say why each wrong option fails. On an exam about constraints, learning to name the violated constraint is the skill being tested — and it is also how wrong options are constructed.

MockRoom's CCDV-F study room has five distinct 53-question mock exams — 265 original scenario questions in total, written against the published exam guide and weighted across its eight domains, each with an explanation for every option. It also has 258 active recall flashcards for spaced review. Nothing here is taken from an exam dump or from the guide's own sample questions, and none of it is real examination content.

Open the CCDV-F study room