CCA-F Practice Questions 2026: Domain-by-Domain Strategy, Scenarios, and Sample Question Styles

CCA-F Practice Questions 2026: A Blueprint-Deep-Dive Strategy

Last updated: July 3, 2026. Verified against the official Anthropic Skilljar CCA-F certification page, the Anthropic Claude Partner Network announcements, and the published exam blueprint.

The Claude Certified Architect – Foundations (CCA-F) is Anthropic's first technical certification, and most prep advice stops at "read the docs and build something." That is not enough. The CCA-F is a 60-question, 120-minute scenario-based exam with a published five-domain blueprint and a pool of six production scenarios that the questions hang on. You do not pass it by knowing Claude features — you pass it by rehearsing architectural trade-offs inside the exact domains and scenarios the exam scores.

free CCA-F practice questionsPractice questions with detailed explanations

The CCA-F Blueprint at a Glance

The official Anthropic Skilljar CCA-F page states the exam "tests foundational knowledge across Claude Code, the Claude Agent SDK, the Claude API, and Model Context Protocol (MCP)" and "validates that practitioners can make informed decisions about tradeoffs when implementing real-world solutions with Claude." The blueprint organizes that into five domains with fixed weights:

Two takeaways for practice planning. First, domains 1, 2, and 3 alone are 67% of the exam — if you are short on time, weight your practice hours there. Second, domain 5 is the smallest at 15%, but its concepts (context window, caching, evals, retries) recur inside every other domain's scenarios. Skip nothing; just sequence it.

The exam is 60 multiple-choice questions in 120 minutes, pass at 720 on a 100–1000 scaled score, closed-book and online-proctored. There is no penalty for guessing — unanswered items are scored as incorrect, so you answer every question.

The Six Production Scenarios You Must Rehearse

CCA-F questions are not free-floating. Each exam draws four of six production scenarios at random, and roughly 15 questions cluster around each scenario. A single business context drives a quarter of your exam. The six scenarios, drawn from the published blueprint, are:

Because scenario selection is random, you must rehearse all six. The smartest move is to build a small working version of at least three scenarios before exam day — for example, a customer-support agent with an escalate_to_human tool, a multi-agent research coordinator with two subagents, and a CI/CD Claude Code run with the -p flag and --output-format json. Building beats reading for scenario questions, because the distractors are written to trap architects who have only read about a pattern.

What CCA-F Questions Actually Look Like

The questions are scenario-based, not vocabulary recall. The official Anthropic Claude Partner Network launch describes CCA-F as "a technical exam for solution architects building production applications with Claude." That framing shows up in the question stems. Across the six scenarios, seven question archetypes repeat:

• "Which is the BEST approach?" — all four options may be technically valid; one is the most production-ready. Tests trade-off judgment.
• "Which should you AVOID?" — three options are acceptable; one is an anti-pattern. Tests recognition of common failure modes.
• "What is the MOST LIKELY cause?" — debugging/diagnosis: a symptom is described, you map it to a root cause. Tests production debugging instinct.
• "What is the FIRST step?" — prioritization/sequencing. Tests whether you sequence work like a shipping architect.
• "What is the PRIMARY benefit?" — tests understanding of WHY an approach is preferred, not just that it works.
• "Which configuration is CORRECT?" — one factually right answer and three containing errors. Tests concrete config knowledge (CLAUDE.md, .mcp.json, settings.json).
• "What is the MAIN risk?" — risk identification by likelihood and impact. Tests reliability thinking.

A single cross-cutting tiebreaker runs through most of these: programmatic enforcement is preferred over prompt-based guidance. Prompts are suggestions; code is enforcement. When two answers both seem plausible, the one that enforces the behavior in code (a PostToolUse hook, a tool schema with validation, a permission gate) usually beats the one that relies on the prompt to ask Claude to behave. Internalize that heuristic before exam day.

Domain 1 Practice Strategy: Agentic Architecture & Orchestration (27%)

The heaviest domain and the one most candidates under-prepare. Practice questions here test the agentic loop, subagent delegation, orchestrator-worker and evaluator-optimizer patterns, parallelization, and model selection (Opus for hard reasoning, Sonnet for balanced throughput, Haiku for fast/cheap subtasks).

High-yield topics to drill:

• stop_reason and loop termination — knowing when the agent loop should exit vs. continue.
• Hub-and-spoke vs. single mega-prompt — when to split into subagents vs. keep one context.
• Subagent context isolation — what stays in the subagent's context vs. what returns to the orchestrator.
• Parallel task execution — when parallelization helps and when it breaks state consistency.
• Session management — --resume, fork_session, and how to make an agent feel stateful across turns.
• Model routing — which model for which subtask role, and the cost/latency trade-offs.

Sample question shape: "A coordinator agent delegates research to four subagents. Three return useful results; one returns an empty response. What is the BEST architectural response?" The wrong answers suggest ignoring the empty one, asking the user, or retrying all four. The right answer is a structured-error-handling pattern: the subagent returns a structured error, the coordinator decides retry vs. escalate based on isRetryable.

Domain 2 Practice Strategy: Claude Code Configuration & Workflows (20%)

This is the most concrete domain. Questions test CLAUDE.md hierarchy, settings.json, permissions and modes, slash commands, hooks, subagents, headless/CI usage, and MCP wiring inside Claude Code. The official Claude Code documentation is the source of truth for these details.

High-yield topics:

• CLAUDE.md hierarchy — user-level, project-level, directory-level; what each scope controls and the "team instructions trap" (user-level instructions are NOT shared with the team).
• Plan Mode vs. Direct Execution — when each is appropriate and how plan mode protects against unwanted side effects.
• Hooks — PostToolUse, PreToolUse, and what a hook can enforce that a prompt cannot.
• Slash commands — custom commands and how they encode reusable team workflows.
• Skills frontmatter — context: fork, allowed-tools, and what they gate.
• Rules files — .claude/rules/ with glob patterns for path-specific behavior.
• CI/CD integration — the -p flag, --output-format json, and headless non-interactive runs.

Sample question shape: "A team wants to ensure no PR is merged without a Claude Code review. Which configuration is CORRECT?" The right answer wires Claude Code into CI with the -p flag and --output-format json for machine-parseable output; distractors suggest relying on a developer's prompt or a CLAUDE.md instruction.

Domain 3 Practice Strategy: Prompt Engineering & Structured Output (20%)

Production prompting, not casual prompting. The recurring theme is reliability: getting machine-parseable output every time, not most of the time.

High-yield topics:

• Tool-based JSON schemas — using tool_use to enforce output structure instead of asking the model in prose. Schemas enforce syntax; they do not enforce semantics.
• Nullable fields and "unclear" enum values — designing schemas that handle edge cases gracefully instead of forcing a hallucinated answer.
• Validation-retry loops — when the output fails validation, retry with the error fed back, instead of accepting a bad parse.
• Few-shot examples — 2–4 optimal; more can drift.
• Extended thinking — when it helps (hard reasoning) and when it is wasted cost.
• Stop sequences — using them to control output boundaries.
• Batch API — 50% cost savings, 24-hour window, no SLA; never use it for blocking workflows.

Sample question shape: "An extraction pipeline gets unstructured invoices and must return a JSON object with vendor, total, and due_date. Some invoices are missing the due date. Which schema design is BEST?" The right answer makes due_date nullable and adds an "unclear" enum fallback; distractors suggest making the field required (forces hallucination) or omitting it (silent data loss).

Domain 4 Practice Strategy: Tool Design & MCP Integration (18%)

This domain rewards hands-on build experience. Questions test MCP primitives, transports, config files, tool scoping, and error handling. The Model Context Protocol specification is the authoritative reference.

High-yield topics:

• MCP primitives — tools, resources, and prompts; what each is for and when to use which.
• stdio vs. HTTP transports — stdio for local, HTTP for remote; the trade-offs.
• .mcp.json vs. ~/.claude.json — project-level vs. user-level MCP configuration.
• Tool count — 4–5 tools per agent is optimal; quality degrades above ~18.
• Tool descriptions as routing — the description is the primary routing mechanism; Claude picks tools based on descriptions.
• tool_choice configuration — auto, any, tool, or none.
• Least-privilege tool scoping — why you do NOT give Claude full database access; the architectural answer is scoping tools to the minimum needed.
• Structured error handling — isRetryable flags and how the agent decides retry vs. escalate.

The favorite "gotcha" archetype here: "Why would you NOT give Claude full access to your entire database?" The right answer is an architectural principle — least-privilege tool scoping reduces blast radius and keeps the agent from acting on unrelated data — not a security vocabulary word.

Domain 5 Practice Strategy: Context Management & Reliability (15%)

The smallest domain by weight, but its ideas bleed into every other domain's scenarios. Practice questions here test the context window, caching, retries, RAG, evals, guardrails, and latency/cost optimization under failure.

High-yield topics:

• "Lost-in-the-middle" effect — attention is not uniform across a long context; important instructions go at the start or end, not buried in the middle.
• Prompt caching — when it pays off (repeated long prefixes) and the cost trade-off.
• Escalation triggers — programmatic triggers (explicit human request, ambiguous policy, no progress) vs. sentiment or self-reported confidence. The exam tests the programmatic version.
• Context degradation strategies — scratchpad, subagent delegation, /compact.
• Crash recovery — manifest files and how to resume an interrupted agent run.
• Human review with stratified sampling — how to sample outputs for review without reviewing everything.
• Structured error propagation — silent empty results on failure are an anti-pattern; return structured errors instead.

Sample question shape: "A support agent's accuracy degrades after 20 turns. What is the MOST LIKELY cause and BEST fix?" The right answer identifies context-window degradation (lost-in-the-middle) and applies a strategy like /compact or subagent delegation; distractors suggest retraining or switching models.

High-Yield Topics Across the Whole Exam

Some concepts appear in multiple domains and scenarios. Prioritize these in your practice sets because each one can show up in several questions:

1. Programmatic enforcement over prompt-based guidance — the single most reliable tiebreaker.
2. Tool-based JSON schemas with nullable fields and validation-retry loops — appears in D3, D4, and scenarios 1 and 6.
3. Hub-and-spoke multi-agent architecture with context isolation — appears in D1 and scenarios 3 and 4.
4. CLAUDE.md hierarchy and the "team instructions trap" — appears in D2 and scenario 2.
5. CI/CD integration with -p and --output-format json — appears in D2 and scenario 5.
6. Least-privilege tool scoping — appears in D4 and scenario 1.
7. Lost-in-the-middle and context degradation strategies — appears in D5 and across scenarios.
8. Structured error handling with isRetryable — appears in D4, D1, and across scenarios.

If you can explain each of those eight concepts in 2–3 sentences and apply them to a scenario, you have covered the cross-cutting core of the exam.

How to Use Practice Questions Effectively

The mistake most candidates make is grinding questions without reviewing misses by cause. The CCA-F rewards understanding the architecture principle behind the right answer, not pattern-matching. Use this review loop:

1. Take a mixed set of 15–20 questions spanning all five domains.
2. For every miss, tag the cause: wrong domain knowledge, wrong scenario context, fell for a plausible distractor, or misread the stem.
3. Revisit the corresponding study-guide section or doc only where the miss log points.
4. Re-take the same set a week later and confirm the miss rate dropped.

A target readiness signal is ~75%+ across every domain on mixed practice, with no single domain below 70%. Because scoring is scaled (not raw percentage), treat 75% as your safety margin, not the pass line.

A Practice-Question Pacing Plan

With 60 questions in 120 minutes, you have ~2 minutes per question. Scenario questions are wordy, so rehearse pacing as part of practice, not just on exam day. A proven three-pass strategy:

• Pass 1 (90 minutes): answer every question you are confident on. Flag the rest.
• Pass 2 (25 minutes): return to flagged questions with fresh attention.
• Pass 3 (5 minutes): verify no blanks. Because there is no guessing penalty, every question has an answer.

Practice this rhythm on full-length timed sets, not just short drills. The CCA-F punishes slow readers; pacing is a skill you build, not a trait you have.

Best Next Step

free CCA-F practice questionsPractice questions with detailed explanations