Study guides / CCAR-P
Claude Certified Architect - Professional Free forever
Work through each domain in order, or jump straight to the lesson you need. Once you're ready for the real thing: request access to the official exam → (requires a Partner Network organization email - see why).
0%
Overall progress
0 of 38 lessons complete
Mark a lesson complete as you go - your progress carries across the whole curriculum.
- 1.1 Auditing Tool and Agent Configuration for Capability Bloat Audit an agent's tool and MCP configuration for capability bloat, diagnose whether the problem is token cost, selection accuracy or attack surface, and choose an enforceable remedy.
- 1.2 Authentication and Authorisation Gaps in Claude Integrations Analyse where credentials live and whose authority each tool call uses in a Claude integration, and identify authentication and authorisation gaps such as shared tokens, token passthrough and prompt-only controls.
- 1.3 Accuracy-Latency Trade-offs and Defending the Configuration Weigh model tier, effort and thinking, retrieval depth and verification passes against latency, and justify a configuration with a measured frontier and a decision record rather than an assumption.
- 1.4 Observability Challenges at Scale and Choosing a Monitoring Strategy Decide what to log and trace across model calls, tool calls and multi-agent runs, and choose sampling, correlation and privacy controls that keep observability affordable and safe at scale.
- 1.5 Designing a RAG Pipeline: Chunking and Indexing Design a RAG ingestion, chunking and indexing pipeline, use contextual enrichment and Claude's citations feature appropriately, and diagnose chunking failures from their symptoms.
- 1.6 Retrieval Strategies Matched to Data Shape and Query Pattern Choose among semantic, keyword, hybrid, reranked, structured and agentic retrieval by matching the strategy to the data shape and the query pattern, and evaluate each stage separately.
- 1.7 Choosing an Integration Mechanism: MCP, API/CLI, or Agent-to-Agent Compare direct API tools, CLI access, MCP and agent-to-agent protocols on reuse, governance, latency and coupling, and select and justify the mechanism for a given integration.
- 1.8 Progressive Discovery vs a Monolithic Context Strategy Weigh loading everything up front against discovering tools, skills, files and knowledge just in time, and choose a hybrid supported by measurements of cost, accuracy, latency and discovery failures.
- 2.1 Translating a Business Problem into a Claude-Based Solution Turn a vague business goal into a scoped, testable Claude solution: decompose it into tasks, decide per task whether Claude owns, assists or is not used, and write success criteria you can measure.
- 2.2 End-to-End Architecture: Input, Processing, Output and Feedback Loops Lay out a reference architecture for a Claude-based system, from intake through context assembly, model calls, output validation and delivery to a feedback loop, and decide which stage should catch which failure.
- 2.3 Workflow, Agentic, or Augmented LLM: Choosing the Pattern Decide when a single augmented call, a fixed workflow or an agent is the right architecture, and justify the choice on cost, reliability, latency and controllability rather than on how sophisticated it sounds.
- 2.4 Multi-Agent Systems and Orchestration Strategy Decide whether multi-agent is justified, choose an orchestration topology, design what context crosses agent boundaries, propagate errors so failures are visible, and account for the token cost multiplier.
- 2.5 Decomposition Techniques for Complex Problems Choose among prompt chaining, sectioning, routing and plan-then-execute, place step boundaries where they can be verified, and add checks between steps so errors do not compound.
- 2.6 Aligning a Design to Business-Value Pillars and SLAs Map design choices to efficiency, productivity, cost, transformation and performance/SLA targets, pick a primary pillar per use case, and state each trade-off in measurable terms.
- 3.1 Defining Evaluation Metrics: Accuracy, Latency, Cost, Safety and Security Choose metrics for each quality dimension of a Claude system, decide which are code-graded, model-graded or human-graded, and set thresholds that trace back to explicit success criteria.
- 3.2 Evaluation Datasets and Mixed-Methodology Test Frameworks Design evaluation datasets that combine representative, edge-case and adversarial inputs, protect them with holdout discipline, and layer automated, LLM-judge and human review into one test framework.
- 3.3 A/B Testing and Iterative Improvement Compare prompts, models and configurations safely, offline first and then on live traffic, with sound randomisation, guardrail metrics, a staged rollout and a pre-agreed rollback.
- 3.4 Diagnosing Failures: Prompt Failure, Hallucination and Model Mismatch Work through a layered diagnostic tree to decide whether a bad output comes from the API call, the tools, the retrieved context, the prompt, or the model, and collect the right evidence before changing anything.
- 3.5 Optimising Token Usage, Latency and Cost-Performance Measure where tokens, time and money go, then match each cost or latency driver to the right lever (caching, batching, tiering, effort, output shaping, context trimming) and validate every trade-off against your evals.
- 3.6 Production Monitoring with Logging and Observability Tooling Design ongoing monitoring for a live Claude system: which quality, cost, latency, error and safety signals to track, how to detect drift and regressions, how to alert sensibly, and how to sample for human review.
- 4.1 Implementing Guardrails and Safety Controls Design layered guardrails (input, prompt, tool, output, process) and decide which requirements need deterministic enforcement in code, how each layer should fail, and how to contain prompt injection.
- 4.2 Risks, Limitations and Failure Modes of LLM Systems Identify how LLM systems fail (hallucination, injection, over-reliance, drift, non-determinism, cascading agent errors) and turn that into a risk register with controls, owners and review triggers you can defend.
- 4.3 Human-in-the-Loop Validation Strategies Decide where human review belongs, when to use approval gates, sampling or confidence-based routing, and how to size reviewer capacity and defend against rubber-stamping and automation bias.
- 4.4 Compliance in the Architecture: GDPR, HIPAA and FedRAMP Translate GDPR, HIPAA and FedRAMP concerns into architecture decisions: data-flow mapping, minimisation, retention, residency, access control, audit evidence and vendor agreements. Architecture only, not legal advice.
- 4.5 Ethical AI: Bias, Fairness and Transparency Turn ethical concerns into engineering work: find where bias enters an LLM system, test for it with counterfactual comparisons, design fair consequential decisions, disclose AI use honestly, and document what you can and cannot explain.
- 5.1 Structured Discovery and Requirements Gathering Run a structured discovery session that surfaces use case, data, constraints, risk and measurable success criteria, so that the model and architecture you recommend follow from evidence rather than from the first idea in the room.
- 5.2 Communicating Architectural Decisions and Trade-offs Communicate a Claude architecture decision to executives, engineers and risk teams by framing options with trade-offs, stating limitations with evidence, and capturing the rationale in a decision record that outlives the meeting.
- 5.3 Stakeholder Feedback Loops and Expectation and SLA Alignment Align stakeholders on what a probabilistic Claude system can promise by separating service, quality and cost objectives, deriving SLOs and SLAs from evidence and dependency limits, and running feedback loops that handle disagreement and scope change.
- 5.4 Documenting an Architecture and Giving Implementation Guidance Produce an architecture document, diagrams, decision records and runbooks for a Claude system, and hand implementation guidance to a build team as constraints, rationale and acceptance criteria rather than a code dump.
- 5.5 Supporting the Lifecycle: Discovery, Design, Handoff, Monitoring, Iteration Define the architect's responsibilities across discovery, design, handoff, monitoring and iteration, including ownership after launch and an evidence-based process for managing model version changes and deprecations.
- 6.1 Selecting a Claude Model on Cost, Latency and Capability Trade-offs Choose a Claude model tier and effort setting by measuring cost per completed task, latency and capability on your own evals, and decide when routing or multi-model patterns beat a single model.
- 6.2 System Prompts, Templates and Guardrails Design a system prompt with explicit criteria, separated variable content and layered guardrails, and decide which requirements belong in prompt wording and which must be enforced in code.
- 6.3 Prompting Techniques: Zero-Shot, Few-Shot and Chain-of-Thought Choose between zero-shot, few-shot and reasoning-based prompting for a given failure mode, and validate the choice on an eval set instead of intuition.
- 6.4 Optimising the Context Window and Managing Token Usage Budget the context window deliberately: decide what to load, in what order, and when to trim, clear, compact or externalise, and recognise the failure modes of long contexts.
- 6.5 Prompt Reuse: Caching, Modular Prompts and Skills Choose and configure prompt caching, modular prompt components and Agent Skills so shared instructions are cheap to run, easy to version and safe to govern.
- 7.1 Configuring Claude Code and Environments for a Team Decide which Claude Code mechanism (CLAUDE.md, rules, settings, hooks, skills, MCP, managed policy) belongs at which scope, and how to roll a team configuration out so that it is shared, enforced where it must be, and verifiable.
- 7.2 AI-Assisted Developer Workflows Choose between plan mode and direct execution, close the feedback loop with verification, place review and CI automation correctly, and report productivity gains without over-claiming.
- 7.3 Debugging and Operational Issue Resolution Isolate which layer of a Claude-based system or Claude Code environment failed, use the right diagnostic and request identifiers, and decide when and how to escalate to Anthropic or your own platform team.