Claude Certified Developer ProfessionalCCDV-PAnthropicStudy PlanCertification

Claude Developer Professional Study Plan: 6-Week Schedule [2026]

Preporato TeamNovember 16, 202615 min readCCDV-P

Start Here

Take the 20 free Developer - Professional practice questions before Week 1 to see where you stand. The plan below uses the six Early Access Developer - Professional practice exams as its milestones, one or two per stage.

Exam Quick Facts

Duration
135 minutes
Cost
$175 USD
Questions
70 questions (60 scored, 10 unscored)
Passing Score
720 out of 1000 (scaled)
Valid For
12 months
Format: Pearson VUE test center or online proctored

Status on November 16, 2026

Developer - Professional is a preview entry in Anthropic's Partner Academy catalog: eight weighted domains, no exam guide and no registration yet. That makes now a good time to start, because the material it points to is documented today, and six weeks of production practice will still count when the guide lands. The "Adapting the plan" section below says what to change when it does.

Introduction

Claude Certified Developer - Professional is about Claude systems after they ship. Its eight domains cover integration reliability, agent architecture, observability, evaluation, guardrails, debugging, fleets of coding agents and cost at scale, and the questions start from a running system with a symptom to explain or a decision to make. Reading documentation helps, but the fastest way to answer those questions is to have built and broken the thing yourself.

This plan gives you six weeks of about 8 to 10 hours each. Every week pairs reading with one build you keep extending, so by Week 5 you have a small production-style Claude service with logging, evals, guardrails and a CI agent, and every domain has something concrete behind it. Practice exams sit at fixed points so your scores steer the time you have left.

Three quick Developer - Professional questions

Question 1 of 3Agent Fleet Operations for Software Delivery (10%)

A developer starts Claude Code with --settings ci.json, which sets a key that their project's .claude/settings.local.json also sets. Managed settings do not set it. Which value applies for that session?

Pick one answer

Full CCDV-P set: 6 timed exams, every answer explained, $19.99 one-time.

See the practice tests
Free questions

Try 15 CCDV-P practice questions free

They come from the CCDV-P 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

Before you start: prerequisites self-check

Developer - Professional assumes the ground CCDV-F covers. Before Week 1, check that you can do each of these without looking anything up:

  • Send a Messages API request with a system prompt, tools and streaming, and read every field of the response.
  • Explain prompt caching as a prefix match and say what breaks a cache.
  • Write a tool definition with a description that says when to use the tool, and handle a tool_use turn.
  • Build a small agent with the Claude Agent SDK or a hand-written loop.
  • Use Claude Code with a CLAUDE.md, permission rules and at least one hook.

If two or more of these are shaky, spend a week on Developer - Foundations material first. The CCDV-F vs Developer - Professional comparison explains how the two exams split the ground.

Timeline adjustment by experience

ProfileSelf-assessmentRecommended timeline
Passed CCDV-F and runs Claude in productionAll five checks pass; you already log usage and handle errors4 to 5 weeks: compress Weeks 1 and 2
Builds with Claude, nothing in production yetChecks pass, but no evals, monitoring or CI agents yet6 weeks, as written
New to the Claude PlatformTwo or more checks fail8 weeks: 2 weeks of CCDV-F material, then this plan

The 6-week plan at a glance

Baseline and production integration

Week 1
  • •Practice exam 1, untimed, as a baseline
  • •Errors, retries, rate limits, context windows, workspaces
  • •Build: a resilient client that logs usage and request IDs

Agent architecture

Week 2
  • •Subagents, forks, compaction, context editing
  • •Tool search, MCP at scale, programmatic tool calling
  • •Build: an orchestrator with three subagents that survives a restart

Observability and evaluation

Week 3
  • •Usage fields, analytics API, Claude Code telemetry
  • •Success criteria, graders, eval sets as release gates
  • •Practice exam 2, timed

Guardrails and debugging

Week 4
  • •Injection defense, permissions, sandboxing, data residency
  • •Stop reasons, mid-stream errors, cache breaks, hook loops
  • •Build: plant injections, then add defenses one at a time

Fleet operations and cost

Week 5
  • •claude -p in CI, GitHub Actions, worktrees, managed settings
  • •Caching, batches, effort and model routing
  • •Practice exam 3, timed under exam conditions

Practice and review

Week 6
  • •Practice exams 4 to 6, timed
  • •Review every miss by domain
  • •Final-week checklist and exam logistics

Week 1: Baseline and Production Integration (20%)

Goal: know where you stand, and master the domain with the most weight, which every other domain builds on.

Practice exam (2.5 hours): take Practice Exam 1 from the Developer - Professional practice exams untimed, before you study. Write down your score for each domain. A low score here is normal; its job is to show you where Weeks 3 to 5 should lean.

Study (4 hours):

  • Errors and retries. Read the API errors page until you can sort every status into "retry" or "fix the request". Know that the SDKs retry twice by default, which errors they retry, and why a tier spend-cap 429 has no retry-after header.
  • Rate limits. Requests, input tokens and output tokens per minute; ramp limits (ramp_limit_exceeded); and the rule that cache reads do not count toward input-token limits.
  • Context windows. The difference between a 400 "prompt is too long" and a model_context_window_exceeded stop reason, and why lowering max_tokens fixes neither.
  • Workspaces. The Default Workspace takes no spend limit, and workspace limits can only stay below the organization's.
  • Grounding. Citations, search result blocks, and the MCP connector's toolset configuration.

Hands-on build (3 hours): write a thin client around one Claude call that logs the model, the usage object and the request-id for every request, honors retry-after, retries 429, 500 and 529 with backoff, streams long outputs and pins the model ID. This client is the base you extend for the rest of the plan.

Milestone check: sort ten error scenarios into retry or fix from memory, explain both context-window outcomes, and name your two weakest domains from the baseline.


Week 2: Advanced Agent Architecture and Orchestration (17%)

Goal: design agents that run long, hit context limits, fail halfway and resume.

Study (4 to 5 hours):

  • Subagents and forks. Read the Agent SDK subagents page: what a subagent's context starts with, how a fork differs, how subagent_type: "fork" appears without configuration from Claude Code v2.1.302, and how an Agent(fork) deny rule blocks it.
  • Context that outgrows the window. Context editing (clear_tool_uses_20250919), threshold compaction, on-demand compaction and the memory tool. Learn which can share a request: compaction and context_management cannot.
  • Tools at scale. When tool search pays off (10 or more tools, or over 10,000 tokens of definitions), how alwaysLoad exempts a Claude Code MCP server, and how plugin MCP tools are named.
  • Programmatic tool calling. How caller.tool_id links each tool call to the code that made it.
  • Sessions. Resuming a Claude Code or Agent SDK session by ID so a crash does not restart finished work.

Hands-on build (3 to 4 hours): extend your client into an orchestrator with three subagents, each with narrow tools, that return compact structured summaries. Kill the process halfway, resume the session, and confirm it continues without redoing finished work. Then let the conversation grow until you have to compact, and watch what the usage numbers do.

Milestone check: explain why a bigger context window does not fix an orchestrator drowning in subagent output, and name the two features that cannot share a request.


Week 3: Observability (12%) and Evaluation (12%)

Goal: see what your system is doing, and stop bad changes before they ship. Together these two domains carry almost a quarter of the exam, and they are where CCDV-F graduates usually have the least practice.

Study (4 hours):

  • Per-request data. The four usage token fields and how they add up, cache hit rate, and why tenant and feature tags belong in your logs.
  • Organization reporting. The Usage and Cost Analytics API: refresh timing, revisions until about 7 days after month end, keyless usage with api_key_id: null, and the api_key_ids[]= empty entry.
  • Claude Code telemetry. CLAUDE_CODE_ENABLE_TELEMETRY=1, the main metrics and events, and enforcement through managed settings. Read what /usage means when it shows last-known data.
  • Evaluation. Anthropic's guide to success criteria and evaluations: specific and measurable criteria, test sets that mirror real traffic, and the three grading methods. Learn the LLM-grader tips: detailed rubric, empirical output, thinking on.
  • Hooks as checks. Command, prompt and agent hooks in Claude Code, and what ok: false does on each event.

Hands-on build (2 to 3 hours): add a dashboard to your service with requests, p95 latency, cost per request and cache hit rate per feature. Then write 30 to 50 graded cases for one feature, a script that runs them with code checks plus an LLM grader, and a CI step that fails on a score drop.

Practice exam (2.5 hours): take Practice Exam 2, timed. Compare each domain score with your Week 1 baseline.

Mid-plan checkpoint

If Practice Exam 2 is still under about 65%, slow down: add a week and repeat the reading for your two lowest domains before moving on. Raw score matters less than the trend, and each later week assumes the earlier ones held.


Week 4: Guardrails (11%) and Debugging (10%)

Goal: harden agents that read the outside world, and diagnose failures from evidence.

Study (4 hours):

  • Injection defense. Anthropic's guides on jailbreaks and prompt injection, hallucinations and prompt leak. The pattern to internalize: untrusted content in tool results, least-privilege tools, approvals enforced in code.
  • Claude Code permissions. The six permission modes, rule order (deny, then ask, then allow), settings precedence, auto mode's 3-in-a-row and 20-total thresholds, and sandbox excludedCommands syntax.
  • Data residency. Workspace geo against inference_geo, the 1.1x price for US-only inference on Claude 4.6 and later models, and what Remote Control keeps local.
  • Stop reasons. All seven values in handling stop reasons, plus empty end_turn responses after tool results.
  • Debugging patterns. Errors that arrive mid-stream, cache breaks after deploys, thinking configuration 400s on newer models, and Stop hook loops with their 8-continuation cap.

Hands-on build (3 hours): plant five prompt-injection attempts in documents and tool results your agent reads. Record which work, add one defense at a time and rerun after each. Then write a one-page runbook per symptom: cut-off answers, empty answers, a cost spike, a refusal spike, a 529 storm. For each, list the log field that confirms it and the first action.

Milestone check: for any stop_reason, say what caused it and the next move, and explain why a broad deny rule beats a narrow allow rule.


Week 5: Fleet Operations (10%) and Cost (8%)

Goal: run coding agents unattended under organization controls, and price a workload before it ships.

Study (3 to 4 hours):

  • Headless runs. Running Claude Code programmatically: --bare, --permission-mode dontAsk, --allowedTools, --max-budget-usd, --output-format json, the 10 MB stdin cap, and how background work is handled at exit.
  • GitHub Actions. The v1 action: prompt, claude_args, --append-system-prompt, the @claude trigger and OIDC for Bedrock, Agent Platform and Foundry.
  • Worktrees and managed settings. What Claude Code skips when it creates a worktree, what worktrees share with the main checkout, and caps such as maxEffortLevel.
  • Cost levers. Prompt caching prices and breakpoints, automatic caching, the Message Batches API, the 1-hour TTL for batches with shared prefixes, effort, model routing, and why cached thinking blocks show up as input.

Hands-on build (2 to 3 hours): add a CI job that runs claude --bare -p on each pull request with explicit allowed tools, dontAsk, a budget cap and JSON output, and records total_cost_usd. Then take your highest-volume feature and write down its cost per 1,000 requests before and after caching, batching and routing, with an eval score beside each change.

Practice exam (2.5 hours): take Practice Exam 3 under exam conditions: 135 minutes, one sitting, no documentation.

Milestone check: configure an unattended CI run from memory and estimate the saving from caching a 20,000-token prefix.


Week 6: Practice, Review and Exam Readiness

Goal: turn knowledge into consistent timed scores.

  • Practice Exams 4, 5 and 6 (7.5 hours): spread them across the week, timed. After each, read the explanation for every question you missed or guessed, including the ones you got right by luck.
  • Weak-domain review (3 hours): for your two lowest domains, reread the cheat sheet section and the documentation behind each miss.
  • Select TWO drill (1 hour): go back through the Select TWO questions from all six exams and judge each option on its own, as true or false.
  • Logistics: when registration opens, book through Pearson VUE, run the online-proctoring system check early if you test from home, and plan to arrive or log in ahead of time.

Not consistently above 80% yet?

Our recommendation is to book once you score 80% or more on two timed practice exams in a row. If you are not there, add a week: one more pass through your weakest domains, then retake the exams you scored lowest on and read every explanation again.

Daily rhythm and steering with scores

A steady week beats a weekend cram. A rhythm that works for most people with a job:

  • Weekdays (60 to 90 minutes): 45 minutes of documentation for the week's domains, then 15 to 30 minutes of practice questions or work on the build.
  • Weekend (3 to 4 hours): the week's build, and the practice exam when one is scheduled.

After every practice exam, sort your misses into three groups: never seen the feature, knew it but misread the scenario, and narrowed to two then picked wrong. The first group needs reading, the second needs slower stem reading (find the one fact that decides the question), and the third needs the documentation for both options, because at this level the wrong option is usually a real feature applied in the wrong place.

Adapting the plan

  • When Anthropic publishes the exam guide. Read its task statements against this plan and move hours toward anything new. Preporato revises the practice exams to the guide when it is out, so retake the revised exams in Week 6.
  • Only four weeks. Merge Weeks 1 and 2 and Weeks 3 and 4, keep the builds smaller, and take at least three timed practice exams.
  • Strong in Claude Code, newer to the API. Spend extra time on Weeks 1 and 3; Week 5's fleet material will move faster.
  • Strong on the API, newer to Claude Code. Add an hour each to Weeks 4 and 5, which carry most of the Claude Code settings and permissions material.

Frequently asked questions

Conclusion

Six weeks, one service you keep extending, and six practice exams at fixed points: that is the whole plan. By the end you will have handled the errors, read the stop reasons, gated a release with evals and run a coding agent in CI, which is what Developer - Professional questions describe. Start with the 20 free practice questions, keep the cheat sheet open while you study, and use the exam domains breakdown when a domain needs more context. For everything Anthropic has published about the exam, see the exam guide.

Developer - Professional 6-Week Plan Milestones

0/13 completed

Sources:

CCDV-P
6 Practice Exams
Detailed Explanations
Performance Analytics
Get Full Access - $19.99See what's included →

CCDV-P · 6 practice exams

$19.99one-time

Get full access