CCA Exam Prep: Complete Study Guide

The Claude Certified Architect (CCA) Foundations exam is the first official certification from Anthropic. It validates that you can design, build, and deploy production systems with Claude — not just prompt it, but architect around it. Passing opens the Anthropic Partner Network, signals expertise to employers and clients, and proves you understand Claude at a level most developers never reach.

We built a complete 24-lesson CCA prep course at Like One after studying every domain, every question type, and every concept the exam tests. This guide distills that preparation into a study plan you can execute in days, not weeks. If you already work with Claude daily — through Claude Code, the Claude API, or MCP integrations — you are closer to passing than you think.

What Is the CCA Exam?

The Claude Certified Architect Foundations exam tests your ability to design and implement AI systems using Claude. It is not a trivia quiz about Anthropic's history or a multiple-choice test you can pass by memorizing documentation. The exam evaluates architectural thinking: given a real-world scenario, can you choose the right model, design the right system, and avoid the pitfalls that break production deployments?

Key exam details:

• Cost: $99 per attempt
• Format: Multiple choice and scenario-based questions
• Passing score: 720 out of 1000
• Domains: 5 knowledge domains weighted by importance
• Time limit: 90 minutes
• Proctoring: Online, on-demand
• Validity: Opens Anthropic Partner Network membership

The 720/1000 passing threshold means you need to get roughly 72% of questions right, but the scoring is weighted — harder questions in high-weight domains count more. You do not need to ace every section. You need solid coverage across all five domains with strength in at least two.

The Five CCA Domains

The exam covers five domains. Each maps to a category of architectural decisions you make when building with Claude. Understanding the weight distribution tells you where to focus your study time.

Domain 1: Agentic Architecture (25%)

This is the highest-weighted domain. It tests your ability to design AI agent systems — not toy demos, but production architectures that handle real-world complexity.

What you need to know:

• Agentic loop design. How to structure the observe-think-act cycle. When to use single-agent vs. multi-agent topologies. How to prevent infinite loops and implement circuit breakers. We cover this extensively in our guide on agentic loops.
• Multi-agent patterns. Orchestrator-worker, pipeline, debate, and hierarchical topologies. When each pattern is appropriate. How agents communicate and share state.
• Session management. How to persist state across turns and sessions. Conversation window strategies. The tradeoffs between stateless API calls and stateful agent sessions.
• Orchestration. How to coordinate multiple Claude instances. Task decomposition strategies. Error propagation and recovery in multi-agent systems.
• Human-in-the-loop. When to escalate to humans. How to design approval workflows. The spectrum from fully autonomous to fully supervised.

Study tip: the exam loves scenario questions in this domain. You will get a business problem and need to choose the right agent topology. Practice thinking through tradeoffs — a pipeline is simpler but slower; an orchestrator is flexible but complex. The Agent SDK guide covers these patterns in production context.

Domain 2: Configuration and Model Selection (15%)

This domain tests whether you understand the Claude model family and how to configure it for different tasks.

• Model selection. When to use Opus vs. Sonnet vs. Haiku. Cost, latency, and capability tradeoffs. Fallback strategies when your primary model is unavailable. See our model comparison for the decision framework.
• Parameter tuning. Temperature, max tokens, top-p, and top-k. What each parameter actually controls and when to adjust them. Common mistakes like setting temperature too high for code generation or too low for creative tasks.
• Extended thinking. When to enable thinking mode. How budget_tokens affects output quality. The cost implications of extended thinking on latency and token usage.
• Prompt caching. How caching works technically. The 5-minute TTL. How to structure prompts for maximum cache hit rates. Cost savings calculations.
• Batches API. When batch processing is appropriate. Latency tradeoffs. Cost savings vs. real-time API calls.

Study tip: memorize the model pricing and capability tiers. The exam will present cost optimization scenarios where choosing the wrong model wastes money or sacrifices quality. Know the exact cost ratios between Haiku, Sonnet, and Opus.

Domain 3: Prompt Engineering (20%)

Prompt engineering for the CCA is not about clever tricks. It is about systematic design of instructions that produce reliable, consistent outputs at scale.

• System prompt architecture. How to structure system prompts with identity, rules, and context sections. How system prompts interact with user messages. When to use system prompts vs. conversation prefilling. Our custom instructions guide covers the CLAUDE.md approach.
• Output formatting. XML tags, JSON mode, structured outputs. How to constrain Claude's output format reliably. Validation strategies for structured responses.
• Few-shot examples. When to use few-shot vs. zero-shot. How many examples are enough. How to select representative examples that cover edge cases.
• Chain-of-thought. When to request explicit reasoning. How chain-of-thought improves accuracy on complex tasks. The cost tradeoff of longer outputs.
• Prompt injection defense. How prompt injection attacks work. Input validation strategies. System prompt hardening. The difference between direct and indirect injection.

Study tip: the exam tests defensive prompt engineering heavily. Expect questions about handling adversarial inputs, preventing jailbreaks, and designing prompts that fail safely when given unexpected input.

Domain 4: Tools and MCP Integration (25%)

Tied with Agentic Architecture for the highest weight. This domain tests your ability to extend Claude's capabilities through tools and the Model Context Protocol.

• Tool definition. JSON Schema for tool inputs. How to write tool descriptions that Claude uses correctly. Common mistakes in tool design that cause Claude to call tools incorrectly or not at all. Read our MCP server tutorial for hands-on practice.
• Tool use patterns. The tool use loop (request → tool_use → tool_result → response). Parallel tool calls. Error handling when tools fail. How to design idempotent tools.
• MCP architecture. The client-server model. Transport layers (stdio, HTTP SSE). Resource and prompt primitives. How MCP differs from direct tool use. Our MCP deep dive covers the full protocol.
• MCP server design. How to build servers that expose tools, resources, and prompts. Security considerations. Authentication patterns. The best MCP servers for common integrations.
• Security. Tool input validation. Preventing command injection through tools. Sandboxing tool execution. Least-privilege tool design. This is a critical area — the exam tests security awareness heavily.

Study tip: know the MCP specification well. Understand the difference between tools, resources, and prompts in MCP. Practice designing tool schemas — the exam will show you a tool definition and ask you to identify issues.

Domain 5: Context Management and Reliability (15%)

This domain tests your ability to build Claude systems that are reliable, maintainable, and cost-effective in production.

• Context window management. How to handle conversations that exceed the context window. Summarization strategies. Sliding windows. Persistent memory architectures that let Claude remember across sessions.
• RAG (Retrieval-Augmented Generation). When to use RAG vs. fine-tuning vs. larger context windows. Chunking strategies. Embedding model selection. Reranking for quality.
• Evaluation and testing. How to measure Claude's output quality. Automated evaluation pipelines. Regression testing for prompt changes. A/B testing system prompts.
• Error handling. Graceful degradation. Retry strategies. Fallback models. Circuit breakers for API failures.
• Observability. Logging and monitoring for Claude-powered systems. Token usage tracking. Latency monitoring. Anomaly detection in model outputs.

Study tip: this domain rewards practical experience. If you have built and operated a Claude system in production, you already know most of this. If you have not, focus on the patterns for handling failure — the exam loves questions about what happens when things go wrong.

Study Plan: Two Weeks to Passing

This study plan assumes you already use Claude regularly. If you are starting from zero, add a week for foundational concepts.

Week 1: Concepts and Architecture

Days 1-2: Agentic Architecture. Study agent loop design, multi-agent topologies, and session management. Build a simple two-agent system with the Agent SDK. Focus on understanding when each topology is appropriate — the exam tests judgment, not just knowledge.

Days 3-4: Tools and MCP. Build an MCP server from scratch. Define custom tools with proper JSON schemas. Practice the tool use loop until it is second nature. Read the MCP specification and understand the transport layer.

Days 5-7: Prompt Engineering and Configuration. Study system prompt architecture, output formatting, and defensive techniques. Memorize model pricing and capabilities. Practice writing prompts that produce consistent, structured output.

Week 2: Practice and Refinement

Days 8-9: Context and Reliability. Study RAG patterns, context window management, and error handling strategies. Review production architecture patterns — logging, monitoring, circuit breakers.

Days 10-11: Practice exams. Take full-length practice tests under timed conditions. Our CCA prep course includes a 30-question practice exam with detailed answer explanations. Review every wrong answer and understand why the correct answer is better.

Days 12-14: Weak area focus. Review your practice exam results. Spend these days exclusively on domains where you scored lowest. Do not waste time reinforcing areas you already know well.

Exam Strategy: How to Answer CCA Questions

The CCA exam uses scenario-based questions that test architectural judgment. Most questions follow this pattern: here is a business problem with constraints, which approach is best?

The Elimination Method

For every question, eliminate answers that violate these principles:

1. Security first. Any answer that introduces a security vulnerability — command injection, unvalidated tool inputs, exposed API keys — is wrong. The exam always favors the secure option.
2. Simplicity wins. If two approaches solve the problem and one is simpler, the simpler one is correct. The exam penalizes over-engineering. A single agent with the right tools beats a complex multi-agent system for straightforward tasks.
3. Cost awareness. Answers that waste tokens or use expensive models for simple tasks are wrong. The exam expects you to optimize cost without sacrificing quality.
4. Production readiness. Answers that work in demos but fail at scale are wrong. The exam tests for error handling, retry logic, and graceful degradation.

Common Traps

• The over-engineering trap. A question describes a simple task and offers a complex multi-agent solution alongside a simple single-agent one. The complex solution sounds impressive but is wrong — the exam rewards choosing the simplest architecture that meets the requirements.
• The missing security trap. An answer looks correct for the business logic but does not validate tool inputs or sanitize user content. Security omissions make answers wrong even when the architecture is sound.
• The cost trap. An answer uses Opus for a task that Haiku handles perfectly. The exam expects you to know when cheaper models are sufficient.
• The assumed validation trap. An answer skips testing or monitoring. Production systems need observability — answers that deploy without verification are wrong.

Key Concepts to Memorize

Some CCA content requires memorization. Here are the facts you should know cold:

Model Pricing (per million tokens)

• Haiku 4.5: $0.80 input / $4.00 output
• Sonnet 4.6: $3.00 input / $15.00 output
• Opus 4.6: $15.00 input / $75.00 output
• Prompt caching: 90% reduction on cached input tokens
• Batches API: 50% reduction on all tokens

Context Windows

• All current Claude models: 200K token context window
• Opus 4.6 extended: 1M token context window available
• Max output tokens: varies by model (check current docs)

MCP Protocol

• Three primitives: tools, resources, prompts
• Transport: stdio (local), HTTP SSE (remote)
• Client-server architecture: host application runs client, integrations expose servers
• Security: servers should validate all inputs, implement least-privilege access

Tool Use

• Tool inputs defined with JSON Schema
• Claude can call multiple tools in parallel
• tool_use stop reason indicates Claude wants to call a tool
• tool_result must reference the tool_use_id
• Always validate tool inputs before execution (prevent injection)

Why the CCA Matters

Beyond the credential itself, preparing for the CCA forces you to systematize knowledge that most developers hold loosely. You might know that Haiku is cheaper, but can you calculate the exact cost difference for a specific workload? You might use MCP servers, but can you design one that handles authentication and error cases correctly?

The certification opens the Anthropic Partner Network, which provides early access to new features, direct support channels, and visibility in Anthropic's partner directory. For consultants and agencies building Claude solutions for clients, the CCA is a differentiator that justifies premium rates.

For job seekers, the CCA signals practical expertise that interview questions cannot fully assess. It tells employers you can architect with Claude, not just prompt it. As AI becomes core infrastructure in every company, this distinction matters more with each passing month.

Resources for CCA Preparation

Structured preparation beats random study. Here are the resources ranked by impact:

1. Like One CCA Exam Prep Course — 24 lessons covering all 5 domains with practice questions, answer explanations, and exam strategies. Lessons 1-3 are free. Built by practitioners who use Claude in production daily.
2. Anthropic's official documentation — The primary source for API details, model specifications, and MCP protocol. Read the tool use and prompt caching sections especially carefully.
3. Build something. The CCA tests applied knowledge. Build an MCP server, create a multi-agent system, implement RAG with Claude. Hands-on experience converts theory into intuition that the exam rewards.
4. Our blog — Guides on agentic loops, MCP servers, persistent memory, and the Agent SDK cover exam topics in production depth.

Ready to Get Certified?

Our CCA Exam Prep course covers all 5 domains with 24 hands-on lessons and a full practice exam. Need personalized preparation? Book a consulting session and we will build a study plan tailored to your experience level.

The CCA is new, which means early certified architects have a first-mover advantage. The partner network is small, the credential is rare, and the market for Claude expertise is growing faster than the supply of qualified architects. Pass the exam now and you are positioned at the front of a wave that every enterprise technology organization is about to ride.