These 20 Claude Certified Developer - Foundations (CCDV-F) practice questions follow the shape of the real exam: a production scenario with a decision to make, four options, and about a quarter marked Select TWO. They are spread across all eight domains in proportion to the published weights, so Applications and Integration gets seven items and each of the two 3% domains gets one. Every question ends with the answer and an explanation of why the winning option wins and why each distractor loses, because CCDV-F distractors are real techniques applied in the wrong situation. Work through the set timed (about two and a half minutes per question), score yourself against the rubric below, then use the domain map at the end to decide what to read next.
Start Here
If the vocabulary in any question is unfamiliar, read the domain sections of the CCDV-F complete guide first. For the full-length experience, Preporato's CCDV-F practice tests offer 6 timed 53-question exams built on the same 8-domain blueprint, and the free CCDV-F sample questions lets you try a set at no cost.
CCDV-F exam update on December 7, 2026
Anthropic updates the CCDV-F exam content on December 7, 2026, and publishes the updated exam guide on November 17. If you test on December 7 or later, prepare from the updated guide. This article follows the current guide, and we will revise it once the new one is out. If you are nearly ready now, a date before December 7 lets you sit the version you studied for.
How CCDV-F questions are built, and how to score yourself
CCDV-F stems are short production scenarios that carry two or three constraints at once: a latency requirement, a cost ceiling, a data boundary, a parser downstream. Usually more than one option would work in some context. The exam asks for the best fit under the constraints actually stated, so the reading skill is spotting the dominant constraint (a person waiting on the response, a hard compliance requirement, an eval that already ruled something out) and letting it eliminate options before you weigh the rest. Multiple-response items work the same way, applied to each option independently; treat a Select TWO as two separate true-or-false judgments and count it correct only when both picks match.
Score this set the way you would read a practice test on preporato.com. Seventeen or more out of twenty means your judgment is where it needs to be and the remaining work is timed full-length practice. Fourteen to sixteen is borderline, pass-capable on a good day, so target the domains you missed. Under fourteen means the concepts need another pass through the guide before more questions will help.
How the 20 questions are distributed
| Domain | Exam weight | Questions in this set |
|---|---|---|
| Applications and Integration | 33% | 7 (Q1, Q2, Q3, Q4, Q5, Q11, Q19) |
| Model Selection and Optimization | 17% | 3 (Q6, Q10, Q15) |
| Agents and Workflows | 15% | 3 (Q7, Q12, Q18) |
| Prompt and Context Engineering | 11% | 2 (Q8, Q13) |
| Tools and MCPs | 10% | 2 (Q9, Q16) |
| Security and Safety | 8% | 1 (Q14) |
| Claude Code | 3% | 1 (Q17) |
| Eval, Testing, and Debugging | 3% | 1 (Q20) |
Try 15 CCDV-F practice questions free
They come from the CCDV-F practice tests, and each option shows its explanation once you answer.
- 6 timed practice exams
- Every answer explained
- A score for each domain
- $19.99 one-time
The 20 practice questions
Questions 1–5
A support chat product streams Claude's replies to the browser over server-sent events. Users report that some long answers stop mid-sentence, yet the interface renders them as finished. Logs for those turns show a final stop_reason of max_tokens. The team wants the smallest change that makes truncation visible and recoverable. What should the developer do?
stop_reason reports why generation ended, and max_tokens means the output cap cut the answer off, so the fix is a larger cap on routes that produce long answers plus interface handling that treats the signal as truncation. A gives up the perceived-latency benefit of streaming and still truncates at the same cap. B ends generation earlier at a sentence boundary and reports stop_sequence, which hides the problem while leaving the cap in place. D changes sampling randomness and has no reliable effect on length; a truncated answer at any temperature is still truncated.
A nightly enrichment job sends 400 sequential Claude requests that share a 20,000-token reference-manual prefix marked with a cache_control breakpoint. Each request waits on an upstream step, so calls arrive roughly fifteen minutes apart. Usage logs show cache_creation_input_tokens on every call and cache_read_input_tokens always at zero, and costs match uncached pricing. What is the most likely cause and fix?
A cache entry lives for a default five minutes, refreshed each time it is read, so calls spaced fifteen minutes apart write a fresh entry every time and never read one, which is exactly what the usage fields show. The extended one-hour lifetime, or tighter scheduling, keeps the entry warm across calls. A is wrong because caching has a minimum cacheable length rather than a maximum. B is wrong because content in tools, system, and messages can all sit inside the cached prefix. C is wrong because concurrency is unnecessary; any request inside the lifetime window reads the entry.
A fintech team's Claude-backed statement summarizer changed tone and format one morning with no deploy. Investigation shows the code references a model alias, and the summarization prompt lives in a database row that support staff edit directly. The team wants reproducible behavior and reviewable change. Which TWO changes address the root causes? (Select TWO.)
Behavior that shifts with no deploy has two live inputs: the model, which an alias can resolve to a newer snapshot, and the prompt, which was being edited outside any review path. Pinning the model version turns upgrades into deliberate, evaluated changes, and versioning the prompt like code makes every change reviewable and revertible. B preserves the exact drift the team is trying to remove. C narrows who can edit but leaves the prompt outside version control, review, and evaluation, so the next quiet change is still one edit away.
A field-service app photographs utility meters with phone cameras and asks Claude to read the digits. Photos are 12-megapixel JPEGs sent as base64 image blocks. Time to first token and per-request cost are both above budget, and a test on images resized to roughly one megapixel shows identical reading accuracy. Which change best fixes cost and latency?
Claude reads images in fixed-size patches, so token cost and processing time scale with pixel dimensions, and the API downscales oversized images anyway before the model sees them. Resizing on the client to the resolution that still reads accurately cuts tokens, upload size, and time to first token in one change. A only alters how the bytes reach the API; the model sees the same image and bills the same tokens. C removes interactivity while a technician stands at the meter waiting. D adds output tokens and latency to a task the model already gets right.
A Node.js service summarizes 60 uploaded documents per user request by calling Claude once per document inside a for loop with await, so each request takes about 60 times the single-call latency while the user waits. The team wants much faster completion without triggering rate-limit errors. Which approach best fits?
Independent calls should run concurrently, and bounding the concurrency (a semaphore or small worker pool) keeps the burst under your rate limits while backoff handles the occasional 429. A removes the wait but converts it into a burst of rate-limit errors and retries. B improves time to first token on each call and does nothing about running them one after another. D is built for offline volume with hour-scale turnaround, which does not suit a user waiting on the response.
Full CCDV-F set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsDomain 1 alone is a third of the exam. If any of Questions 1 to 5 felt shaky, work through the Applications and Integration section of the CCDV-F exam domains breakdown before continuing.
Questions 6–10
An insurer extracts eight fixed fields from claim forms with the top capability tier. Every request carries the same 9,000-token instruction and examples block, and results must reach an adjuster's screen within seconds. A 5,000-form eval shows the fast tier matches extraction accuracy. Monthly spend is three times budget. Which TWO changes cut cost without breaking requirements? (Select TWO.)
The eval already proves the cheaper tier holds accuracy, so downgrading with the eval kept as a guardrail is the largest saving available, and caching a stable 9,000-token prefix removes most of the remaining input cost per call. A fails the seconds-level latency requirement, since batches can take up to a day to complete. D raises output tokens and latency on a task the model already performs correctly, so it moves cost in the wrong direction.
A platform team is deciding which of four upcoming workloads should be built as an agent loop, where the model chooses its own next steps and tool calls, versus a fixed workflow of predetermined model calls. Cost, auditability, and predictability all matter to the team. Which TWO workloads justify an agent loop rather than a workflow? (Select TWO.)
An agent earns its nondeterminism and cost only when the path cannot be scripted in advance. Debugging an unknown cause and open-ended research both branch on what each step reveals, so a loop that decides its next action is the right shape. A and C are enumerable pipelines with fixed inputs, fixed prompts, and a fixed output schema. A workflow runs them cheaper, faster, and more auditably, and an agent there adds variability without adding capability.
A retrieval assistant places 25 retrieved policy documents (about 40,000 tokens) in the user turn, with the instruction "answer only from these documents; otherwise reply NOT FOUND" inserted between documents 12 and 13. In testing, the model sometimes answers from general knowledge. The team wants the cheapest reliable improvement. What should they change first?
Attention concentrates at the beginning and end of a long context, so an instruction buried in the middle of 40,000 tokens sits where it is least likely to hold. Putting the rule in the system prompt and repeating it beside the question costs almost nothing. B reduces randomness without changing what the model treats as an instruction. C adds tokens and latency before the placement problem is addressed. D leaves the guidance in the same low-attention position, so the examples inherit the problem.
An intake service registers two tools, extract_claim and lookup_policy, and every response must arrive as an extract_claim tool call so downstream code can read structured fields. With tool_choice left at the default, the model occasionally replies in prose or calls lookup_policy first. Which change guarantees the required tool call on every request?
tool_choice with type: "tool" and a name forces the model to call exactly that tool, which is the API-level guarantee the pipeline needs. A only guarantees some tool call, so lookup_policy can still be chosen first. B is a probabilistic instruction plus a retry loop, which lowers the failure rate and guarantees nothing. C removes a tool the service may still need and swaps a schema-enforced tool call for free-form JSON in text, which is exactly what defensive parsing exists to distrust.
A document-summarization endpoint fails on some uploaded PDFs with a 400 error stating that the prompt is too long, while smaller files succeed. The developer proposes raising max_tokens from 4,000 to 16,000 to give the request more room. The summaries themselves are short. What is the correct diagnosis and fix?
max_tokens caps the output; the context window bounds input plus output together, and a 400 saying the prompt is too long is the API reporting that the input side already overflowed, so a larger output cap makes it worse. Measure with the token counting endpoint, then chunk, summarize hierarchically, or trim. A misreads which side overflowed. B describes a 429, which is retryable; a 400 is a request problem you fix rather than retry. D invents a format failure the error message does not describe.
Full CCDV-F set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsModel tier, caching, and batch decisions repeat across the whole exam. The decision rules are condensed onto one page in the CCDV-F cheat sheet, which is worth a read before Questions 11 to 20.
Choose provider-side prompt caching with prefix keys, then drag the TTL down and watch the hit rate and the bill for 1,000 requests fall away: Question 2 is this slider in reverse, calls that arrive after the cache window has closed, and Question 6 is the same long prefix reused on every request.
Questions 11–15
A retailer must generate descriptions for 400,000 catalog items before a launch in five days, and the merchandising interface also lets an editor regenerate any single description while they wait on the page. The team wants the lowest cost that still meets both needs. Which processing design fits?
The two workloads have different dominant constraints. The backfill has volume and nobody waiting, which is what the Batch API exists for: asynchronous, discounted, finished within a day. The editor is a person waiting on a page, so that path needs realtime with streaming. B makes the editor wait on hour-scale turnaround. C pays realtime rates for 400,000 non-urgent calls and fights rate limits for no benefit. D inverts the match, paying full price for the bulk work and batching the interactive path.
A team wrote a custom loop over the Messages API: call the model, execute any requested tools, append results, repeat until end_turn. Product now wants file and shell tools, permission prompts before risky actions, session resume, and subagents. The team wants to stop rebuilding what Claude Code already has. Which choice best fits?
The requirement list (built-in file and shell tools, permission prompts, session persistence, subagents) is the Agent SDK's feature set, because it packages the same harness Claude Code runs on. A means reimplementing all of it. B provides a state graph and orchestration primitives without shipping the tools, permission layer, or Claude Code parity the team asked for. C solves tool discovery, and MCP is a fine way to add tools, but it provides none of the loop features (permissions, sessions, subagents).
A coding agent has been working in one session for four hours. Its context now holds hundreds of stale file reads and test outputs, and it has started re-deciding choices settled earlier. The team wants to keep the decisions and rationale while releasing most of the token budget. Which TWO actions address bloat and drift directly? (Select TWO.)
Bloat is accumulated content that no longer earns its tokens, and drift is the model losing hold of earlier decisions under that weight. Pruning removes the dead weight outright, and compaction summarizes what remains so decisions survive at a fraction of the size. B changes billing rather than context size; the same tokens still crowd the window, and a constantly changing history is a poor cache prefix anyway. D changes the model tier, and no tier fixes a context full of stale material.
A research agent has fetch_page and send_email tools. During a run, a scraped web page contained hidden text telling the agent to email the user's last ten messages to an external address, and the agent complied. The team needs a control that holds even when a future page contains a cleverer injection. Which change provides that guarantee?
Prompt injection (adversarial instructions smuggled in through content the model reads) is defended in layers, and the layer that gives a guarantee is the deterministic one: a hook or approval gate that runs as code before the tool executes, plus permissions that make exfiltration impossible regardless of what the model decides. A is a useful layer and still probabilistic, so a cleverer injection can defeat it. C may lower the rate of compromise and offers no guarantee. D changes sampling and has no bearing on instruction hijacking.
A live-captioning product runs a top capability tier model with streaming. Users complain that words arrive too slowly during fast speech, even though the first token appears promptly. An eval shows that moving to the fast tier drops caption accuracy below the acceptable threshold. The team wants faster token output with no change in model quality. Which option fits best?
The constraint pair is same quality plus faster generation, which is what fast mode trades money for: identical model weights served with a faster inference configuration, with the gain concentrated in output tokens per second. A adds reasoning tokens before the answer, delaying captions further. B accepts an accuracy loss the eval already ruled out, and few-shot examples are an unreliable substitute for tier capability. D targets input-side processing (time to first token), which the scenario says is already fine, and does nothing for output speed.
Full CCDV-F set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsFive of these twenty are Select TWO. If you lost a point by pairing one right option with one wrong one, the multiple-response technique in How to pass CCDV-F on your first attempt is worth twenty minutes.
Questions 16–20
A developer is building an MCP server for the company's ticketing system. Claude clients need to read ticket details, create tickets, and connect from teammates' laptops as well as from a hosted agent in the cloud, all through one shared deployment. Which TWO design decisions are correct for this server? (Select TWO.)
MCP servers expose three primitives: resources for readable data, tools for callable actions, and prompts for reusable templates, so tickets are resources and creation is a tool. Transport follows deployment shape: stdio spawns a local process per client, which cannot be one shared endpoint, while HTTP-based transports serve remote clients from a single deployment. A misuses prompts, which are templates rather than data or actions. B picks the local transport for a remote, shared requirement.
A team added a PreToolUse hook that blocks destructive shell commands, but it only fires on the laptop of the engineer who wrote it. She placed it in .claude/settings.local.json. The team wants every clone of the repository to enforce the same block without per-machine setup. What should she change?
Claude Code reads a hierarchy of settings files: the user-level file is personal, .claude/settings.local.json is personal and kept out of version control, and .claude/settings.json is the shared project file that travels with the repository. Team-wide enforcement belongs there. B works until someone forgets, and it is never version-controlled. C turns a deterministic hook into a probabilistic instruction. D moves enforcement to CI, which does nothing for interactive sessions on developer machines.
A bank is deploying a coding agent that must run inside its own VPC, use an internal build toolchain, and never send tool traffic through infrastructure the bank does not control. A vendor-managed agent runtime would ship in days, and the self-hosted route will take weeks. Which deployment model should the team choose, and why?
Managed deployment hands the loop and sandbox to the provider for speed and low operational burden; self-hosted keeps execution on your infrastructure for control and compliance. Two of this scenario's requirements (traffic confined to the bank's VPC, a custom internal toolchain) are only satisfiable when the bank runs the runtime, so schedule pressure does not change the answer. A defers a hard requirement. C asserts a security ranking the scenario gives no evidence for. D is factually wrong about managed runtimes, which do execute tools.
A developer's tool-use loop receives a tool_use block, runs the tool, then replies with a user message whose content array starts with a text block reading "Here is the result:" followed by the tool_result block. The API rejects the request with a 400 error stating that tool_use ids were found without tool_result blocks immediately after. What is the correct fix?
The Messages API requires each tool_use block in an assistant turn to be answered by a tool_result block, referencing the same id, in the user message that comes directly after, and inside that message the tool_result blocks must come first, with any text after them. A controls whether the model may call tools and has no bearing on result placement. B marks the result as a failed execution, a different signal that does not relax ordering rules. C discards the structured pairing entirely and hides tool output where the model cannot associate it with the call.
A store assistant told a shopper an item was in stock when it was sold out. The trace shows the model called get_inventory with the correct SKU, the tool returned a quantity of 14 from a cache last refreshed six hours earlier, and the model reported that number faithfully. Where does the failure live, and what is the first fix?
Failure attribution starts by asking whether the model did what the evidence supported. It did: correct tool, correct argument, faithful report. The bad data entered at the integration layer, so the fix belongs there, and returning freshness metadata lets the model or the application flag stale reads next time. B asks the model to compensate for a data defect it cannot see. C spends money on reasoning that was never the problem. D mislabels extended thinking, a model-side dial, as an integration fix.
Full CCDV-F set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsTwenty questions is a diagnostic. To rehearse pacing across a full 53-question form, take a timed test on the CCDV-F practice tests page and score it by domain.
If you missed these, read this
Use your misses to pick the next reading, since a wrong answer here usually points at a rule you have not yet internalized rather than a fact you have not seen.
- Applications and Integration (Q1, Q2, Q3, Q4, Q5, Q11, Q19): the Messages API mechanics, caching, batch, and configuration sections of the complete guide, then the same domain in the exam domains breakdown.
- Model Selection and Optimization (Q6, Q10, Q15): the tier decision rules and cost levers in the cheat sheet.
- Agents and Workflows (Q7, Q12, Q18): the workflow-versus-agent criteria and deployment models in the exam domains breakdown.
- Prompt and Context Engineering (Q8, Q13): the bloat, drift, pruning, and compaction definitions in the cheat sheet, plus the context section of the complete guide.
- Tools and MCPs (Q9, Q16): the tool description and capability-selection material in the complete guide.
- Security and Safety (Q14): the layered-defense section of the complete guide and the trap-answer list in How to pass CCDV-F on your first attempt.
- Claude Code (Q17) and Eval, Testing, and Debugging (Q20): the component map and failure-isolation table in the cheat sheet.
Build the SDK agent and MCP server yourself
Question 12 turns on knowing what the Agent SDK already gives you and Question 16 on how an MCP server is put together; one graded project has you build a working SDK agent with custom tools, a turn budget, and output you can trust, the other a stdio MCP server from scratch with JSON-RPC and two tools.
- Build a Working Agent with the Claude Agent SDK: Custom Tools, a Turn Budget, and Output You Can Trust ~1hadvancedRubric-graded ProOpen project
- Build a stdio MCP Server From Scratch: JSON-RPC, Two Tools, and a Protocol Oracle ~2hadvancedRubric-graded ProOpen project
When the reading is done, the next step is volume under time pressure. Preporato's CCDV-F practice tests give you 6 full-length 53-question exams with an explanation on every item and a 500-card flashcard deck, available through Preporato Pro or the single-cert bundle, and the free CCDV-F sample questions is there if you want to try the format first. If your exam is more than a few weeks out, the 4-week CCDV-F study plan sequences the reading and the practice.
Frequently asked questions
Key takeaways
Key Takeaways
0/9 completedNext steps
Score yourself, note the domains behind your misses, and do the reading in the map above before touching more questions. Then move to volume: the CCDV-F practice tests give you six timed 53-question forms with per-domain scoring, the 4-week study plan sequences the rest of your preparation, and the exam-day tactics in How to pass CCDV-F on your first attempt turn the judgment you have built here into a first-attempt pass.
Wire the hook and permission callback behind Q14 and Q17
Both questions reward a control that runs as code before the tool executes: a PreToolUse hook committed to project settings so every clone enforces it, and a permission callback with an audit trail and a human escalation path; these two graded projects have you wire each one and prove that it fires.
- Harden Your .claude Directory: Permissions, a Skill, and a Hook That Fires ~1hintermediateRubric-graded ProOpen project
- Guardrails for an SDK Agent: a Permission Callback, an Audit Trail, and a Human Escalation Path ~1hadvancedRubric-graded ProOpen project
Sources:
![20 Free CCDV-F Practice Questions With Explanations [2026]](/blog/ccdv-f-practice-questions-with-explanations-2026.webp)