Preparing for the Claude Certified Architect (CCA) Foundations exam in 2026? This guide covers everything you need: the exam format, all five domains with their official weightings, a domain weight table, five representative practice questions with full explanations, a study timeline, and an FAQ. Whether you have one week or one month, start here.
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 credential is valid for two years from the date you pass.
The exam is not trivial. A 75% passing threshold on 60 scenario-based questions leaves little margin for guessing. 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, scenario-based |
| Time limit | 120 minutes (2 minutes per question) |
| Passing score | 75% — 45 of 60 correct |
| Scoring method | Domain-weighted |
| Validity period | 2 years from passing date |
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. There are no definition questions. 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, minimal-footprint design, 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 frameworks to fix it systematically. The PRECISE framework is the cornerstone of this domain.
High-priority topics: PRECISE (Persona, Role, Explicit instructions, Context, Instructions, Steps, Examples), few-shot example selection and ordering, chain-of-thought and extended thinking usage, Constitutional AI principles, and prompt injection prevention in production systems. Understand not just what each PRECISE component 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, choose between transport layers, 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, stdio vs. SSE transport trade-offs, writing tool descriptions that Claude can reliably use, 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 know the CALM framework — and the easiest to lose if you don't. Study this domain last but never skip it.
High-priority topics: the CALM framework for context-aware LLM management, prompt caching with cache_control breakpoints, 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. Immediately terminate all remaining subagents and return a top-level error to the user
- B. Ignore the failed subagent and silently return results from the three successful ones
- C. Surface the partial failure to the user, return results from successful subagents, and request clarification before retrying
- D. Automatically retry the failed subagent with elevated permissions to resolve the error autonomously
Correct answer: C. The minimal-footprint and human-in-the-loop principles require that permission errors be surfaced to the user rather than resolved autonomously. Escalating permissions (D) violates minimal-footprint — the agent should not acquire capabilities it wasn't explicitly granted. Silently returning incomplete results (B) is deceptive. Terminating everything (A) is unnecessarily destructive when three-quarters of the task succeeded.
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 follows the PRECISE framework with a clear Persona, detailed Instructions, and rich Context. Despite this, Claude's responses vary noticeably in tone and length across sessions. A review of the prompt reveals there is no Examples section. 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. The Examples component of PRECISE functions as a behavioural anchor — it shows Claude precisely what a correct response looks like in terms of length, tone, and structure. Without it, 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 the rest of the PRECISE structure is already in place.
Question 4 — Tool Design & MCP
You are building an MCP server that needs to stream large file contents to Claude in real time during a long-running analysis task running in a cloud environment. Which transport layer should you choose?
- A. stdio — lower latency for subprocess communication on the same machine
- B. SSE (Server-Sent Events) — supports real-time streaming over HTTP and works across network boundaries
- C. WebSocket — provides full bidirectional streaming unavailable in SSE
- D. stdio — simpler to implement and avoids the overhead of running an HTTP server
Correct answer: B. SSE is the MCP transport designed for remote servers and real-time streaming over HTTP. It works across network boundaries, making it the only valid choice for a cloud deployment. stdio (A and D) is limited to local subprocess communication on the same machine — it cannot cross a network boundary. WebSocket (C) is not a supported MCP transport layer. Whenever the deployment is remote or distributed, SSE is the correct answer.
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 CALM strategy 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 75% passing threshold 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 are typically available immediately after you submit the exam. 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.
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? Our platform offers 300 scenario-based practice questions across all five domains, with full explanations and a domain-weighted score breakdown after every session. Start with the practice question bank, or go straight into the full 60-question timed simulation.