Claude Certified Architect - Professional
Own the full lifecycle of secure, observable, production-grade Claude systems from discovery to iteration.
The official exam
- Questions
- 63
- Time
- 120 minutes
- Fee
- US$175
- Passing score
- 720 on a 100-1000 scale
- Valid for
- 12 months
- Format
- Multiple-choice and multiple-response
- Delivery
- Proctored online or at a test center
As published by Anthropic in exam guide 1.0 (July 2026); checked 9 August 2026. Read the official exam guide
Who it's for
Mid- to senior-level solution architects, AI engineers, technical leads, and senior software engineers responsible for end-to-end production systems and cross-functional decisions.
- Three or more years in systems architecture or platform engineering
- Six or more months operating Claude or comparable LLM systems in production
- Experience delivering systems from discovery through deployment and operations
- Ability to defend cost, latency, quality, safety, and maintainability tradeoffs
What the exam covers
- Solution Design and Architecture17%
- Claude Models, Prompting and Context Engineering13%
- Integration19%
- Evaluation, Testing and Optimization16%
- Governance, Safety and Risk Management14%
- Stakeholder Communication and Lifecycle Management14%
- Developer Productivity and Operational Enablement7%
Practice exams
Original questions in the official format, timed like the real thing, with a breakdown by exam domain and an explanation for every answer. Start with the diagnostic.
- Architect Professional Diagnostic14 questions, 30 minutesFree
- Architect Professional Full Mock63 questions, 120 minutes
Lessons
- 1Study the Decisions, Not the VocabularyA certification blueprint is a map of decisions a competent practitioner can defend. Treat it as a list of terms and you will study the least useful part of the exam.
- 2Business Discovery, Requirements, and SLAsThe first architecture decision is deciding what problem you are actually responsible for solving.
- 3End-to-End Architecture and Value TradeoffsArchitecture is the art of spending complexity only where it changes the outcome.
- 4Choose the Smallest Surface That Can Carry the WorkProduct selection is architecture at knowledge-work scale. The wrong surface can make correct output stale, unreviewable, or needlessly expensive.
- 5Spend Capability Where Failure Is ExpensiveModel selection is not a ranking exercise. It is an allocation problem across quality, latency, context, and cost.
- 6Turn a Request Into a Testable ContractA strong prompt does not merely describe what to write. It makes success observable before generation begins.
- 7Put Each Fact in the Right Kind of ContextContext is temporary attention. Knowledge is maintained evidence. Memory is continuity. Caching is reuse. Mixing them creates confident stale answers.
- 8Validate the Claim, Not the ConfidenceFluency is presentation quality. Validation is evidence that the output can safely do its job.
- 9Put Authority Around CapabilityA model can produce an answer without having permission to see the data, make the decision, or take the action.
- 10The Messages API Is a State MachineThe API does not remember your conversation. Your application does, and one misplaced content block can break the entire loop.
- 11Structured Output Is an Untrusted ContractValid JSON is not a valid business decision. Parse the bytes, validate the shape, verify the meaning, then permit the action.
- 12A Tool Loop Is Controlled DelegationClaude may propose an action. Your application validates the request, grants the capability, observes the result, and decides whether the loop continues.
- 13MCP Separates Capability From HostBuild a narrow, stateless MCP server whose contract can be discovered, cached, invoked, and scaled without hidden connection state.
- 14The Agent SDK Is a Harness, Not PermissionAn agent becomes dependable when the loop, tools, context, hooks, and termination policy are explicit enough to inspect and constrain.
- 15Security Lives Outside the PromptThe model can recommend a safe action. Only deterministic controls can make an unsafe action impossible.
- 16Evals Turn Agent Behavior Into Engineering EvidenceA trace tells you what happened. An eval tells you whether it was acceptable. A regression gate keeps the next change from quietly making it worse.
- 17Claude Code Scales Through Shared ConstraintsA team does not need one giant prompt. It needs a small project contract, reusable procedures, deterministic checks, and versioned configuration.
- 18Multi-Agent Orchestration and DelegationDelegate a bounded question, not your entire uncertainty.
- 19Tool Contracts, Errors, and Progressive DiscoveryThe model chooses from the interface you describe. Ambiguous tools create ambiguous behavior.
- 20RAG, Retrieval, and Data PipelinesA grounded answer is only as trustworthy as the evidence that reached the model.
- 21Integration Protocols, Identity, and Least PrivilegeA tool is not safe because Claude uses it carefully. It is safe when the system refuses unauthorized use.
- 22Production Observability, Latency, and CostA green API call can still be a failed task.
- 23Enterprise Governance, Compliance, and Human ReviewGovernance is the system that decides who may take which risk with whose data.
- 24Stakeholder Communication, ADRs, and Lifecycle OwnershipAn architecture is not delivered when the diagram is finished. It is delivered when the next owner can operate the decision.
- 25Architect Professional System CapstoneBuild the evidence packet that makes a production architecture defensible.
Study plans
- Days 1-5: discovery, requirements, product selection, and value tradeoffs
- Days 6-10: models, prompts, context, validation, and governance foundations
- Days 11-15: Messages API, structured output, tool loops, and MCP
- Days 16-20: Agent SDK, security, evaluation, Claude Code, and orchestration
- Days 21-25: tool contracts, RAG, identity, observability, and cost
- Days 26-30: enterprise governance, stakeholder lifecycle, and operations
- Days 31-35: capstone defense, full mock, and remediation
- Week 1: discovery, value, and product landscape
- Week 2: model, prompt, context, and validation foundations
- Week 3: API lifecycle and structured output
- Week 4: tool loops, MCP, Agent SDK, and security
- Week 5: evaluation, Claude Code, orchestration, and tool contracts
- Week 6: RAG, identity, and integration
- Week 7: observability, latency, cost, and governance
- Week 8: stakeholder lifecycle and operational ownership
- Week 9: capstone, full mock, and remediation
Go deeper in the Academy
- Production LLM Application (Phase 11): Connect model calls to a service boundary
- Advanced RAG (Phase 11): Go deeper on retrieval and reranking
- LLM Observability (Phase 17): Instrument production trajectories
- A/B Testing LLM Features (Phase 17): Compare variants with live evidence
- SRE for AI (Phase 17): Own incidents, SLOs, and recovery
- Compliance Frameworks (Phase 17): Map obligations to system controls
- FinOps for LLMs (Phase 17): Manage cost per useful outcome
Katalock's Claude certification prep is independent study material based on Anthropic's public exam guides. It is not affiliated with, endorsed by or authorised by Anthropic, does not contain live exam questions, and cannot guarantee a pass. Practice scores are raw percentages. They are not Anthropic's 100 to 1,000 scaled score and can't predict an official result.