Already familiar with the CCA Foundations exam format and domain weightings? Then this page is your next step: a hands-on study plan built around five worked practice questions with full explanations, a 7-day and a 14-day timeline, and an FAQ to help you turn preparation into a passing score. New to the exam? Start with our Claude Certified Architect Exam Guide for the full exam format, domain breakdown, and scoring details — then come back here to plan your study schedule.
What Is the Claude Certified Architect (CCA) Certification?
The Claude Certified Architect certification is Anthropic's professional credential for engineers, architects, and AI builders who design production-grade applications using Claude. Unlike general AI certifications that test broad machine-learning theory, the CCA Foundations exam is entirely Claude-specific — it tests real architectural decisions you make when deploying Claude in production systems.
Passing the exam signals that you understand Claude's agentic capabilities, tool-use mechanisms, prompt engineering principles, and context management features at a depth sufficient to make correct design choices under real-world constraints. The CCA Foundations certification is valid for 12 months from the date of passing; you must renew before your 12-month term expires.
The exam is not trivial. The exam uses a scaled 720/1,000 scoring system — the passing score is 720 out of 1,000, not a percentage of questions answered correctly. But the five domains are well-defined, the material is learnable, and every question type on the exam has a recognisable pattern once you've practised enough of them.
CCA Foundations Exam Format
Before studying domains, understand exactly what you're facing on exam day:
| Detail | Value |
|---|---|
| Total questions | 60 |
| Question format | Multiple-choice and multiple-response, scenario-based (each item states how many responses to select) |
| Time limit | 120 minutes (2 minutes per question) |
| Passing score | 720 / 1,000 (scaled score, not a raw percentage) |
| Scoring method | Domain-weighted |
| Validity period | 12 months from date of passing; must renew before expiry |
| Registration fee | $125 (USD) |
Every question places you inside a realistic scenario — a production system under load, a broken agent loop, a poorly scoped tool schema — and asks you to identify the best architectural decision. Studying only by reading documentation passively will leave you underprepared; you need active practice with scenario-based questions to calibrate your judgment.
The 5 CCA Exam Domains and Their Weightings
The CCA Foundations exam is divided into five domains. Each carries a specific percentage of your final score. Study time should roughly mirror those percentages — spending equal time on a 15% domain and a 27% domain is an inefficient use of limited preparation hours.
| Domain | Exam Weight | Est. Questions |
|---|---|---|
| 1. Agentic Architecture | 27% | ~16 |
| 2. Claude Code Configuration | 20% | ~12 |
| 3. Prompt Engineering | 20% | ~12 |
| 4. Tool Design & MCP | 18% | ~11 |
| 5. Context Management | 15% | ~9 |
Domain 1: Agentic Architecture (27%)
The heaviest domain — more than one in four marks comes from here. It covers how Claude operates inside autonomous agent loops: the observe-think-act-respond cycle, subagent orchestration, tool-calling sequences, and the reliability patterns that make agentic systems safe to deploy at scale.
High-priority topics: parallel vs. sequential subagent execution, scoped tool access, clarifying ambiguity before a long autonomous run, human-in-the-loop interrupt design, and recovery strategies when a subagent fails mid-task. Expect questions where two answer choices both technically work but one is architecturally superior — this is the domain where judgment matters most.
Domain 2: Claude Code Configuration (20%)
Tests your ability to configure Claude Code correctly for production projects. The exam expects fluency with CLAUDE.md file structure, the inheritance hierarchy between global and project-level settings, and how slash commands are defined, scoped, and invoked.
High-priority topics: when to use settings.json vs. settings.local.json, Bash and file tool permission allowlists, connecting and configuring MCP servers inside Claude Code, and writing CLAUDE.md files that steer Claude's behaviour without over-constraining it. Candidates often underestimate this domain because it feels like configuration — but the questions require genuine understanding of how the settings interact at runtime.
Domain 3: Prompt Engineering (20%)
Goes well beyond writing a better system prompt. This domain tests your ability to diagnose why a prompt underperforms and apply structured techniques to fix it systematically.
High-priority topics: persona and role framing, explicit instructions, context construction, few-shot example selection and ordering, chain-of-thought and extended thinking usage, structured output via tool_use and JSON schemas, and prompt injection prevention in production systems. Understand not just what each technique does but what breaks when you omit one.
Domain 4: Tool Design & MCP (18%)
The Model Context Protocol domain tests both conceptual knowledge and practical design skills. You need to be able to read a tool schema, identify what's wrong with it, decide when to split versus consolidate tools, and reason about MCP server security in production contexts.
High-priority topics: MCP server architecture (resources, tools, and prompts primitives), JSON Schema for tool input definitions, writing tool descriptions that Claude can reliably use, tool naming conventions that reduce ambiguity, and authentication patterns for production MCP deployments. The exam frequently presents broken or suboptimal tool schemas and asks you to identify the flaw.
Domain 5: Context Management (15%)
The lightest domain by weight but consistently underestimated. Context management questions are often the easiest marks available once you understand the core concepts — and the easiest to lose if you don't. Study this domain last but never skip it.
High-priority topics: prompt caching, conversation compaction and summarisation patterns, token estimation and budget management, and multi-turn conversation design that maintains quality over many turns.
5 Sample CCA Exam Questions
The following questions mirror the scenario-based style used on the CCA Foundations exam. Work through each before reading the answer and explanation.
Question 1 — Agentic Architecture
An orchestrator agent spawns four subagents in parallel to process different sections of a large document. One subagent encounters a permission error on a file system tool and halts. What is the correct response from the orchestrator?
- A. Reassign the failed section to one of the three subagents that completed successfully, since their file system access is evidently working
- B. Have the failed subagent write its own error into the shared document context so the other subagents can route around it
- C. Surface the partial failure to the user, return results from successful subagents, and request clarification before retrying
- D. Grant the subagent broader file system permissions and re-run it so the job finishes without interrupting the user
Correct answer: C. A permission error is not a transient failure, so retrying it unchanged does not resolve it, and the published exam guide treats escalation as the right move when an agent cannot progress on its own. Widening the subagent’s permissions has the agent grant itself a capability it was never given. Reassigning the section to a subagent that happens to be working retries an error that fails the same way. Letting the failed subagent post its error into shared context bypasses the coordinator, which in a hub-and-spoke design owns error handling and information routing.
Question 2 — Claude Code Configuration
A developer wants Claude Code to run npm test and npm run build without confirmation prompts, while still requiring approval for all other Bash commands. This allowlist should apply to every developer who clones the repository. Where is the correct place to configure it?
- A. In the user's global
~/.claude/settings.jsonunderallowedTools - B. In the project's
.claude/settings.jsonunderallowedTools, committed to version control - C. In the project's
CLAUDE.mdas a natural-language permission instruction - D. In the project's
.claude/settings.local.jsonunderallowedTools
Correct answer: B. Project-level .claude/settings.json committed to version control is the correct location for tool permissions that should apply consistently to all project contributors. Global settings (A) apply to every project on that machine, not just this one. CLAUDE.md instructions (C) are behavioural guidance, not enforced tool permissions. settings.local.json (D) is for personal, machine-specific overrides that must not be committed.
Question 3 — Prompt Engineering
A production customer-support system prompt has a clear persona, detailed instructions, and rich context. Despite this, Claude's responses vary noticeably in tone and length across sessions. The prompt includes no worked examples. What is the most likely root cause of the inconsistency?
- A. The persona definition is too broad and needs to be narrowed with more specific attributes
- B. Without concrete examples, Claude lacks a calibration anchor for tone, length, and format
- C. The instructions section is too long and is causing the model to selectively ignore guidance
- D. The context section is conflicting with the persona and should be shortened
Correct answer: B. Few-shot examples function as a behavioural anchor — they show Claude precisely what a correct response looks like in terms of length, tone, and structure. Without them, Claude interpolates from pre-training, producing variance. Adding two or three worked examples of ideal responses is the fastest fix for tone and length inconsistency when persona, instructions, and context are already solid.
Question 4 — Tool Design & MCP
An MCP server exposes two separate tools, get_order_status and get_order_shipping_info, that both query the same orders table and are almost always needed together for a given order. Claude sometimes calls only one when both are actually needed. What is the most effective fix?
- A. Rename both tools with more distinctive names so Claude can tell them apart more easily
- B. Consolidate the two tools into a single
get_order_detailstool that returns both status and shipping information - C. Add a note to the system prompt instructing Claude to always call both tools together
- D. Leave the tools separate but shorten their descriptions to reduce token overhead
Correct answer: B. When two tools are almost always needed together and draw on the same underlying data, consolidating them into a single tool removes the coordination problem entirely — there's no longer a decision for Claude to get wrong. This is the same tool-design judgment tested elsewhere on the exam: match tool granularity to how the data is actually used, rather than mirroring the API or database structure one-to-one.
Why A is wrong: Better naming might reduce confusion at the margins, but it doesn't address the root cause — two tools that are almost always called together shouldn't require Claude to remember to call both.
Why C is wrong: A prompt instruction is a probabilistic nudge, not a structural guarantee. It can reduce the error rate but won't eliminate it the way consolidating the tools does.
Why D is wrong: Shortening descriptions to save tokens doesn't address the coordination problem, and thinner descriptions typically make correct tool selection harder, not easier.
Question 5 — Context Management
A long-running agentic task is approaching the context window limit with approximately 15% of the window remaining. The agent still needs to execute three more tool calls to complete the task. Which strategy best preserves task continuity?
- A. Clear the entire conversation history and restart from a fresh context with the original system prompt
- B. Summarise completed task steps into a compact state block and continue execution from the summary
- C. Increase the
max_tokensparameter to extend the available context window - D. Return a context-limit error to the user and ask them to restart the task from scratch
Correct answer: B. Conversation compaction — summarising completed steps into a dense state block — is the standard approach for preserving task continuity when approaching the context limit. Clearing history entirely (A) discards all accumulated task state. max_tokens (C) controls output length, not input context size, and cannot extend the window. Returning an error (D) is premature when compaction is available and the task can continue.
CCA Foundations Study Timeline
How much preparation time you need depends on your existing familiarity with Claude's APIs and tooling. The two plans below are realistic for candidates starting from a working knowledge of LLM APIs.
One-week sprint (7 days)
- Days 1–2: Read the official CCA exam guide. Use our CCA Exam Guide to map every topic to its domain. Note the domains you already feel confident in.
- Days 3–5: Work through 40–50 practice questions per day, in domain order from heaviest to lightest. Review every explanation — especially on questions you answered correctly, because understanding why the right answer is right matters more than the result itself.
- Day 6: Take one full 60-question timed exam simulation. Treat it exactly as the real exam — no pausing, no references. Review your domain score breakdown carefully.
- Day 7: Targeted review of your two weakest domains only. 20–30 focused questions. Rest the evening before exam day.
Two-week preparation (14 days)
- Week 1: Cover each domain in weight order — Agentic Architecture first, then Claude Code Config and Prompt Engineering together, then Tool Design & MCP, then Context Management last. 20–30 questions per domain, each explanation reviewed thoroughly.
- Week 2: Two full 60-question timed simulations, spaced three days apart. Use the domain-weighted breakdown from each run to direct your remaining study hours. In the final 24 hours: review your personal notes only — no new questions.
In both plans, the domain score breakdown from the timed simulation is your most valuable piece of data. It tells you precisely where to invest remaining hours — not where you think you're weakest, but where the data says you are.
Frequently Asked Questions
How hard is the CCA Foundations exam?
Harder than most candidates expect on their first attempt. The 720/1,000 scaled passing score combined with purely scenario-based questions means you cannot pass through memorisation alone. Candidates who study for one to two weeks with active, question-based practice pass on their first try at a high rate. Candidates who only read documentation typically do not.
Is the CCA exam open-book?
No. The CCA Foundations exam is a proctored, closed-book assessment. You cannot reference documentation, notes, or external resources during the exam. This makes active recall practice — working through problems without looking up answers — the most valuable study technique available. Every practice question you work through without checking answers first is worth more than two pages of reading notes.
What is domain-weighted scoring?
Domain-weighted scoring means that questions from heavier domains carry more influence on your final score than questions from lighter domains. A question from Agentic Architecture (27%) contributes more to your percentage score than a question from Context Management (15%). This is why studying proportionally to domain weight is important: gaining accuracy in the two or three heaviest domains has a disproportionately large impact on whether you pass.
How long does it take to receive results?
Results timing is set by Anthropic; refer to Anthropic's official exam guide for current details on when and how results are delivered. Your score report includes a breakdown by domain, which is valuable both for understanding where you lost marks and for planning a retake strategy. Candidates who fail often have one domain where they scored below 50% — that single domain is almost always the deciding factor, and it's recoverable with targeted study.
How much does the CCA Foundations exam cost?
The standard registration fee for the CCA Foundations exam is $125 (USD), paid directly to Anthropic when you schedule your session — verify current pricing on Anthropic's official registration page before you book. It's worth gauging your starting point first — our free 10-question readiness diagnostic scores you across all five domains in a few minutes and estimates how close you are to the 720/1,000 passing standard, so you can decide whether to schedule now or spend a few more weeks on active practice first.
Can I retake the exam if I fail?
Yes. A mandatory waiting period applies between attempts — refer to the current Anthropic certification policy for the exact interval. The most effective retake strategy is to use your domain breakdown: identify your lowest-scoring domain, spend 80% of your retake preparation time on it, and run one more full simulation before attempting again.
What is the difference between CCA Foundations and higher CCA tiers?
The CCA Foundations exam is the entry-level credential. It tests broad competency across all five domains at an architectural decision-making level. Higher-tier CCA certifications go deeper into specific areas — advanced agentic system design, enterprise MCP deployments, or large-scale context management architectures. Foundations is the prerequisite for all higher CCA tracks and is the right starting point for every candidate.
Ready to put this study guide to work? If you're not sure where to start, take our free 10-question readiness diagnostic first — it scores you across all five domains in a few minutes and estimates how close you are to the 720/1,000 passing standard. Then build judgment with the 400-question practice bank, and when you're ready to test under real conditions, go straight into the full 60-question timed simulation for a domain-weighted score breakdown.