CCDV-F Exam Domains: Complete Breakdown of All 8 Domains [2026]

The Claude Certified Developer - Foundations (CCDV-F) exam distributes 53 scored questions across eight domains, and the weights are dramatically uneven. A single domain, Applications and Integration, controls a full third of the exam by itself, while the two smallest domains carry 3% each and still contribute a question or two you can bank. Before you build a study schedule, you should know those weights cold, because they answer the most practical question in exam preparation: where do your points live?

This guide breaks down every CCDV-F domain: the exact weights, the approximate question counts they produce on a 53-question exam, the topics inside each domain, the tradeoffs the exam actually tests, and the scenario patterns to expect. The exam runs 120 minutes through Pearson VUE, requires a scaled score of 720 out of 1000 to pass, and mixes single-answer multiple choice with multiple-response items (roughly a quarter ask you to Select TWO or Select THREE). Your score report shows percent correct per domain, so this structure follows you past exam day.

If you are new to the certification itself, start with the complete CCDV-F certification guide or the shorter what is CCDV-F overview, then return here for the domain-level detail.

What this guide covers:

• The complete weight breakdown for all 8 domains with approximate question counts out of 53
• Every topic each domain tests, taken directly from the exam blueprint
• The tradeoffs behind the questions, with scenario examples for each domain
• A deep treatment of Applications and Integration, the dominant domain at 33%
• Cross-domain themes that show up in synthesis questions
• A weight-based study prioritization strategy with links to a full preparation plan

Domain Weight Overview

The weights below come straight from the exam blueprint. To convert a weight into a question count, multiply it by 53 and round. Applications and Integration at 33% works out to roughly 17 questions, Model Selection and Optimization at 17% to roughly 9, and so on down to the two 3% domains at about 2 questions each. Exact counts can shift by a question between exam forms, but the proportions hold.

The Numbers That Matter

The headline is Domain 1. Applications and Integration (33%) contributes roughly 17 of your 53 questions, which is more than the bottom four domains combined (Tools and MCPs, Security, Claude Code, and Eval together carry 24%, about 13 questions). No other domain on any Anthropic exam blueprint concentrates this much weight in one place, so it deserves the depth of preparation you would normally spread across two or three domains.

The top of the table compounds quickly. Domains 1 and 2 together control exactly half the exam, and adding Agents and Workflows (15%) brings the top three to 65%, roughly 34 questions. The tail still matters, though: Claude Code (3%) and Eval, Testing, and Debugging (3%) produce only 1 to 2 questions each, but the 720-out-of-1000 passing bar leaves little room to concede points, and both cover material a working Claude developer already touches weekly. These are the cheapest points on the exam.

Domain 1: Applications and Integration (33%)

Approximate question count: ~17 of 53

Applications and Integration is the heaviest domain on the exam by a wide margin, and its size reflects what the certification is for: engineers who build applications with Claude. It covers the application layer end to end, from the first API request through feature selection, processing mode, interface design, and the configuration discipline that keeps a production system stable. Give it your deepest preparation, because its concepts underpin questions in every other domain.

The Messages API Feature Surface

The Messages API is the core request and response interface for Claude: you send role-structured messages plus a system prompt, and the model returns a response. The exam expects fluency with the features layered on top. Streaming delivers the response token by token as it is generated, which is what makes a chat interface feel responsive. Vision accepts images inside requests, so the model can read screenshots and documents. Extended thinking lets the model reason internally before answering, improving accuracy on hard multi-step problems at the cost of extra tokens and latency. Tool use lets the model request actions from your application, and prompt caching reuses a stable prompt prefix across requests at a fraction of the normal input price.

The exam tests these as a matching exercise: a question describes an application with stated constraints and asks which feature combination the design needs, and the distractors are real features applied to the wrong requirement, such as extended thinking on a simple high-volume classification task.

Batch Versus Real-Time Processing

The Batch API accepts large sets of requests, processes them asynchronously within a processing window, and charges roughly half the per-token price of real-time requests, which return in seconds and are the only option when a human is waiting. The exam question is almost always the same shape: a workload with a volume figure and a latency requirement. An overnight enrichment job over millions of documents belongs on the Batch API, while an interactive assistant cannot tolerate the delay. Harder variants combine the decision with caching, asking which mechanism to apply first when cost and latency both appear in the stem.

Application Design Across Interfaces and Lifecycle Management

The blueprint also tests whether you can carry one capability across surfaces. The same assistant might appear in a chat UI, inside an IDE, as a CLI, and as an API service, and each interface changes the design: streaming and session history matter in chat, repository context matters in the IDE, and structured output matters for the API consumer. Requirements questions give you a business need and ask what to establish before building, and the correct answer anchors on users, constraints, and success criteria before technology choices. Lifecycle management covers what happens after launch: models are versioned and eventually deprecated, prompts evolve, and the exam rewards designs that monitor quality and plan for migrations.

Configuration Management

Configuration is where this domain gets specific. CLAUDE.md is the instruction file Claude Code reads for project context and standards, and settings.json holds permissions and behavior configuration; both belong in version control so an entire team gets identical behavior. Model pinning means requesting a dated model snapshot instead of a floating alias, so upgrades happen when you choose to run evals against the new version instead of silently in production. Prompt versioning applies the same discipline to prompts: tracked changes, review, and a tested rollback path.

Scenario angles to expect:

• The exam gives you a workload with a volume figure and a latency budget and asks for the processing mode and cost mechanism.
• The exam gives you an application whose behavior changed with no code deploy and asks which practice prevents it (model pinning is the usual answer).
• The exam gives you one assistant shipping across chat, IDE, and API surfaces and asks which design concerns differ per interface.

What to study: the Messages API documentation on docs.anthropic.com, including streaming, vision, extended thinking, prompt caching, and the Batch API. Build one small application that uses at least three of these features, because this domain rewards candidates who have felt the tradeoffs.

Domain 2: Model Selection and Optimization (17%)

Approximate question count: ~9 of 53

Domain 2 starts with the fundamentals every other decision rests on. Tokens are the subword units a model reads and generates, and both directions are billed per token, which is why every optimization conversation eventually becomes a token conversation. The context window is the maximum amount a single request can carry, bounding how much history, retrieved content, and instruction fits at once. Sampling is how the model picks among probable next tokens during generation, and it is why output is non-deterministic: the same prompt can produce different answers on different runs, with direct consequences for testing and for any code that consumes model output.

The tier and mode content is where the questions concentrate. The Claude family spans Opus (the most capable tier, for complex reasoning at the highest cost), Sonnet (the balance of capability, speed, and price), and Haiku (the fastest and cheapest tier, for high-volume well-bounded tasks). On top of tier selection sit the request-level dials: fast mode trades a premium price for higher output speed, extended thinking buys deeper reasoning with extra tokens and latency, and effort levels tune how much reasoning a request receives. The tested judgment is proportionality, because a nuanced contract analysis and a ticket-routing service belong on different tiers, and defaulting to the most capable model for everything reads as junior-level thinking on this exam.

Prompt caching anchors the cost management thread, because reusing a stable prefix often solves a cost problem without touching quality. The classic scenario describes a service resending a 20K-token static prefix on every request; the correct first move is caching, while the distractors involve downgrading the model and accepting a quality loss nobody asked for.

Scenario angles to expect:

• The exam gives you three workloads and asks you to map each to a model tier on capability, cost, and latency.
• The exam gives you inconsistent outputs between identical test runs and asks for the explanation (sampling and non-determinism, with evals as the mitigation).

What to study: the model comparison and pricing documentation, prompt caching mechanics, and one experiment running the same prompt through all three tiers.

Domain 3: Agents and Workflows (15%)

Approximate question count: ~8 of 53

Domain 3 tests the decision that shapes every Claude application: who controls the loop. In a workflow, your code controls the steps and the model executes defined tasks inside a fixed pipeline, which makes the system predictable, testable, and cheap to run. In an agent, the model controls its own loop, deciding which tools to call and when the task is done, which is justified only when the path through the problem cannot be predicted in advance. The exam builds scenarios around this restraint: a fixed five-step document pipeline proposed as an autonomous agent is over-engineered, and a task requiring dynamic exploration keeps breaking when forced into a rigid workflow.

Once a problem genuinely needs an agent, the domain tests how you build it. Manager and subagent hierarchies let an orchestrating agent delegate subtasks to specialized subagents, each with its own isolated context window, and combine their results; decomposition buys context isolation, parallelism, and specialization at the price of latency, tokens, and coordination. On the construction side, the Claude Agent SDK packages the agent loop, built-in tools, context management, permissions, and hooks as a ready-made harness, while a custom loop built directly on the Messages API gives full control at the price of building all of that yourself. Hooks are deterministic code that runs at defined points in the loop, such as before and after tool calls, and can log, modify, or block what the agent does.

Deployment and ecosystem topics round out the domain. Managed deployment hands the loop and its infrastructure to a provider, while self-hosting keeps control, data residency, and operational burden on your side, and the exam frames the choice through compliance and operations requirements. The blueprint also names third-party agent frameworks (Strands, LangGraph, PydanticAI), and the tested depth is recognition: know what they are and the criteria for choosing a framework, the Agent SDK, or a hand-built loop.

Scenario angles to expect:

• The exam gives you a business process and asks whether it needs a workflow or an agent, with the stated constraint as the deciding factor.
• The exam gives you a set of requirements (built-in tools, permissions, session management) and asks which build approach delivers them fastest.

What to study: Anthropic's guidance on building effective agents and the Claude Agent SDK documentation. Build one small agent with at least one hook before exam day.

Domain 4: Prompt and Context Engineering (11%)

Approximate question count: ~6 of 53

Domain 4 treats the context window as a resource to be managed rather than a bucket to be filled. As a session accumulates history, retrieved documents, and tool results, two failure modes emerge: drift, where the model gradually wanders from its original instructions as newer content dominates the window, and bloat, where stale material crowds out what the current turn actually needs. The tested countermeasures are pruning (dropping content that no longer earns its place), compaction (summarizing older history into a shorter form that preserves the essentials), and context isolation via subagents, where a noisy subtask like reading a large document runs in its own context and returns only its conclusion.

The prompting content covers instruction clarity and few-shot prompting, which adds a handful of worked examples to establish a pattern the model should follow. The professional twist is cost awareness: examples improve format compliance and consistency, and they consume tokens on every single call, so the exam asks when the technique earns its price rather than whether it works.

Structured output and defensive parsing form the domain's most practical thread. Structured output patterns constrain the model to produce schema-shaped data, and defensive parsing means validating that output before any downstream code trusts it, with retry and fallback paths for the cases where a probabilistic system produces something slightly wrong. The exam punishes designs that pipe raw model output straight into application logic, because a single malformed field should degrade gracefully instead of crashing a pipeline.

Scenario angles to expect:

• The exam gives you an assistant whose quality degrades over a long session and asks for the mechanism that restores it.
• The exam gives you a pipeline that crashes on slightly malformed output and asks which combination of structured output and validation hardens it (a common Select TWO).

What to study: Anthropic's context management and prompt engineering documentation, plus one exercise: build a small pipeline that parses model JSON output and make it survive a malformed response.

Domain 5: Tools and MCPs (10%)

Approximate question count: ~5 of 53

Domain 5 starts with the tool use loop itself. You define tools with names, descriptions, and input schemas; the model responds with a structured tool call when it decides one is needed; your application executes the call and returns the result; and the model continues with that result in context. The exam expects you to know where responsibility sits at each step, including the split between client-side tools (executed by your application, with access to your systems) and server-side tools (executed on Anthropic's infrastructure within the request, such as web search and code execution).

Tool description writing gets its own blueprint line because it is the highest-leverage skill in the domain. The model chooses tools by reading their descriptions, so a description that states what the tool does, when to use it, and what each parameter means directly raises selection accuracy, while two vague overlapping descriptions produce wrong calls that no prompt engineering can fully fix.

The Model Context Protocol (MCP) is Anthropic's open standard for connecting models to external tools and data through a uniform client-server interface, and the exam tests it at development depth. An MCP server exposes three primitives: tools (actions the model can invoke), resources (data the client can read into context), and prompts (reusable templates the server offers). Transport matters too: a local server can run over standard input/output (stdio), while a remote server communicates over a network socket. The final topic is the tradeoff the whole domain builds toward: a capability shared across multiple applications belongs in an MCP server, a single-app bespoke action belongs in a custom tool, packaged instructions belong in a Skill (a reusable instruction set Claude loads when relevant), and built-in tools cover the common cases before you build anything.

Scenario angles to expect:

• The exam gives you a model that keeps selecting the wrong one of two similar tools and asks for the fix (rewrite the descriptions to remove the overlap).
• The exam gives you a capability needed by several applications and asks which exposure mechanism fits (MCP server, with the custom tool as the distractor).

What to study: the tool use documentation and the MCP specification, then build one small MCP server exposing at least one tool and one resource, because primitive-level questions are hard to answer from reading alone.

Domain 6: Security and Safety (8%)

Approximate question count: ~4 of 53

Domain 6 is small and dense, and it opens with the attack class every Claude developer must recognize on sight. Prompt injection is malicious instruction content embedded in data the model processes (a user message, a retrieved document, a web page, a tool result) that attempts to override the developer's instructions, and a jailbreak is an input crafted to push the model past its safety behavior. The dangerous combination the exam keeps returning to is untrusted content plus capable tools: an agent that reads external web pages and can also send email has an attack path from any page it reads to any inbox it can reach. The tested defense is layering: validate inputs, limit what tools an agent can reach, check outputs, and enforce consequential limits in code, because prompt instructions alone are never sufficient protection for real stakes.

Claude Hooks appear here as a guardrail mechanism: deterministic code that runs at defined points in an agent's loop and can inspect or block a tool call before it executes. A hook that rejects any refund above a threshold is enforcement the model cannot talk its way past, which is exactly the property the exam rewards. Authentication and authorization questions extend the same principle to identity: know who is making a request, check what that identity may do at the tool boundary, and avoid designs where every user inherits one broadly scoped service account.

Data protection and key management complete the domain. Personally identifiable information (PII) flowing into prompts, logs, and stored histories creates leakage risk, so minimization and redaction belong in the design. API keys belong in environment variables or secret managers with rotation plans, and they never ship inside client applications; a browser or mobile frontend calls your backend, and the backend holds the key.

Scenario angles to expect:

• The exam gives you an agent wired to untrusted content and capable tools and asks you to name the injection path and the layered mitigation.
• The exam gives you a consequential action and asks where the enforcement belongs (a hook or code check, never a prompt instruction).

What to study: Anthropic's guidance on prompt injection and agent security, the Claude Hooks documentation, and standard key management practice.

Domain 7: Claude Code (3%)

Approximate question count: ~2 of 53

Domain 7 covers Claude Code, Anthropic's command-line coding agent, and its questions are among the most concrete on the exam. The tested core is the customization surface and which piece solves which need: Rules hold persistent instructions, Skills package reusable capabilities that load when a task calls for them, Commands are reusable prompts invoked as slash commands, Agents are subagents with their own context and tools, and Agent Memory persists what Claude learns across sessions. When a scenario describes a developer retyping the same instructions every session, the answer is the surface that makes those instructions permanent.

The operational topics cover session management, slash commands, and headless mode, which runs Claude Code non-interactively so scripts and CI pipelines can drive it. Configuration questions center on the CLAUDE.md hierarchy and settings.json: instructions and settings cascade across enterprise, project, and personal scopes, and team standards belong in version-controlled project files. When the exam describes inconsistent behavior across a team, the cause is almost always shared standards living in someone's personal configuration.

Two questions is a small allocation, but this material overlaps Domain 1's configuration management topic, so studying it pays twice. If you use Claude Code daily, an hour of reviewing the official feature names against your own habits is enough.

What to study: the Claude Code documentation sections on Rules, Skills, Commands, Agents, Memory, and configuration.

Domain 8: Eval, Testing, and Debugging (3%)

Approximate question count: ~2 of 53

Domain 8 carries only about two questions, but the reasoning it tests runs underneath scenario questions across the whole exam. Its core skill is failure attribution. An integration-layer failure lives in your code: a malformed request, a mishandled rate limit, a tool result returned in the wrong format, a parser that chokes on valid output. A model-output failure lives in the response itself: a hallucinated fact, drifting format, or a task beyond the selected tier. The two classes have completely different fixes (a code change versus a prompt, model, or evaluation change), and the exam punishes candidates who jump to prompt tweaking for what is actually a parsing bug.

Trace analysis is the method that makes attribution possible: following a single request through prompt assembly, the model call, each tool invocation, and response parsing to find the stage where reality diverged from intent. The error identification and recovery topic adds the operational layer, distinguishing transient API errors that deserve retries with backoff from application bugs that will fail identically on every retry.

Treat this domain as a lens rather than a chapter. Every debugging scenario elsewhere in the exam gets easier once you habitually ask which layer broke before choosing a fix.

What to study: Anthropic's error documentation and one practical exercise: add logging to a small Claude application until you can trace a single request end to end.

Cross-Domain Themes: How the Exam Thinks

CCDV-F questions rarely stay inside one domain, and the multiple-response items in particular love to span two or three. Three reasoning patterns run underneath the whole blueprint.

The Cost, Latency, and Capability Triangle

Most optimization questions resolve to a triangle of cost, latency, and capability, and the exam wants you to optimize for the dimension the scenario names. Batch processing and caching (Domain 1), model tiers and modes (Domain 2), and agent loops versus workflows (Domain 3) are the same tradeoff wearing different clothes. When a question states a constraint, treat it as the scoring key: the correct answer honors the stated budget even when a more capable option sits in the list.

The Simplest Sufficient Architecture

The exam consistently rewards restraint. A single API call beats a workflow when one call suffices, a workflow beats an agent when the steps are predictable, the cheapest model that meets the quality bar beats a reflexive upgrade, and a custom tool beats a full MCP server for a one-off internal need. Over-engineered options are the most common trap for experienced candidates, because they describe real techniques that would genuinely work while costing more than the requirement justifies.

Determinism at the Boundaries

The model at the center of a Claude application is probabilistic, so the exam expects the code around it to be deterministic. Defensive parsing validates output before anything trusts it (Domain 4), hooks and code-enforced authorization gate consequential actions (Domain 6), model pinning and prompt versioning make behavior reproducible (Domain 1), and trace analysis assumes a system that records what it did (Domain 8). Whenever an option relies on prompt instructions to guarantee a high-stakes behavior, treat it as a trap.

How to Prioritize Your Study Time

Weight is the starting point for prioritization, and experience is the adjustment. Here is a practical tiering for most candidates:

Start with Tier 1 and stay there until the API feature surface, batch versus real-time economics, and configuration discipline feel automatic, because those concepts reappear across the other seven domains. Tier 2 is where practice tests earn their keep, since model selection and orchestration questions hinge on judgment that improves fastest through worked scenarios. In Tier 3, give MCP server development and prompt injection defense real hands-on time, and treat Claude Code and Eval as quick review passes that secure their handful of questions.

The 4-week CCDV-F study plan turns this tiering into a week-by-week schedule, and the first-attempt guide covers exam-day tactics, including the multiple-response items that make up about a quarter of the exam.

Common Questions

Domain Mastery Checklist

Use this checklist to confirm coverage before you sit the exam. Every line maps to a topic the blueprint names explicitly.

Conclusion

The CCDV-F blueprint tells you exactly what Anthropic believes a Claude developer does: build and configure applications on the API (33%), select and optimize models economically (17%), orchestrate agents and workflows with restraint (15%), engineer prompts and context deliberately (11%), extend the model with tools and MCP servers (10%), secure the whole system (8%), and operate Claude Code and a debugging discipline around it (3% each). Study in that order of weight, adjust for your own gaps, and give the dominant first domain the multi-topic treatment its size demands.

Three habits separate passing candidates on this exam. They read every scenario for its stated constraint and optimize for that dimension. They reach for the simplest architecture and the cheapest sufficient model before anything grander. And they reject any option that trusts a prompt instruction to guarantee behavior that code should enforce.

Your recommended next steps:

1. Build your schedule from the 4-week CCDV-F study plan, which allocates weeks according to the domain weights above
2. Read the first-attempt pass guide for question tactics, including multiple-response strategy
3. Keep the CCDV-F cheat sheet nearby for rapid review of the highest-yield facts

Ready to test yourself against the blueprint? Preporato's CCDV-F practice tests give you 6 full-length exams of 53 questions each, distributed across all 8 domains by weight, with an explanation for every answer. Alongside them sits a 500-card flashcard deck built to the same blueprint, and together they are the fastest way to find out which domains still need your attention before you book the real thing.