Claude Certified Developer – Foundations (CCDV-F)

Free practice questions & exam guide — no signup, no paywall to start.

Claude Certified Developer – Foundations is Anthropic's official credential for engineers who build, integrate, and ship applications powered by Claude. The exam code is CCDV-F. There is no widely used shorthand for this credential — you'll see it written out in full or as CCDV-F, and both forms are used interchangeably throughout this guide and across Anthropic's own materials.

If you write code against the Claude API, wire Claude into a production application, build agents with the Claude Agent SDK, or maintain MCP servers and custom tools for a team, this is the credential built around your job — not around prompting skill in isolation, and not around system-level architecture decisions. This page is the hub for everything else on this site about the exam: benefits, eligibility, validity and renewal, cost and registration, and a full FAQ. For the credential family overview, see Claude Certifications; for the mechanics shared across all four exams (retakes, appeals, accommodations), see the shared policy reference.

What the exam actually validates

CCDV-F is an independent assessment of the knowledge, skills, and abilities needed to build Claude-based applications competently at a foundational level. Passing signals that you can independently own, or significantly contribute to, building, integrating, and shipping Claude-powered systems in a production codebase — not that you've memorized API parameters, and not that you've merely used Claude as an end user. The exam guide frames this as a floor, not a ceiling: a foundational bar for professional competence, with a separate Architect credential covering the broader system-design layer above it.

Concretely, a credential holder can demonstrate: building agents and workflows with the Claude Agent SDK, agentic frameworks, or custom agent loops; integrating Claude into application code through the API and client SDKs (including streaming responses, error handling, and multi-format input); operating Claude Code across its interfaces, including authoring Claude Skills and configuring CLAUDE.md, settings.json, and plugins; writing effective prompts and applying context engineering to prevent context drift in long-running interactions; designing and running evals, debugging failure modes through trace analysis, and validating structured output; monitoring production quality over time; selecting the right Claude model tier and managing tokens, prompt caching, and batch processing for cost and latency; applying secure-by-design principles and hooks-based guardrails against prompt injection and destructive actions; and building custom tools, function schemas, and MCP servers while weighing tradeoffs against built-in tools and Skills.

Why this credential exists

Claude adoption inside engineering organizations has outpaced any shared, external way to verify who actually knows how to build with it correctly. Internally, teams have historically relied on informal signals — a candidate mentions a side project, a resume lists "LLM integration," a portfolio has a repo with an anthropic import in it. None of that is independently verifiable, none of it is scored against a consistent bar, and none of it distinguishes someone who has shipped a production-grade integration from someone who has called the API once in a tutorial. CCDV-F exists to close that gap: a single, proctored, blueprint-scored exam that means the same thing regardless of who administers it or which team wrote the job posting.

It also exists because "building with Claude" is not one skill — it's a cluster of related but separable skills: calling an API correctly is different from designing a good tool schema, which is different from managing a token budget at scale, which is different from defending against prompt injection. The eight-domain structure reflects that decomposition directly, and the domain weights reflect Anthropic's own judgment about which of those skills matters most for a working developer's actual day-to-day output.

Who this credential is for

The intended audience is technical professionals who build, integrate, and ship production-grade AI solutions with LLMs, particularly Claude — primarily AI/ML engineers, technical leads, and senior software engineers. The exam guide's target profile is one to five years of software engineering experience plus at least six months of hands-on work with Claude or a comparable LLM system. Candidates are expected to be proficient in Python and/or TypeScript, fluent with REST APIs and CLI tools, and to have a working understanding of LLM fundamentals, agents, context management, and MCP.

This is deliberately not a credential for casual Claude users. The exam guide explicitly excludes non-technical users and roles limited to prompt writing without broader application-development responsibility — that audience is better served by Claude Certified Associate – Foundations. There are no mandatory prerequisites to register, but the content assumes you've been writing and shipping code, not just chatting with a model. See the eligibility page for a detailed self-assessment.

The 8 exam domains

CCDV-F is organized into eight domains, each weighted by how much of the 53-item exam it represents. The weighting is heavily skewed — one domain alone accounts for roughly a third of the exam, while two others together account for less than 6%. Understanding this shape matters more than memorizing any single domain's bullet points, because it tells you where to actually spend your preparation time.

Applications and Integration (33.1%)

This is by far the heaviest domain, and that weighting is not an accident — it reflects what the credential is actually built to validate. The core job function of a Claude developer is shipping working integrations: calling the API correctly, handling streaming responses, managing errors and retries, accepting multi-format input (text, images, documents), and wiring Claude into an existing application's request/response lifecycle. It also covers integrating Claude through client SDKs and third-party integrations rather than only raw HTTP calls. Every other domain supports that core job; this domain *is* that job. If you prepare for one thing, prepare for this — it alone is worth more than the bottom four domains combined.

Model Selection and Optimization (16.8%)

Covers choosing the right Claude model tier for a given task and managing the cost/latency tradeoffs that come with real production traffic. That includes token budgeting and estimation, prompt caching strategy (what to cache, when caching pays off versus adds complexity), and batch processing for workloads that don't need synchronous responses. A developer who can only use one model tier for everything, or who has never reasoned about caching economics, will find this domain exposes real gaps — it's the second-heaviest domain for a reason.

Agents and Workflows (14.7%)

Covers building agents and workflows using the Claude Agent SDK, established agentic frameworks, or fully custom agent loops. This is the orchestration layer that sits above a single request/response API call — the reasoning-tool-call-result loop repeated until a task completes, including how an agent decides when it's done, how it handles partial failure inside a multi-step task, and how state is carried across steps.

Prompt and Context Engineering (11.0%)

Covers writing effective prompts and, critically, applying context engineering to prevent context drift — the gradual degradation that happens as a conversation or agent loop accumulates irrelevant, stale, or contradictory information in its context window. This domain tests whether you can reason about what belongs in context, what should be summarized or evicted, and how to structure prompts so that behavior stays reliable as interactions grow longer, not just on day-one prompt quality.

Tools and MCPs (10.6%)

Covers designing custom tools, function schemas, and MCP (Model Context Protocol) servers, and — just as importantly — knowing when to reach for a built-in tool versus a custom one versus a Claude Skill versus an MCP integration. This tradeoff judgment is tested directly: the exam expects you to know the shape of each option's strengths, not just how to write a JSON schema for a single tool.

Security and Safety (8.1%)

Covers applying secure-by-design principles and hooks-based guardrails against prompt injection and destructive actions. A meaningful slice given how much real production risk concentrates here — an agent with tool access that can be manipulated by adversarial input in a document, email, or web page it processes is a live threat model, not a theoretical one, and this domain tests whether you can reason about and mitigate it.

Claude Code (3.1%)

Covers operating Claude Code across its interfaces: authoring Claude Skills, and configuring CLAUDE.md, settings.json, and plugins. It's a light domain relative to the others, but it's specific — expect questions that assume you've actually configured a Claude Code environment for a team, not just used it interactively with defaults.

Eval, Testing, and Debugging (2.6%)

The lightest domain by weight, covering designing and running evals, debugging failure modes via trace analysis, validating structured output, and monitoring production quality over time. Its low weight doesn't mean it's unimportant in practice — production Claude systems live or die on good evals and monitoring — it means the exam samples it narrowly relative to Applications and Integration. Don't over-invest study time here relative to its 2.6% share.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[{
        "name": "get_order_status",
        "description": "Look up the status of a customer order by ID.",
        "input_schema": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    }],
    messages=[{"role": "user", "content": "Where is order 48213?"}],
)

# A real integration handles streaming, retries, and the follow-up
# tool_result turn — the exact ground the Applications and Integration
# domain (33.1% of the exam) is built to test.
for block in response.content:
    if block.type == "tool_use":
        print(block.name, block.input)

What exam questions are actually shaped like

All 53 scored items are multiple-choice or multiple-response — there's no live-coding or hands-on lab component. That said, the exam guide's domain descriptions (integration, tool design, context engineering, debugging via trace analysis) imply scenario-based questions rather than pure definition recall: expect a short description of an application situation — a streaming response that's cutting off mid-sentence, an agent that's looping on the same tool call, a context window that's degrading output quality over a long conversation — followed by answer choices that test whether you can identify the correct diagnosis or fix. This is consistent with how Anthropic's other Claude certifications are structured, and it rewards people who've actually debugged these situations in real code over people who've only read about them.

How to think about preparing

There's no official Anthropic-published study guide beyond the exam guide itself and the Partner Academy's own materials, and this site won't invent a specific hour count for you — everyone's baseline is different. The one piece of high-leverage advice the domain weighting gives you directly: since Applications and Integration (33.1%) and Model Selection and Optimization (16.8%) together account for just under half the exam, make sure your hands-on experience with API integration, streaming, error handling, token/cost management, and caching is genuinely current — not experience from a year ago with an SDK version that's since changed. For the four lighter domains (Security and Safety, Tools and MCPs, Claude Code, Eval/Testing/Debugging), a deliberate review pass is usually enough if you have any working familiarity with the concepts already; they're real but narrow slices of the exam.

If you're looking for a practice test, be aware of what's out there: at least one paid, multi-certification exam-prep platform has shipped a gated sample test for this exact exam (matching the 53-item, 120-minute, 8-domain structure), with presumably paid access to a full question bank beyond the free sample. This site takes a different approach — free, complete coverage of the domain blueprint, eligibility, cost, and every practical question a candidate is likely to have, with nothing gated behind a signup or a paywall.

Developer vs. Architect Foundations: related, not hierarchical

The most common point of confusion is assuming Claude Certified Architect – Foundations is a "higher tier" than Developer Foundations, or that you need one before the other. Neither is true. They are related but distinct scopes, not a ladder. Claude Certified Architect – Foundations validates broader system design: agentic architecture and orchestration, Claude Code configuration for team workflows, MCP tool-interface design, and context management across multi-agent systems — the decisions that shape how a whole system is put together.

Claude Certified Developer – Foundations validates the application-level work of building and shipping within that system: writing the integration code, handling the API contract correctly, building the individual tools and agent loops, and operating Claude Code day to day. A useful shorthand: Architect asks "how should this system be designed and orchestrated," while Developer asks "can you build, integrate, and ship the thing that implements that design." Many engineers will find one or the other maps more closely to their actual day job — and some will reasonably hold both, since the domains overlap in places (both touch Claude Code and MCP, for instance) without duplicating the same task statements.

Is it worth it?

For an engineer already doing this work, the honest answer is that the exam mostly formalizes what you'd need to know to ship Claude features competently anyway — the value is less in learning net-new material and more in having an independent, portable signal that a hiring manager or client can verify without reading your code. See the benefits page for the full case, including how the $125 fee compares to what one verifiable credential can do for a job search or a rate negotiation in a competitive AI-engineering market.

It is not, and doesn't claim to be, a substitute for shipped production experience. It validates knowledge and applied skill against a fixed blueprint at a point in time; it doesn't validate judgment under the specific constraints of your team's codebase, incident history, or scale. Treat it as a complement to a portfolio of real work, not a replacement for one.

A day in the life, mapped to domains

One way to see why the domain weighting matches real work: trace a typical week for an engineer maintaining a Claude-powered feature. Monday, you're debugging a customer report that a streamed response occasionally cuts off before a tool call resolves — that's Applications and Integration. Tuesday, you're reviewing a cost report showing token spend has crept up and deciding whether a heavier model tier is actually buying you accuracy or just cost — that's Model Selection and Optimization. Wednesday, you're extending an internal agent that keeps re-running the same search tool instead of terminating — that's Agents and Workflows. Thursday, a teammate flags that a long-running support-chat agent has started giving worse answers a few dozen turns into a conversation — that's context drift, squarely in Prompt and Context Engineering. Friday, you're reviewing a pull request that adds a new MCP server for internal ticket lookups and debating whether it should be a custom tool instead — that's Tools and MCPs, with a side of Security and Safety once someone asks what happens if a ticket body contains adversarial instructions.

Claude Code and Eval/Testing/Debugging tend to show up as background maintenance rather than headline work — updating CLAUDE.md when a new coding convention is adopted, writing a new eval case after a regression slips through, checking a trace to see why a tool call returned malformed JSON. That's consistent with their light exam weighting: real, necessary, but a smaller share of where the actual engineering hours go compared to the integration and orchestration work that dominates both the job and the exam.

Common misconceptions about CCDV-F

• "It's a coding exam." It isn't — all 53 items are multiple-choice or multiple-response. There's no live coding, no submitted repo, no lab environment. It tests whether you can reason correctly about integration, architecture, and debugging scenarios, not whether you can type working code under time pressure.
• "It's a prerequisite for Architect Foundations." It's not. The two credentials are independently registrable and test different scopes; you can take either first, both, or just one, based on which matches your actual role.
• "Passing means I don't need to know the Claude Agent SDK deeply." The opposite — Agents and Workflows is 14.7% of the exam on its own, and Applications and Integration (which frequently involves the same SDK surface) is another 33.1%. Together, agent-and-integration-adjacent content is easily half the exam.
• "The exam changes constantly since Claude changes constantly." The exam guide is versioned (this content is grounded in Version 1.0), and Anthropic's renewal policy explicitly accounts for content changes over time — but within a given exam guide version, the blueprint and weights are fixed and published, not a moving target.
• "A high score in a domain I use every day guarantees a pass." Not quite — your overall scaled score blends performance across all eight domains weighted by their percentages. Strength in Applications and Integration matters far more than strength in Claude Code specifically because of the weighting, but the exam still samples every domain.

For Python developers specifically

Because the exam guide names Python and/or TypeScript as the expected proficiency, and Python has historically been the dominant language in AI/ML tooling, it's worth addressing directly: yes, Python-only proficiency is sufficient — you do not need TypeScript to sit or pass this exam. Anthropic's Python SDK covers the same core surface tested by the Applications and Integration domain (client construction, streaming, tool use, multi-format input), and the Agent SDK, MCP server implementations, and Claude Code configuration all have first-class Python paths. If your production Claude work has been entirely in Python — a FastAPI service calling the Messages API, a Python-based MCP server, an Agent SDK loop orchestrated in a backend job — you have everything language-wise that the exam assumes.

How CCDV-F fits into the broader Claude certification family

Anthropic runs a single certification program with four credentials inside it, of which CCDV-F is one: Claude Certified Architect – Foundations (system design and orchestration), Claude Certified Architect – Professional (a deeper, more senior architecture credential), Claude Certified Associate – Foundations (day-to-day productivity use of Claude for non-technical and lightly technical roles), and Developer Foundations itself (application-level building and shipping). All four share the same registration system (Anthropic Partner Academy for purchase, Pearson VUE for scheduling and delivery), the same 100–1,000 scoring scale with a 720 passing threshold, and the same 12-month validity period. Only the content, fee, and domain blueprint differ from one credential to the next.

That shared structure means the mechanics you learn while preparing for or registering for CCDV-F transfer directly if you ever pursue a second Claude credential — you won't need to relearn how Pearson VUE scheduling works, how retake waiting periods are calculated, or how the score report is formatted. See the full comparison across all four credentials if you're trying to decide which one (or which combination) matches your actual role, especially if your responsibilities span both hands-on development and broader system-architecture decisions.

Free vs. paid preparation resources

A fair question when researching any new certification is where to actually study. For CCDV-F, the authoritative source is Anthropic's own exam guide and Partner Academy materials — start there for anything you want to be certain is accurate. Beyond that, the independent resource landscape for this specific exam is still thin, since it's a relatively new credential: a few independent study-guide write-ups exist, at least one general-purpose exam-prep video platform has practice questions, and — notably — at least one paid, multi-certification exam-prep platform (covering dozens of unrelated certifications like cloud and project-management exams alongside this one) has already shipped a gated sample test matching this exam's exact structure, with a free sample and presumably paid access to the rest.

This site's approach is to be the free, complete alternative: full domain coverage, a realistic eligibility self-assessment, exact cost and registration mechanics, validity and renewal timelines, and a comprehensive FAQ — all without a signup wall or a paid tier gating the rest of the content. If you've already looked at a gated sample test elsewhere and want the full picture without paying for it, the five pages linked from this hub are designed to cover that gap directly, sourced from the same official exam guide those other resources draw from.

Where to go next

• Benefits — the hiring-signal and ROI case in detail
• Eligibility — the full audience profile and a realistic self-assessment
• Validity and renewal — the 12-month clock and what happens if it lapses
• Cost and registration — the $125 fee, domain-weighted value, and how to register
• Full FAQ — 15+ specific questions answered in one place
• Claude Certifications — how all four credentials fit together
• Shared policy reference — retakes, appeals, accommodations, identical across all four exams