CCDV-F Study Plan: 4-Week Preparation Schedule [2026]

Introduction

Four weeks is a realistic timeline for the Claude Certified Developer - Foundations (CCDV-F) exam if you match the recommended profile: 1 to 5 years of software engineering plus 6 months of hands-on work with Claude or a comparable large language model (LLM) system, with working fluency in Python or TypeScript, REST APIs, and the command line. This plan assumes 8-10 hours per week, built from 1 to 1.5 hours on weekday evenings plus a longer weekend block, roughly 32-40 hours in total.

The CCDV-F is a broad Foundations-level exam: 8 domains spanning the Claude API and client SDKs, model selection, the Claude Agent SDK, prompt and context engineering, tool use and the Model Context Protocol (MCP), security, Claude Code, and evaluation. The exam runs 53 scored questions in 120 minutes, passing at 720 out of 1000 (scaled), and roughly a quarter of the items are multiple-response ("Select TWO" or "Select THREE"), a format that punishes partial knowledge.

The philosophy is simple: active practice beats passive reading. Every week pairs documentation study with something you build and measure, and every checkpoint uses practice test scores to steer your remaining hours.

The four weeks follow the blueprint, front-loading the weight: Applications and Integration plus Model Selection (half the exam) in Week 1, agents and context engineering in Week 2, the four smaller domains plus your first full timed test in Week 3, and pure practice in Week 4. If you ship Claude features daily, compress the plan to two weeks, and if you are new to LLM APIs, extend it to six; both adaptations are detailed near the end.

Before You Start: Prerequisites Self-Check

The CCDV-F has no formal prerequisites, but the exam assumes the recommended experience profile. Answer these five questions honestly:

1. Have you worked as a software engineer for 1 to 5 years, and are you comfortable in Python or TypeScript? Exam scenarios describe code-level situations and expect you to reason about them without a syntax refresher.

2. Have you called the Claude API, or a comparable LLM API, from your own code in the last 6 months? Message arrays, system prompts, and token limits should already be familiar.

3. Are REST APIs and the command line second nature? The exam assumes CLI fluency, especially in Claude Code and MCP questions.

4. Can you explain tokens, context windows, and non-determinism to a colleague without notes? These fundamentals anchor Domain 2 and reappear inside questions from every other domain.

5. Have you used Claude Code or an agent framework, even casually? Domains 3 and 7 reward candidates who have watched an agent loop run, fail, and recover.

If you answered no to most of these and you do not write code professionally, pause: CCAO-F vs CCDV-F: Which Claude Certification walks through whether Anthropic's non-technical track fits your role better, and developers weighing the architect track should read CCDV-F vs CCA-F instead.

The 4-Week Plan at a Glance

The sequencing mirrors the weights: Domains 1 and 2 carry 50% of the exam between them, so they get the first and deepest week, and Weeks 2 and 3 cover the remaining six domains in descending weight order. With everything covered by the end of Week 3, your first timed test leaves a full week for repair.

Week 1: Applications and Integration + Model Selection

Half the exam lives in these two domains, making Week 1 the heaviest and the one to protect most fiercely.

Goal: understand what the exam tests, establish your baseline, and master the API mechanics and model trade-offs the other six domains build on.

Study activities (4-5 hours):

• Read the official exam guide on the Anthropic Partner Academy, noting the 8 domains, weights, and task statements. Our domain breakdown annotates each one with study priorities.
• Work through the Messages API systematically at docs.anthropic.com: message arrays and roles, system prompts, streaming, vision inputs, and extended thinking (a mode where the model spends extra tokens reasoning before it answers). Know when batch beats realtime: the Batch API trades immediacy for a lower price on work that can wait.
• Study prompt caching mechanics. Prompt caching stores a processed prompt prefix so repeated calls skip reprocessing, cutting cost and latency. It pays off when a long, stable prefix (a system prompt, a document, a tool inventory) fronts every request, a setup the exam expects you to recognize on sight.
• Study configuration management: CLAUDE.md files, settings.json, prompt versioning, and model pinning (referencing a snapshot ID so a provider upgrade never silently changes your app's behavior).
• Master the model selection triangle: capability, cost, and latency. Review tokens, context windows, sampling, and non-determinism, then the Opus, Sonnet, and Haiku trade-offs plus fast mode and effort levels. The tested principle is proportionality: route high-volume simple tasks to fast, inexpensive models and reserve the top tier for work where reasoning depth justifies the cost.

Baseline practice test (2 hours): take your first full-length test on Preporato untimed before deep study begins, recording your score in each domain; this baseline decides where your Week 4 hours go.

Hands-on build (2-3 hours, weekend): write a small CLI script that calls the Messages API with streaming and a structured JSON output format. Run the same extraction task across all three model tiers and record tokens, latency, and cost, then add prompt caching with a long stable prefix and measure the savings over ten repeated calls. Once you have seen these numbers, Domain 2 questions become straightforward.

Milestone check: name all 8 domains with weights from memory, sketch a Messages API request unaided, justify a model tier for three scenarios, and know your two weakest domains from the baseline.

Week 2: Agents and Workflows + Prompt and Context Engineering

Goal: turn "should this be an agent?" from intuition into explicit criteria, and learn the context patterns that keep long-running systems reliable.

Study activities (4-5 hours):

• Study the workflow vs agent decision. A workflow chains model calls through predefined steps your code controls, while an agent hands control flow to the model, which decides which tools to call and when to stop. The deciding factors are task predictability, error tolerance, and latency budget, and the rewarded instinct is restraint: with steps known in advance, a workflow wins on cost, latency, and debuggability.
• Study the Claude Agent SDK: how to construct an agent, customize its loop, and attach hooks (code that runs at defined points in the loop to observe or intervene). Know the managed vs self-hosted trade-off, and what Strands, LangGraph, and PydanticAI each are at a one-line level, since framework distractors appear in Domain 3 questions.
• Study context window management: drift and bloat prevention through pruning and compaction (summarizing older history to reclaim tokens while keeping key facts), plus context isolation through manager and subagent hierarchies. A subagent is a separate agent instance with an isolated context window that handles a delegated task and returns only its result, keeping the manager's context lean.
• Study output reliability patterns: instruction clarity, few-shot prompting (worked examples that establish a pattern), structured output formats, and defensive parsing: validating the model's output against a schema, since even well-prompted models occasionally return malformed JSON.

Hands-on build (3 hours, weekend): build the same small task twice: first as a fixed workflow chaining two or three Claude calls, then as an Agent SDK agent with one tool and one hook. Add a subagent for a research step in isolated context, and log what each version costs in tokens and wall-clock time. The comparison teaches Domain 3's core judgment firsthand.

Week 3: Tools, MCP, Security, Claude Code, and Evals

The four smallest domains add up to 24% of the exam and cluster naturally: tools and MCP define what an agent can touch, security defines what it must never touch, and Claude Code plus evals define how you operate and verify it.

Goal: cover the remaining four domains, then take your first fully timed test.

Study activities (4-5 hours):

• Study tool use: how function calling works, how to write tool descriptions the model routes on reliably (specific, unambiguous, clear parameter semantics), and the split between client-side tools your code executes and server-side tools run on Anthropic's side.
• Study MCP properly. The Model Context Protocol (MCP) is an open standard that lets Claude discover and call external tools and data sources through a uniform interface. Know the three primitives a server can expose (resources, tools, prompts), the transports (stdio for local processes, sockets for networked servers), and the selection question the exam loves: when a built-in tool, custom tool, Skill, or MCP server is the right packaging for a capability.
• Study security and safety (Domain 6): prompt injection (malicious instructions smuggled into content the model processes) and jailbreak defense, data leakage and PII handling, authentication (proving who is calling) vs authorization (deciding what they may do), guardrail layering, Claude Hooks as guardrails, and key management.
• Study Claude Code (Domain 7): Rules, Skills, Commands, Agents, and Agent Memory, plus session management, slash commands, headless mode, the CLAUDE.md hierarchy, and settings.json. At 3%, budget a single evening and lean on your daily use.
• Study evals and debugging (Domain 8): error identification and recovery, trace analysis, and the diagnostic split the questions are built around: whether a failure lives in the integration layer (your code, parsing, tool wiring) or in the model's output, because each diagnosis implies a different fix.

Hands-on build (3 hours, weekend): write a small MCP server over stdio exposing one tool and one resource, and wire it into Claude Code. Add a hook that blocks a destructive action, and try a simple prompt injection against your own setup. Finish with a 15-case eval script with known-good answers for your Week 1 extraction task, run before and after a prompt change.

Week 4: Practice Tests, Drills, and Exam Logistics

Week 4 converts knowledge into a passing score: no new material, only testing, review, and logistics.

Days 1-2, weak-domain drills: open your mistake log. Any domain below 80% gets a dedicated drill: re-study the concepts you missed, then work a focused question set in that domain. For recurring mistakes, apply the teach-it test: explain the concept aloud with a concrete example, and if it stumbles, study again.

Days 3-4, exam simulation: take two full-length practice tests under strict conditions: 120 minutes on a timer, no notes, no pauses. The pacing math: 53 questions in 120 minutes gives slightly over two minutes each, so flag anything that takes longer than three and return to it. Drill multiple-response discipline especially hard: roughly a quarter of the exam uses the format, and a "Select TWO" item typically requires both correct selections for credit, so read exactly how many answers the question demands and evaluate each option independently before comparing survivors.

Day 5, logistics and light review: register through the Anthropic Partner Academy if you have not already; registration requires Claude Partner Network membership, free to join at claude.com/partners. The exam costs $125 and runs proctored through Pearson VUE, online or at a test center. For online delivery, test your equipment, clear your desk, and have your ID ready. Spend one final hour on the CCDV-F cheat sheet, then stop studying. Consolidation beats cramming at this point.

Exam day: warm up with ten minutes of cheat sheet review. During the exam, read each scenario for the constraint that decides the answer (a volume figure, a latency requirement, a security boundary), eliminate obviously wrong options first, and change an answer only with a specific reason. For deeper strategy, read How to Pass CCDV-F on Your First Attempt.

Daily Rhythm and How to Steer with Scores

The plan works best as a steady rhythm:

• Weekdays (4-5 sessions of 60-90 minutes): open with 10 minutes of flashcards from the 500-card CCDV-F deck to keep earlier weeks alive, then 45-60 minutes on the current week's material, closing with 15 minutes of practice questions.
• One weekend block (2-3 hours): reserve this for the hands-on build; the builds need uninterrupted time and are the highest-retention hours in the plan.

Use practice test scores as your steering mechanism, with one rule: any domain below roughly 80% gets revisited before moving on. Scaled scoring makes your exact exam margin unpredictable, so consistent 80%+ practice performance is the reliable readiness signal. Preporato's 6 full-length tests support the cadence: an untimed baseline in Week 1, a timed test closing Week 3, two in Week 4, and two in reserve.

Adapting the Plan

The 2-week compressed plan (experienced Claude developers). If you build with the Claude API and Claude Code daily, most of Weeks 1 and 2 is review. Spend Week 1 on a baseline test, the exam guide, and gap-filling in whatever the baseline exposes (most often prompt caching economics, MCP transport details, and the security domain). Spend Week 2 on the Week 3 material plus three timed tests, skipping builds you have already done in production but keeping the multiple-response drilling, since format technique fails experienced candidates as often as knowledge does.

The 6-week extended plan (career changers and developers new to LLM APIs). Stretch Weeks 1 and 2 into two weeks each, adding a foundation session before each block: work through the Anthropic quickstart before touching streaming or caching, and run a prebuilt Agent SDK example before writing your own. Keep Weeks 3 and 4 as written, and add one extra untimed test mid-plan so the score trail has enough data to steer with.

Frequently Asked Questions

Conclusion

The CCDV-F covers 8 domains spanning the full developer surface of Claude, and the exam rewards exactly what this plan builds: working knowledge backed by things you have run, measured, and broken. Four weeks at 8-10 hours per week is enough when every hour has a job.

This plan leaves you with artifacts that outlive the certification: a model-tier benchmark script with caching measurements, a task built as both workflow and agent, an MCP server with a guardrail hook, a 15-case eval harness, and a mistake log of every wrong answer. These are the production patterns the credential certifies, ready to carry into your next project.

For the full exam overview, read the Complete CCDV-F Guide. For background on the credential, see What is CCDV-F?, and for quick daily reference, bookmark the CCDV-F cheat sheet.

Ready to establish your baseline? Take your first CCDV-F practice test on Preporato and start Week 1 today. All 6 tests, plus the 500-card flashcard deck, are available through Preporato Pro and the practice bundle.