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
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
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?
Settings precedence, highest first, is managed settings, command line (--settings), project local, shared project, then user. A key passed with --settings overrides the same key in project and user files for that session only. List keys such as permissions.allow are the exception: they merge across files. A reverses the order, and C and D invent rules.
On November 3, a finance team pulls October's totals from the Usage and Cost Analytics API for the monthly close. A week later the same query returns slightly different numbers. What explains this, and when are October's totals final?
Analytics data typically refreshes within 4 hours and can take up to 24, and values can be revised as late events arrive until about 7 days after the end of the calendar month. For final totals, query only months that ended at least 7 days ago. B invents sampling. C is wrong because every page of a paginated query reads the same snapshot. D misstates the refresh schedule.
A nightly Message Batches job of 40,000 requests hits the 24-hour limit before 1,200 of them are sent to the model. How are those 1,200 requests billed, and what should the pipeline do?
A request that reaches the batch's 24-hour expiration before it is sent to the model comes back with the result type expired, and you are not billed for it. Most batches finish within an hour, and results stay available for 29 days. A, B and D describe billing rules that do not exist.
Full CCDV-P set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsTry 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_useturn. - 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
| Profile | Self-assessment | Recommended timeline |
|---|---|---|
| Passed CCDV-F and runs Claude in production | All five checks pass; you already log usage and handle errors | 4 to 5 weeks: compress Weeks 1 and 2 |
| Builds with Claude, nothing in production yet | Checks pass, but no evals, monitoring or CI agents yet | 6 weeks, as written |
| New to the Claude Platform | Two or more checks fail | 8 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-afterheader. - 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_exceededstop reason, and why loweringmax_tokensfixes 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 anAgent(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:compactionandcontext_managementcannot. - Tools at scale. When tool search pays off (10 or more tools, or over 10,000 tokens of definitions), how
alwaysLoadexempts a Claude Code MCP server, and how plugin MCP tools are named. - Programmatic tool calling. How
caller.tool_idlinks 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
usagetoken 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 theapi_key_ids[]=empty entry. - Claude Code telemetry.
CLAUDE_CODE_ENABLE_TELEMETRY=1, the main metrics and events, and enforcement through managed settings. Read what/usagemeans 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: falsedoes 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
excludedCommandssyntax. - 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_turnresponses 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@claudetrigger 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 completedSources:
- Claude API errors and rate limits
- Context windows and workspaces
- Agent SDK subagents, context editing and compaction on demand
- Tool search tool and programmatic tool calling
- Usage and Cost Analytics API and Claude Code monitoring
- Define success and build evaluations
- Data residency and handling stop reasons
- Claude Code: settings, permission modes, hooks, headless runs, GitHub Actions and worktrees
- Prompt caching and batch processing