How to Pass the CCDV-F Exam on Your First Attempt [2026 Guide]

The CCDV-F fails developers in a predictable way. You have shipped code that calls the Claude API, you can sketch a tool-use loop from memory, and you still finish at 690 because 53 applied scenarios in a row asked which implementation choice fits a stated constraint, and you answered a dozen of them from habit rather than from the guidance Anthropic actually publishes.

The Claude Certified Developer - Foundations (CCDV-F) is Anthropic's certification for engineers who build applications on Claude, and it is a very passable exam on the first attempt if you prepare for what it actually measures. The questions are scenario-driven: a team has a latency budget, a cost ceiling, a parsing failure, or a security concern, and you pick the implementation that fits. That style rewards developers who have made these decisions in real code.

This guide gives you a first-attempt method: the format, a phased preparation plan, per-domain tactics in weight order, the hands-on work that converts documentation into durable knowledge, pacing for 53 questions in 120 minutes, multiple-response technique, and exam-day logistics under Pearson VUE.

Prefer to start with a walkthrough you can watch? Our video companion to this guide covers the same ground: the exam format, the domain weights, and the preparation strategy that follows from them.

Why the CCDV-F Is Winnable on Attempt One

Internalize the format first; every piece of strategy in this guide follows from it.

Three format facts work in your favor. First, all 53 questions are scored, so there are no unscored experimental items and every question you bank is real progress toward the 720 passing mark. The score is scaled, meaning Anthropic converts your raw performance to a common 100 to 1000 scale so results stay comparable across exam forms; treat roughly 75 to 80 percent accuracy as your working target. Second, 120 minutes for 53 questions is a generous time budget, which means careful reading beats speed. Third, the blueprint is published with exact weights, so you can allocate study hours with precision.

The difficulty lives in the question style. A representative CCDV-F stem reads like a ticket from a real backlog: "A team's summarization endpoint must return the first tokens within two seconds and processes the same 40-page policy document on every request. Which combination of API features should the developer use?" The scenario names a latency constraint and a repeated stable prefix, and it expects you to recognize that streaming (delivering the response token by token as it generates) answers the first and prompt caching (reusing a stable prompt prefix across calls at a reduced price) answers the second. Every option will be a real feature, and only one combination fits the stated constraints.

Roughly a quarter of the items are multiple-response questions, where the stem asks you to "Select TWO" or "Select THREE" from a longer list and the item is scored as a complete unit. On a 53-question form that is about 13 questions, so the technique gets its own section below.

A Phased Preparation Approach

Preparation that wanders through documentation produces recognition, and the exam requires applied recall. Structure your weeks into three phases.

Phase 1: Diagnose (2 to 3 days). Read the full 8-domain blueprint in the domains breakdown, then take one full 53-question practice test untimed and open-book. Score yourself per domain and write down your three weakest, because that list is where your study hours should go.

Phase 2: Build and study (2 to 3 weeks). Alternate between hands-on builds (detailed below) and targeted reading on docs.anthropic.com, weighted toward your diagnostic gaps and the heavy domains. For every feature, be able to complete the sentence "use this when... and avoid it when..." because that sentence is what the scenarios score. You exit this phase when you have built something small against every major domain.

Phase 3: Calibrate (1 week). Take two or three full-length practice tests under strict exam conditions: a 120-minute timer, no references, no pauses. After each test, spend as long reviewing explanations as you spent answering, including for questions you got right, because the traps repeat. Consistent timed scores above 80 percent are your green light to book.

The CCDV-F 4-week study plan turns these phases into a day-by-day schedule.

Domain Tactics, Ordered by Weight

The CCDV-F spreads its 53 questions across eight domains with sharply unequal weights, so study time should follow the weights.

Applications and Integration (33 percent): Win the Exam Here

At a third of the blueprint, this domain contributes roughly 17 or 18 questions, more than the bottom five domains combined. It covers the Messages API end to end: request and response structure, tool use, streaming, vision inputs, extended thinking (the mode where Claude reasons internally before answering), prompt caching mechanics, and the choice between realtime calls and the Batch API (Anthropic's asynchronous endpoint that trades immediate delivery for a substantial cost reduction on non-urgent workloads). It also covers the material candidates skip: configuration through CLAUDE.md files and settings.json, pinning model versions so behavior stays stable across releases, and versioning prompts like production artifacts. Expect several questions where the correct answer is a lifecycle or configuration practice rather than an API call. If you can only over-invest in one domain, invest here.

Model Selection and Optimization (17 percent): Numbers Decide These Questions

This domain tests fundamentals (tokens, context windows, sampling parameters, and why identical prompts can produce different outputs) alongside the practical matrix of Opus, Sonnet, and Haiku trade-offs, effort levels, and extended thinking versus fast responses. The questions almost always carry a number: a per-request cost target, a token budget, a latency bound. Read for that number first, because the trap option is the more capable model that violates it. Prompt caching returns here from the cost angle, so know what caching saves and what it cannot save when the prefix keeps changing.

Agents and Workflows (15 percent): Know When Agents Lose

The most tested judgment here is the decision between a workflow (a fixed sequence of steps your code orchestrates) and an agent (a loop where the model decides which step comes next). Stems describing predictable, repeatable pipelines want the workflow answer, and stems describing open-ended tasks with unpredictable branching want the agent answer. Beyond that, know the manager and subagent hierarchy pattern, how the Claude Agent SDK (Anthropic's framework for building agents that loop over tools) structures an agent, what hooks let you intercept in a custom loop, and the trade-off between managed and self-hosted deployment. Framework names like Strands, LangGraph, and PydanticAI appear at the recognition level.

The Middle Weights: Context, Tools, and Security

Prompt and Context Engineering (11 percent) rewards named techniques: pruning stale turns, compaction (summarizing a long conversation to reclaim context space), isolating noisy work in subagents, few-shot examples, structured output, and defensive parsing of model responses. Tools and MCPs (10 percent) expects you to write a tool description a model can act on and to place a capability correctly among built-in tools, custom tools, Skills, and the Model Context Protocol (MCP, Anthropic's open standard for connecting Claude to external tools and data sources), including what an MCP server exposes (resources, tools, and prompts) and how it transports (stdio or sockets). In Security and Safety (8 percent), prompt injection (malicious instructions embedded in content the model reads) is defended with layered guardrails, scoped permissions, and validation outside the prompt, because wording alone is a weak defense. The two 3 percent domains (Claude Code and Eval, Testing, and Debugging) contribute about three questions between them, and daily Claude Code use, covered next, earns them without dedicated study time.

Hands-On Practice That Converts Reading into Points

The recommended profile for this exam is 1 to 5 years of software engineering plus 6 or more months of hands-on Claude or comparable LLM work, and the scenarios are written to detect that experience. Three habits during Phase 2 cover most of the blueprint with code you actually ran.

Build with the API and the Agent SDK. Each of these takes an evening. Write a streaming chat endpoint with one custom tool and force a tool-call round trip. Add prompt caching to a request with a large stable prefix and read the cost difference off your usage dashboard. Request structured output, then feed the parser malformed responses until your defensive handling is real. Finally, use the Agent SDK to build a small agent with two or three tightly scoped tools plus one hook, because watching the model choose a tool badly teaches tool-description writing faster than any article.

Run Claude Code daily. Use it on your actual work for the whole preparation period. Write a project CLAUDE.md, add a personal one, and notice how the hierarchy resolves. Create a custom slash command, configure settings.json, try a Skill, and run one task in headless mode (executing Claude Code non-interactively from a script). This habit covers the Claude Code domain, the configuration-management material in the heavyweight domain, and the context-management techniques, all as muscle memory.

Write an MCP server. A minimal server over stdio exposing one tool and one resource takes an evening in Python or TypeScript, and it permanently settles what the Tools and MCPs domain tests: what the protocol standardizes, where the server runs, and when an MCP server beats a bespoke integration.

Time Management: 53 Questions in 120 Minutes

The arithmetic gives you about 2.25 minutes per question, which is roomy, and the room is exactly why candidates get in trouble: with no time pressure in the first hour, it feels safe to spend five minutes on a stubborn question, and three of those erase your entire reserve.

Run two passes. On the first pass, answer everything you can decide within about two minutes; the moment you start re-reading options a third time, pick your best answer, flag the question, and move on. Hold yourself to checkpoints: roughly 90 minutes left by question 14, 60 by question 27, and 30 by question 40. Aim to finish the first pass with 15 minutes in reserve for flagged items. Change an answer only when you can name the specific thing you missed on the first read; vague second-guessing converts right answers into wrong ones.

The Multiple-Response Technique

With about 13 Select TWO or Select THREE items on the form, multiple-response discipline is worth studying as its own skill. These items are scored as complete units: you earn the point when your entire selection is correct, so abandon any partial-credit instinct.

Treat each required selection as an independent single-answer question that must clear the same confidence bar. Then apply the coverage check: the correct set almost always satisfies the scenario jointly, with each selection answering a different requirement in the stem. If a stem establishes a cost problem and a reliability problem and asks for two actions, expect one cost control and one reliability control, and treat a pair that stacks both answers on the same requirement as the likely trap.

Common First-Attempt Mistakes

Studying favorite topics instead of the blueprint. Agents are the interesting material, and they are 15 percent of the exam. Candidates who spend half their preparation on agent frameworks routinely leak points across the 33 percent domain, where breadth of API mechanics and configuration practice decides far more questions.

Learning features without decision criteria. Knowing that prompt caching exists earns nothing; the points come from knowing it pays off when a large stable prefix repeats across calls and does nothing for one-off heterogeneous requests.

Skipping the operational material. Model pinning, prompt versioning, CLAUDE.md hierarchy, and settings.json feel like housekeeping, and the exam treats them as core engineering. These are cheap points for anyone who spent two weeks using Claude Code seriously.

Taking practice tests without reviewing explanations. The score tells you where you stand, and only the explanation review moves you forward. If your review time is shorter than your test time, you are rehearsing your current level.

Exam-Day Logistics Under Pearson VUE

Registration runs through the Anthropic Partner Academy, which requires Claude Partner Network membership (free to join at claude.com/partners). The exam costs $125 and runs proctored through Pearson VUE in two formats.

Online proctored lets you test from home: run the official system check on the same machine and network you will use, clear your desk, close the door, and plan for a single screen and a webcam scan of the room. Your government ID must match your registration name exactly, and the common failure mode is environmental, so eliminate interruptions and flaky Wi-Fi in advance. A Pearson VUE test center trades the commute for a controlled environment; confirm the address, arrive 30 minutes early, and bring the same matching ID. Either way, book a mid-week, mid-morning slot if you can, take your last full practice test five or six days out, keep the final day light with the CCDV-F cheat sheet, and rest completely the day before.

A passing score earns a digital badge through Credly by Pearson. The credential is valid for 1 year, with a free non-proctored renewal assessment available on the Anthropic Partner Academy before the 12-month expiration; letting it lapse means a full proctored retake.

FAQ

Conclusion

Passing the CCDV-F on the first attempt comes down to preparing for the exam that exists: 53 all-scored applied scenarios with public blueprint weights, a heavy domain that rewards breadth across the API and its operational practices, and about 13 multiple-response items that demand a deliberate coverage technique. Diagnose first, build against every major domain second, and calibrate under timed conditions last.

Map your weeks with the 4-week study plan, keep the cheat sheet at hand for the final week, and calibrate against Preporato's 6 full-length CCDV-F practice tests, where every question carries an explanation of why the right answer wins and why each distractor loses, alongside a 500-card flashcard deck for daily review. If you are torn between the developer and architect tracks, the CCDV-F vs CCA-F comparison settles it.

Take the diagnostic this week. Four weeks of deliberate practice from now, the 53 questions that count will look like scenarios you have already answered.