CCAR-P Study Guide: The Seven Domains, In Weight Order

Seven domains, unevenly weighted, and those weights should decide your revision plan before anything else does. Integration leads at 19 percent, then Solution Design & Architecture at 17, Evaluation, Testing & Optimization at 16, Governance, Safety & Risk Management and Stakeholder Communication & Lifecycle Management tied at 14 apiece, Claude Models, Prompting & Context Engineering at 13, and Developer Productivity & Operational Enablement at 7. Against a 63-question paper that lands at roughly 12, 11, 10, 9, 9, 8 and 4 items.

Those numbers overturn the instinct most candidates arrive with. The two areas containing no code at all, governance and stakeholder work, are worth 28 percent between them, more than any single technical area on the blueprint. The prompt engineering material people expect to dominate a Claude exam sits at 13 percent, behind three other domains.

This page follows guide version 1.0, effective July 2026. The structure is flat: single-tier domains, no published sub-skill breakdown, no scenario sections, so each item is drawn against a domain weight and nothing else. Results are criterion-referenced on a 100 to 1000 scale with 720 required, and no raw-percentage equivalent is published, so there is no arithmetic that lets you safely abandon a domain in advance.

What follows walks all seven in weight order, saying what each one genuinely asks of you rather than restating its objective list, then closes with a revision sequence and a plan for the final week.

Integration, 19 percent: everything that crosses a boundary

About 12 questions, and the widest span on the paper. The objectives run to eight: evaluating tool and agent configuration for capability bloat, auditing authentication and authorisation for gaps, trading accuracy against latency, choosing monitoring strategies that survive scale, designing RAG pipelines with chunking and indexing, matching retrieval strategy to the shape of the data, evaluating connection protocols including MCP, and deciding between progressive discovery and loading everything up front.

What links them is that each governs an edge: what the model may reach, under whose authority, carrying which data, over which wire, and leaving which record behind. Most of the revision is ordinary distributed-systems and security judgement, applied to a component that answers differently each time you ask it.

Concrete revision targets. Be able to explain why deleting a tool beats instructing the model not to call it. Know where an authorisation check must sit so that a persuaded model cannot route around it, and what may never be handed to the model as a credential. Be able to pick a chunking strategy from the corpus rather than from habit, distinguishing a table-heavy dataset from long continuous prose. Know what fields a trace needs before anyone can reconstruct an incident a week later. If circumstances mean you can only prepare two domains to depth, make this one of them.

Solution Design & Architecture, 17 percent: judgement under a stated constraint

About 11 questions. The objectives cover translating business problems into Claude solutions, designing end-to-end architectures including feedback loops, selecting among workflow, agentic and augmented-LLM patterns, designing multi-agent systems and orchestration, applying decomposition, and aligning designs to business value.

Revising this area by memorising pattern definitions will not get you far, because the questions rarely hinge on recognising a pattern. They hinge on a single clause in the stem that constrains the answer: a ceiling on cost per transaction, a percentile latency target, a boundary that data may not cross, a team who inherit the system next quarter. Several options remain defensible in general and exactly one survives that clause.

So revise the discriminators rather than the taxonomy. Whether the number of subtasks is knowable before you see the input. Whether steps depend on each other or run independently. Whether an action can be undone. Whether the spend per request has a ceiling you set in code or a tail you cannot bound. A useful exercise: take three systems you have shipped, and for each write one line naming the constraint that drove the design and one line naming the design you rejected. An architecture you cannot argue against is a habit rather than a decision, and this domain is built to find that out.

Evaluation, Testing & Optimization, 16 percent: evidence about a system that will not repeat itself

About 10 questions, covering evaluation metrics across accuracy, latency, cost, safety and security; evaluation datasets and test frameworks; A/B testing and iterative improvement; diagnosing issues such as prompt failure, hallucination and model mismatch; optimising tokens, latency and cost-performance; and monitoring through logging and observability.

The reframe that unlocks the whole area is that assert-equals testing does not apply. You are measuring properties and distributions, not matching strings, and a result arrives with an interval around it rather than a verdict. Candidates who never make that shift quietly conclude the system is untestable and lose most of these marks.

The rest is diagnostic discipline. Given a described symptom, name which layer moved: the prompt, the retrieval corpus, the tool surface, the model version, or the traffic mix itself. Then name the single experiment that isolates it, changing one thing and comparing over enough samples to mean something.

Revise this alongside Integration rather than after it. A diagnosis question is unanswerable unless you already know what the pipeline stages are and how each one fails, so studying the two in the same sitting compounds better than treating them as separate blocks of reading.

Governance and Stakeholder Communication, 28 percent combined and no code in either

Two domains at 14 percent each, roughly 9 questions apiece, and together the largest block on the paper. Technical candidates underrate both, which is precisely why they are worth budgeting hours against.

Governance, Safety & Risk Management covers guardrails and safety controls, the risks and failure modes of LLM systems, human-in-the-loop validation, compliance (the guide names GDPR, HIPAA and FedRAMP as examples), and ethical considerations including bias, fairness and transparency. It is not a law exam. What is being tested is translation: turning an obligation the organisation has accepted into a property of the system that can be pointed at and verified. Where data is processed, how long it is retained, what reaches the logs, who may read a trace, which decisions require a recorded human sign-off. The recurring distinction is that a control the model can read is a control it can be argued out of.

Stakeholder Communication & Lifecycle Management covers structured discovery, communicating architectural trade-offs, expectation alignment including SLAs, documentation and implementation guidance, and the lifecycle through handoff, monitoring and iteration. Every option here reads as something a reasonable professional might say. What separates the right one is almost always evidence and ownership: is the commitment backed by a measurement, and does the mechanism have a named person accountable for it.

Prompting at 13 percent, developer tooling at 7 percent

Claude Models, Prompting & Context Engineering is about 8 questions: model and effort selection against trade-offs, system prompts, templates and guardrails, prompt engineering technique, context window and token optimisation, and reuse through caching, modular prompts and Skills.

The professional framing is what catches people. A prompt at this tier is a versioned artifact that every request pays for, and its byte-level layout determines whether caching hits. Model choice and effort level are two independent dials, not one preference. Revise by asking what a change costs rather than what it improves: enabling caching, raising effort, adding examples, moving a document out of the window and into retrieval each have a second-order effect, and the distractors are built from those.

Developer Productivity & Operational Enablement is the smallest at 7 percent, about 4 questions: configuring Claude tooling and environments for teams, improving workflows with AI-assisted tooling, and supporting debugging and operational resolution. Four items sounds skippable and is not, because a scaled pass mark makes borderline results turn on exactly that many. It is also the most concrete material available, a finite set of files, layers and documented mechanisms. Per hour invested, nothing else on the blueprint returns as much. The idea to hold onto is that instruction files supply context, while enforcement lives in mechanisms the client applies regardless of what the model decides.

A revision order that respects the weights

Start with a timed diagnostic before you read anything, so that the plan is built from your gaps rather than your assumptions. Score it by domain.

Then work in four blocks. Block one is Integration and Solution Design together, because they share a mode of reasoning: name the trade-off, then choose against the condition the stem actually states. That pair is 36 percent, roughly 23 questions, and it decides most results. Block two is Evaluation, worked immediately after Integration while the pipeline stages are still fresh. Block three is the governance and stakeholder pair, which you should revise by writing rather than reading: draft the two-sentence version of a latency commitment you would put in front of a sponsor, and list what a receiving team needs before they can safely change a system they did not build. Block four is prompting and developer tooling, left late deliberately because it is the most factual and the least likely to decay.

Run the diagnostic again at the end of block three. If a domain is still weak and worth 14 percent or more, that is where the remaining hours go, whatever your original schedule said. Weight beats preference every time you have to choose.

The last seven days

Stop learning new material about five days out. Anything encountered for the first time in the final week will not be reliable under time pressure, and the hours are better spent making what you already know retrievable at speed.

Sit at least two full-length timed simulations at the real count and clock, ideally on separate days, at the hour of day your appointment falls. The point is not the score. It is felt experience of the pace, so that the sensation of being fourteen questions in with the clock at twenty-eight minutes registers as normal rather than alarming.

Between simulations, review by wrong-option rationale rather than by rereading notes. For every item you missed, write one line explaining what the tempting distractor would actually cost in production. If you cannot write that line, you have identified a real gap rather than a slip.

In the final two days, reread your own notes on the two 14 percent domains, since they are the ones that fade fastest for technical candidates, and confirm your logistics. Scheduling changes are only possible up to 24 hours before the appointment, so the day before is far too late to discover a diary clash.

Common questions