CCA-F Exam Day: What to Expect, Real Experiences, and How to Pass First Try
What is it actually like to sit the Anthropic Claude CCA-F exam? Real exam-taker experiences, the hardest questions candidates face, what surprised them most, and the strategies that made the difference between passing and failing.
The Claude Certified Architect – Foundations (CCA-F) launched on March 12, 2026, and within 72 hours Reddit's r/ClaudeAI was flooded with passing-score screenshots. One candidate posted 985/1000. Others posted 720 — just enough to pass — after a second attempt. A few posted nothing at all.
That spread tells you something important: this is not a tutorial-grind certification. The CCA-F tests whether you can make real engineering decisions under time pressure, anchored to production scenarios, without Claude to help you. It is the hardest AI certification on the market right now, and the community is still figuring out the best way to prepare for it.
This post collects what candidates have shared about exam day — the scenarios that surprised them, the domains that cost the most points, and the preparation habits that separated passes from retakes. If you are scheduled to sit the CCA-F, or deciding whether to register, read this first.
What the CCA-F Is Actually Testing You On
Before anything else, calibrate your expectations. The CCA-F is not a memorization exam. You will not be asked to recite API parameter names or quote documentation. Every question is rooted in a production scenario — a real-ish engineering situation — and asks you to choose the most appropriate architectural decision from four plausible options.
Here is what the exam looks like in numbers:
- 60 questions across five domains
- 120 minutes to complete — exactly 2 minutes per question on average
- Passing score: 720/1000 (scaled scoring, ~72%)
- 6 production scenario contexts, of which 4 are randomly assigned to your exam
- $99 registration fee (free for the first 5,000 Claude Partner Network employees)
- Closed-book, no AI assistance permitted — you cannot ask Claude anything
- Score report delivered within 2 business days with a per-domain breakdown
The five domains and their approximate weights are:
| Domain | Weight | Core Focus |
|---|---|---|
| D1: Agentic Architecture & Orchestration | ~27% | Agent SDK loops, multi-agent patterns, hooks, session management |
| D3: Claude Code Configuration | ~20% | CLAUDE.md hierarchy, custom commands, Plan Mode, CI/CD integration |
| D4: Prompt Engineering & Structured Output | ~20% | Explicit criteria, few-shot examples, tool_choice modes, JSON schema output |
| D2: Tool Design & MCP | ~18% | Tool descriptions, error responses, MCP server architecture and integration |
| D5: Context Management & Reliability | ~15% | Information preservation, escalation patterns, error propagation, caching |
The thing that catches candidates off guard is this: over 45% of the exam is concentrated in Domains 1 and 3 — agentic architecture and Claude Code configuration. If you prepared mostly from API reference docs and prompt engineering tutorials, you walked into the wrong exam.
The 6 Scenarios You Might Get (and How to Approach Each)
Each of the 60 questions belongs to one of four scenario contexts randomly assigned to your exam. You will not know which four you get until the exam begins. Knowing all six cold is the only safe approach. Here is what each scenario tests — and what trips candidates up.
Scenario 1: Customer Support Resolution Agent
What it tests: Tool design for escalation, error handling strategies, first-contact resolution patterns, and the mechanics of a support loop that knows when to hand off to a human.
What trips people up: The temptation to use sentiment analysis or Claude's self-assessed confidence as the escalation trigger. The exam consistently rewards programmatic enforcement of escalation criteria over instructions that ask Claude to decide for itself when it is uncertain. If a question presents four escalation options and one of them is "tell Claude to escalate when it is not confident," that is almost certainly the wrong answer.
Scenario 2: Code Generation with Claude Code
What it tests: CLAUDE.md file hierarchy, custom slash commands, Plan Mode versus direct execution, CI/CD pipeline integration with the -p (non-interactive) flag, and iterative refinement workflows.
What trips people up: The configuration hierarchy is surprisingly specific. A setting in a project-level CLAUDE.md behaves differently from one in the user-level CLAUDE.md, which behaves differently from an environment variable. The exam loves to give you a scenario where two settings conflict and ask which one wins. If you have not explicitly mapped the precedence order, you will be guessing.
Scenario 3: Multi-Agent Research System
What it tests: Hub-and-spoke orchestration, subagent delegation, context passing between agents, provenance tracking, and when the orchestrator should decide versus when it should delegate the decision to a subagent.
What trips people up: The boundary between orchestrator responsibility and subagent autonomy. Questions in this scenario often present four variations of a multi-agent architecture and ask which one avoids a specific failure mode — like context loss on handoff or hallucinated citations in research summaries. Candidates who understand the pattern abstractly but have not thought through failure modes tend to pick architectures that look clean but break under edge conditions.
Scenario 4: Developer Productivity Tools
What it tests: Session management, memory persistence, MCP server distribution, codebase exploration patterns, and how to configure Claude Code for team-wide developer workflows rather than individual use.
What trips people up: MCP server configuration details. This scenario often asks about the difference between a local MCP server (good for individual dev workflows) and a remote MCP server (good for team distribution), and the security implications of each. Candidates who have not configured MCP servers in practice tend to confuse these.
Scenario 5: Enterprise Document Processing
What it tests: Structured output with JSON schemas, Batch API cost optimization, multi-pass extraction patterns, retry logic on validation failure, and the trade-offs between parsing structured versus unstructured output.
What trips people up: The exam draws a sharp line between asking Claude to return JSON (prompt-based, unreliable) and using the structured output beta with a schema (guaranteed valid JSON). Candidates who treat these as equivalent lose easy points. Also commonly missed: when the Batch API actually saves money versus when synchronous calls are better.
Scenario 6: Regulatory Compliance Agent
What it tests: Human-in-the-loop design, audit trail requirements, validation patterns before irreversible actions, and the architectural choices that make an AI system defensible in regulated environments.
What trips people up: This scenario tends to present questions where the "AI-confident" answer (let Claude proceed autonomously with high reliability) conflicts with the "compliance-aware" answer (always get human sign-off before certain actions). The exam rewards the latter. Any option that reduces human oversight of high-stakes decisions is usually a distractor.
Real Exam-Taker Experiences
The following profiles reflect common patterns reported by the CCA-F candidate community. Names are illustrative; they represent composite experiences shared in public forums and study groups.
"Passed with 840/1000 — but Domain 2 humbled me"
Solutions architect, 6 months building with Claude APIs
"I felt reasonably prepared going in. I had built two production Claude integrations at my company, I understood the Agent SDK, and I had gone through the official exam guide twice. What I was not ready for was how specific Domain 2 gets about MCP error handling. There were questions about error classifications — retriable versus non-retriable — where I genuinely did not know if a network timeout should be retried immediately, after a backoff, or surfaced to the user. I guessed on at least three of those. My domain breakdown confirmed it: Agentic Architecture was my strongest area (86%), and Tool Design & MCP was my weakest (71%). If I were doing it again, I would spend a full week just on MCP server patterns and error response design before I touched anything else."
"Failed first attempt (698), passed second (776) — here's what changed"
Backend developer, building with Claude for 3 months
"My first attempt, I treated Domain 3 — Claude Code configuration — like a light topic. I figured I use Claude Code every day, how hard can the configuration questions be? The answer: very hard. The exam asks about the configuration hierarchy in ways that are not obvious from casual use. For example, I knew that a project CLAUDE.md overrides certain defaults. I did not know the exact precedence when a user-level CLAUDE.md and a project-level CLAUDE.md both define conflicting settings for the same command. I failed by 22 points, and my breakdown showed Domain 3 as the problem. Between attempts, I did something I should have done first: I set up a test project and deliberately created conflicting configurations at every level of the hierarchy to observe what actually wins. That hands-on mapping is what got me over the line the second time."
"Passed in 3 weeks of part-time study — with zero prior Claude experience"
Tech lead, strong AWS background, new to Claude
"I came from an AWS architecture background, so the systems design mindset was already there — I just needed to learn the Claude-specific layer. My strategy was domain-first: I spent one week per domain in order of weight, starting with Agentic Architecture. For each domain, I read the official documentation, then immediately built a tiny proof-of-concept implementing what I had just read. The hands-on step is what made concepts stick. For MCP, I actually stood up a local MCP server with intentional error conditions and watched how the client behaved. For Claude Code configuration, I mapped every level of the CLAUDE.md hierarchy manually. The exam still had surprises — the scenario-based format is harder than any practice question I had seen — but I was not encountering concepts cold. I scored 803, which I am happy with for a first attempt with no prior experience."
"The questions are harder than any practice test I found"
Senior software engineer, daily Claude user for over a year
"I want to be honest about something that I wish I had known: the quality of the distractors. In every practice test I took before the exam, the wrong answers were identifiable because they were clearly wrong — either technically incorrect or obviously suboptimal. On the actual exam, all four options are plausible. They represent the kinds of decisions that experienced engineers actually debate. I would read a question, eliminate two options immediately, and then sit staring at the remaining two for a full minute before committing. That pace is not sustainable across 60 questions. I finished with 4 minutes to spare, which was too close for comfort. The time pressure is real. Practice specifically for the scenario format — not just the content — before you sit."
The Hardest Questions Candidates Face
Based on community feedback and per-domain score distributions, here are the question types that consistently cost candidates the most points — along with the common wrong answer and why it is tempting.
Domain 1: Orchestrator versus Subagent Decision Authority
The hard question type:
A scenario describes a multi-agent pipeline where one of the subagents encounters an ambiguous input mid-task. The question asks: should the subagent resolve the ambiguity autonomously, surface it to the orchestrator, or halt execution entirely?
Common wrong answer: Let the subagent resolve it autonomously, since that is what delegation is for and it keeps the pipeline moving.
Why it is tempting: Subagent autonomy sounds like good architecture. The whole point of delegation is that subagents handle things independently.
Why it is wrong: The exam consistently rewards escalation for ambiguity in production systems. Subagents resolving ambiguity autonomously introduce silent errors that compound downstream. The correct architecture surfaces ambiguity upward rather than resolving it with a local guess — especially when the resolution affects subsequent pipeline steps.
Domain 2: MCP Error Classification
The hard question type:
An MCP tool returns an error. The question describes the specific error condition (network timeout, rate limit, invalid schema, authentication failure) and asks which error handling strategy is appropriate.
Common wrong answer: Immediately retry the call, since transient errors usually resolve on retry.
Why it is tempting: Retrying on failure is the default pattern most engineers learn first.
Why it is wrong: Not all errors are retriable. Authentication failures and invalid schema errors are non-retriable — retrying will reproduce the same error. Rate limit errors are retriable but only after a backoff delay. Network timeouts may be retriable immediately or may indicate a larger infrastructure problem. The exam tests whether you can classify errors correctly before choosing a strategy. "Always retry" is the answer that fails on authentication and schema errors.
Domain 3: Configuration Hierarchy Precedence
The hard question type:
A developer has a setting defined at the user level in their global CLAUDE.md. A project-level CLAUDE.md in the same repository defines a conflicting value for the same setting. A CI/CD environment variable also sets a value. Which one wins?
Common wrong answer: The user-level setting, because it is the user's explicit preference.
Why it is tempting: User-defined settings feel like they should be authoritative — they represent intentional configuration choices.
Why it is wrong: The hierarchy is explicit and does not privilege user settings: environment variables take highest precedence, then project-level CLAUDE.md, then user-level CLAUDE.md. This is by design — it allows projects and CI environments to override developer defaults for consistency. Candidates who rely on intuition rather than the documented hierarchy get this wrong.
Domain 4: tool_choice="any" versus tool_choice="auto"
The hard question type:
A scenario describes a situation where the system must guarantee that Claude calls a tool on every turn, but should be free to choose which tool to call from a set of options. Which tool_choice value is correct?
Common wrong answer: tool_choice="auto", because that lets Claude choose from the available tools.
Why it is tempting: "Auto" sounds like "Claude decides automatically" — which matches "Claude is free to choose which tool."
Why it is wrong: auto allows Claude to respond with text instead of calling a tool at all. any forces Claude to call at least one tool but leaves the selection open. The distinction is critical when a tool call is mandatory on every turn — a requirement that auto cannot guarantee. If you conflate "Claude selects the tool" with "Claude must use a tool," you will choose auto in every scenario where any is correct.
Domain 5: When Prompt Caching Helps versus When It Does Not
The hard question type:
A system makes repeated API calls where each request includes a long system prompt and a short, unique user message. The question asks whether adding a cache_control breakpoint to the system prompt will reduce costs and latency for this workload.
Common wrong answer: No, because caching adds overhead that offsets the benefit for short conversations.
Why it is tempting: Caching feels like an optimization that only makes sense for very large context windows.
Why it is wrong: This is exactly the scenario prompt caching is designed for: a stable, repeated prefix (the system prompt) combined with variable suffixes (the user messages). Caching the system prompt means only the user message tokens are processed on cache hits, which delivers significant cost and latency savings at scale. Candidates who have not worked through the caching economics confuse "caching is for long contexts" with "caching is for this exact pattern."
Time Management Strategy
120 minutes for 60 questions is exactly 2 minutes per question. That sounds adequate until you are 20 minutes in, you are on question 8, and you just spent 4 minutes on a scenario question that required re-reading the context twice.
Candidates who pass consistently report the same approach:
Phase 1: First pass (60 minutes)
Read each question once. If you can answer it in under 90 seconds with high confidence, answer it and move on. If you are uncertain, mark it for review and move on immediately. Do not debate yourself on marked questions during the first pass. The goal is to bank all your confident answers and surface your uncertainty accurately.
Phase 2: Second pass (45 minutes)
Return to every marked question. Now that you have seen all the questions in your assigned scenarios, you often have better context for the ones you flagged. Scenario-based questions sometimes contain subtle clues that only become visible after you have read the full context. Use this pass to resolve your marked questions with better information.
Phase 3: Buffer (15 minutes)
Keep a 15-minute buffer at the end. Do not use it unless you finish your second pass early. If you do finish early, use it to revisit any questions where you made a forced guess.
Reading strategy for scenario contexts
Each scenario comes with a context paragraph describing the system being built. A common mistake is skipping the context and going straight to the question. Resist this. Spend 30 seconds on the context before reading the question — it will tell you which architectural constraints apply and often eliminates two of the four answer options before you have read a single word of the question itself.
Key time management rule:
Never spend more than 3 minutes on any single question during your first pass. If you hit 3 minutes, make your best guess, mark it, and move on. Running out of time on the first pass is a more common failure mode than answering individual questions incorrectly.
The Week Before the Exam
This schedule is based on what candidates with busy schedules have found works. It assumes you have already done your primary study — this is the refinement phase, not the learning phase.
Days 7–5: Target your weak domains
Pull out your domain breakdown from any practice exams you have taken. Identify your two lowest-scoring domains and focus all your study time on those — not your strong domains. If your Domain 2 (MCP) is at 68% on practice tests, spend these three days only on MCP tool design, error handling classification, and MCP server architecture. Do not touch the domains you already know.
Days 4–3: Full timed practice exams
Two full-length, timed practice exams on back-to-back days. Do not pause. Do not look anything up mid-exam. Treat them exactly like the real thing. The goal is not just to check your content knowledge — it is to train your pace and build the focus required to maintain attention across 60 scenario-based questions without breaking concentration.
Day 2: Wrong answers only
Go through every question you got wrong across both practice exams. For each one: why did you pick the wrong answer, what made it tempting, and what is the principle that makes the correct answer right? Build a one-page cheat sheet of the patterns behind your most common mistakes. This document will be worth more on exam day than any summary guide.
Day 1: Light review and cheat sheet only
No new content. No practice exams. Review only the one-page cheat sheet you built from your wrong answers. Cap your study time at 45 minutes. Anything more will increase anxiety without improving performance. Confirm your exam setup: check that your computer meets the proctoring requirements, test your camera and microphone, and decide where you will sit.
Exam morning
- Eat a normal breakfast. Low blood sugar impairs decision-making — relevant for an exam that is entirely about decisions.
- Start at least 15 minutes before your scheduled time to resolve any proctoring setup issues. Technical problems that eat into exam time are a known stress multiplier.
- Clear your desk. The proctored environment requires a clean workspace. Set this up the night before, not five minutes before start.
- Block 2.5 hours in your calendar — 2 hours for the exam, 30 minutes buffer for setup and unexpected delays.
- Do not open Claude, documentation, or any reference material. Closed-book means closed-book, and the proctoring software is watching.
What Candidates Wish They Had Studied More
Based on post-exam community discussions, here are the topics that candidates most consistently underestimated:
| Topic | Domain | What to Know |
|---|---|---|
| MCP server configuration details | D2 | Local vs remote MCP server trade-offs, credential handling, tool boundary scoping |
| PostToolUse hooks and when they fire | D3 | Hook lifecycle, execution order, what triggers PostToolUse vs PreToolUse, side-effect timing |
| Exact stop_reason values | D1 | When each stop_reason appears (end_turn, tool_use, max_tokens, stop_sequence) and the correct handler for each |
| Context window math and caching economics | D5 | When caching saves money, minimum token thresholds for cache utility, stale cache invalidation |
| CLAUDE.md configuration hierarchy | D3 | Full precedence order: env variables > project CLAUDE.md > user CLAUDE.md, and override behavior |
| Batch API vs synchronous API trade-offs | D5 | Cost structure, when batch is cheaper, latency implications, workload patterns where sync is better |
| Anti-patterns in structured output | D4 | Why regex parsing of unstructured output fails, when to use the structured output beta vs prompt-level JSON instruction |
The common thread across all of these: they are not conceptual topics you can absorb from a summary article. They require you to have worked with the actual APIs, configuration files, and tooling. Candidates who had built real Claude integrations before attempting the exam outperformed candidates who had only studied. The exam is designed that way deliberately.
Benchmark before you book:
The community recommendation for when you are ready to sit the exam: score consistently above 900/1000 on the official practice exam. If you are at 820–880, you will likely pass, but with less margin than you want. If you are below 800, more preparation will save you the $99 retake fee.
Start Your Prep on CertLand
CertLand's CCA-F practice exam contains 606 scenario-based questions mapped to the official domain weights — the largest question bank available for this certification. Every question includes a detailed explanation covering why the correct answer is right and why each distractor is wrong.
A few things that make CertLand's question bank different from what you find elsewhere:
- Questions are anchored to the same six production scenario contexts used on the real exam
- Distractors are engineered to be genuinely tempting — not obviously wrong — so you build real pattern recognition rather than just eliminating bad options
- Domain-level tracking shows you exactly which domains need more work before you book your exam date
- Explanations are written at the engineering level — they explain the principle behind the correct answer, not just which option to pick
Ready to start practicing?
Your first 10 questions are free — no account required.
Start the Free CCA-F Practice Exam606 questions · All 6 scenario contexts · Full domain breakdowns
The CCA-F is hard by design. Anthropic built it to mean something — to distinguish engineers who have internalized how to build with Claude from those who have only read about it. If you have been building real Claude integrations in production, the certification is within reach with structured preparation. If you have not, use the prep process itself as the forcing function to build that experience.
The community consensus from people who have sat the exam: there is no shortcut, but there is a path. Understand the architecture deeply, work through the failure modes, practice under time pressure, and trust the preparation when you are in the room.
Good luck. The badge is worth it.
Comments
No comments yet. Be the first!
Comments are reviewed before publication.