Claude Developer Certification Questions: CCDV-F Exam Guide

The Claude Certified Developer, Foundations exam (CCDV-F) asks 53 scenario-driven questions in 120 minutes. Understanding how claude developer certification questions are structured across eight domains is the most efficient preparation lever available, because domain weights vary from 2.6% to 33.1% and reward proportionate study investment.

What exactly does the CCDV-F exam test?

The CCDV-F exam covers eight domains spanning the full developer workflow: integrating Claude into applications, building agents, selecting models, engineering prompts, and securing deployments. Unlike the CCAR-F Architect exam, CCDV-F items are written directly against domain skills rather than drawn from a scenario bank, so every question tests a specific skill rather than a multi-part narrative you must track across the sitting.

You face 53 items in 120 minutes. The exam costs $125 USD per attempt and is delivered online-proctored or at a Pearson VUE test centre. A scaled score of 720 on a 100-to-1000 scale is required to pass. Your score report returns the result, your scaled score, and percent-correct by domain, letting you see exactly where you lost points. The credential is valid for 12 months from the award date.

Which domains produce the most questions?

Domain weighting determines where to concentrate your study hours. Per the official CCDV-F exam guide (2026-07-08), the eight domains carry the following exact weights:

Domain 2, Applications and Integration, accounts for roughly one in three questions. If you allocate equal time across all domains, you will under-prepare for the section that has the greatest single impact on your score. Domain 5, Model Selection and Optimisation, adds another 16.8%. Together, Domains 2 and 5 represent just under half the exam. A proportionate study plan allocates roughly one-third of preparation time to Domain 2 and another sixth to Domain 5.

What do Applications and Integration questions look like?

Domain 2 questions test your ability to wire Claude into real systems: REST API calls, streaming versus synchronous responses, third-party deployment targets such as Amazon Bedrock and Google Vertex AI, and asynchronous processing with the Batches API.

A foundational SDK pattern the exam expects you to recognise:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-20251101",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Summarise this contract in three bullet points."}
    ]
)
print(response.content)

The exam probes whether you know when to use client.messages.create versus client.messages.stream, when to reach for the Batches API, and how authentication differs between deployment targets. Bedrock uses IAM credentials; Vertex AI uses Google OAuth or service account tokens. Model identifier formats also differ: Bedrock uses strings such as anthropic.claude-opus-5-20251101-v1:0, while Vertex uses region-scoped endpoint strings like claude-opus-5@20251101. Questions in this space reward SDK familiarity over abstract knowledge.

The Batches API represents a genuine latency-versus-cost tradeoff that examiners can test as a scenario:

{
  "requests": [
    {
      "custom_id": "doc-001",
      "params": {
        "model": "claude-haiku-4-5-20251001",
        "max_tokens": 512,
        "messages": [{"role": "user", "content": "Extract key dates from this document."}]
      }
    }
  ]
}

Use the Batches API when throughput matters more than latency and cost savings are the priority. Use synchronous calls when a user is waiting for a real-time response. This tradeoff appears frequently in Domain 2 scenarios. For a deeper look at how tool results feed back into the agentic loop alongside API responses, see our coverage of Tool Result Appending.

How do Model Selection questions appear on the exam?

Domain 5 (16.8%) asks you to match Claude model tiers to real constraints. The exam does not reward identifying the newest model; it rewards knowing the tradeoff axes: latency, cost, capability, and context window size.

A well-formed Domain 5 scenario presents a use case and asks which model family fits best. Claude Haiku 4.5 suits high-throughput, latency-tolerant classification tasks at the lowest cost. Claude Opus 5 is appropriate when accuracy on complex reasoning is the primary constraint and cost is secondary. Claude Sonnet sits between these poles for balanced workloads.

The exam also covers model selection within multi-agent systems. The orchestrating agent often runs a larger model for complex planning while subagents run a smaller, cheaper model for narrow subtasks. Our Agentic Architecture & Orchestration concept library covers this decomposition pattern in detail, including the criteria for routing tasks between model tiers.

Cost-per-request reasoning is testable. If a scenario gives you a monthly request volume and per-token pricing, you should identify which model and API method combination stays within budget. Prompt caching lowers cost on system prompts repeated across many requests, and the exam may ask you to identify when caching provides meaningful savings versus when request patterns are too varied for it to help.

What should you know for Tool and MCP questions?

Domain 8, Tools and MCPs, carries 10.6% of the exam. Questions test both the mechanics of tool schema definitions and the higher-level decision of when to build versus consume an existing MCP server.

A well-formed tool definition:

{
  "name": "get_customer_orders",
  "description": "Retrieves all orders for a given customer ID, sorted by date descending. Use this tool whenever the user asks about order history or purchase records.",
  "input_schema": {
    "type": "object",
    "properties": {
      "customer_id": {
        "type": "string",
        "description": "The unique customer identifier."
      },
      "limit": {
        "type": "integer",
        "description": "Maximum number of orders to return."
      }
    },
    "required": ["customer_id"]
  }
}

The description field carries significant weight in routing decisions. Claude uses tool descriptions as the primary signal for which tool to invoke; a vague description causes misrouting. See Tool Descriptions as Selection Mechanism for a systematic breakdown of how description specificity affects routing accuracy.

For MCP specifically, the exam tests the difference between MCP resources (read-only content catalogs) and MCP tools (callable actions). It also tests the MCP isError flag pattern for structured error propagation back to the calling agent, and the decision criteria for building a custom server versus integrating an existing one. Authentication scoping, environment variable expansion in MCP configuration, and the distinction between server-level and tool-level permissions are all fair game.

Domain 1, Agents and Workflows (14.7%), overlaps with this territory: you need to know how agents loop over tool calls, how to detect and handle errors within the loop, and the difference between goal-based and step-based prompts for orchestration.

What do Prompt and Context Engineering questions test?

Domain 6, Prompt and Context Engineering, carries 11.0% of the exam. It tests when few-shot examples outperform zero-shot instructions, how XML tags help Claude parse structured sections of a prompt, and how to design prompts that produce reliable structured output.

A system prompt using XML structure:

<role>You are a financial analyst assistant.</role>
<constraints>
  - Only cite figures present in the provided document.
  - Format all monetary values as USD with two decimal places.
  - If information is missing, say so explicitly rather than estimating.
</constraints>
<output_format>
  Respond with a JSON object containing keys: summary, key_figures, risks.
</output_format>

Context management questions test your understanding of the context window as a finite resource. When does summarisation help, and when does it introduce drift? What is the tradeoff between compaction frequency and information fidelity in long-running sessions?

Our Prompt Engineering & Structured Output concept library covers schema design for preventing fabrication, the technique hierarchy for iterative refinement, and the mechanics of reliable structured output generation.

A common Domain 6 scenario: a long-running agentic session is approaching its context limit. The exam will ask you to identify the correct intervention from among summary injection, forking a fresh session with a condensed brief, or adjusting the chunking strategy. Knowing when each approach is appropriate is the difference between a correct and an incorrect answer.

What does the Security and Safety domain cover?

Domain 7, Security and Safety, carries 8.1% of the exam. Questions cover prompt injection defences, input validation at API boundaries, least-privilege tool design, and the principles behind safe agentic deployment.

A typical scenario: a user-provided string is embedded directly into a system prompt without sanitisation. The exam will ask what risk this introduces (prompt injection) and what the correct mitigation is: validate and sanitise user input before embedding it, or enforce hard constraints in the system prompt that a malicious injection cannot override.

The domain also tests your understanding of when to require human review before a high-stakes action, and how to design an approval gate the agent cannot bypass through prompt manipulation. This connects to Domain 1: agentic systems that take irreversible actions need human checkpoints built into the architecture at the code level, not just expressed in the prompt.

What is the best preparation approach for CCDV-F?

Building a real Claude-powered application is the most efficient preparation method because it forces the exact decisions the exam tests: model selection, API method choice, tool schema design, error handling, and prompt iteration. An application that integrates Claude via the Messages API, uses at least one tool, handles streaming responses, and deploys against a real data source will touch Domains 1, 2, 5, 6, and 8 in a single project.

Practice exams calibrated to the 53-question format, 120-minute limit, and 720 passing threshold let you identify weak domains before your real sitting. AI Skill Certs is an independent prep platform, unaffiliated with Anthropic; its adaptive engine uses a 0.90 mastery threshold with Bayesian Knowledge Tracing to surface the concepts where you are most likely to lose points. Archie, the platform's Socratic tutor, guides you through concepts with graduated hints rather than providing answers directly.

When a scenario is unfamiliar, apply the constraint hierarchy: if cost is the primary concern, prefer Haiku and the Batches API; if latency is the concern, prefer synchronous streaming with a smaller model; if the stakes are high and errors are hard to reverse, prefer deterministic, programmatic enforcement over prompt-only approaches. The exam consistently rewards answers that respect real constraints rather than defaulting to the largest, most capable model for every use case.

Domains 3 and 4 together carry only 5.7% of the exam. Do not neglect them entirely, but cap your preparation time proportionally and invest the bulk of your effort where the domain weights direct you. The reasoning Domain 4 requires, tracing failures and verifying outputs, will sharpen your answers in every other domain regardless.