Applications and Integration: the domain that decides CCDV-F

Applications and Integration is the largest domain on CCDV-F by a wide margin: 33.1% of the exam, roughly 17 of 53 items, more than the next two domains combined. Inside it sit six published skills, and the two heaviest are Claude Application Design at 8.6% and Software Engineering Foundations at 7.4%. Together those two are about 16% of an Anthropic certification spent on boundaries, schemas, REST, asynchronous work, version control and code review.

How big it actually is

Compare that with what candidates actually talk about. Claude Code is 3.1% of this paper. Eval, Testing and Debugging is 2.6%, which on a 53-item exam is about one question. Both are more interesting to study than schema design, and between them they are worth less than a fifth of this one domain. The full weights for all four tracks put the same point in one table.

The six skills inside it

CCDV-F is the only one of the four tracks that publishes weights at this level of detail, which makes it the only exam where you can plan against skills rather than domain names. That is worth using: the spread inside this domain runs from 8.6% down to 2.8%, a range as wide as the gap between several whole domains elsewhere on the paper.

The unglamorous half

Software Engineering Foundations is the finding most people miss. It is 7.4% of an exam about building with Claude, and almost none of it is about Claude: representational state transfer and JSON, asynchronous work, version control, code review, and refactoring at both the small and structural scale.

It earns its place. Most of what goes wrong in a Claude application goes wrong in the ordinary engineering around the model — three independent calls awaited in sequence when they could run together, a retry over an operation that is not safe to repeat, generated code that passes its tests and still should not merge. The exam asks about those, and it asks about them in the same scenario-and-four-options format as everything else.

What application design means here

The heaviest skill on the whole paper, at 8.6%, and the name is broader than the content. In practice it is about boundaries: how instructions reach the model across different surfaces, keeping what you instructed separate from what merely arrived, designing a schema around what the consumer needs rather than everything available, and keeping a session clean enough that the next turn is not paying for the last ten.

Two of those overlap with material examined elsewhere and are worth studying once for both purposes. The instruction-versus-content boundary is the same idea as prompt injection and guardrails, and schema design is the response side of tool use and structured output.

API mechanics you can be asked about

At 6.8% this is the third-heaviest skill, and the examinable surface is narrower than the name suggests: messages, tools, streaming, extended thinking and caching; access through third-party vendors; the choice between realtime and deferred processing; and stop reasons — what a response's own metadata tells you about why generation ended, before you parse a word of it.

The realtime-versus-batch decision is the one worth a written rule. Deferred processing trades immediacy for cost. Volume and price pressure make it attractive; a commitment to answer one customer within seconds disqualifies it, and no amount of either pressure relaxes that. Which layer of the stack you are working at changes almost nothing about that judgment — see Agent SDK, Claude Code or the API for how the exams separate those.

How to spend the time

A reasonable shape for a four-week run is a third of your study days in this one domain, front-loaded rather than saved for the end. Start with application design and engineering foundations, because together they are 16% of the paper and they are the two most likely to be skipped by someone preparing for a “Claude exam.” Take API mechanics next. Configuration management, requirements and life cycle are real but small, and one focused pass each is proportionate.

Then stop studying and sit something timed. Weight-aware mocks are the only way to find out whether your revision matched the paper — see how many mocks to take for the sequencing.

Key takeaways

• One domain is a third of the exam. Applications and Integration is 33.1%, roughly 17 of 53 items, larger than the next two combined.
• Its two heaviest skills are the least Claude-specific. Application design at 8.6% and engineering foundations at 7.4%.
• General engineering is examined. REST and JSON, async work, version control, code review and refactoring all appear by name.
• CCDV-F publishes skill-level weights. It is the only track where you can plan against skills rather than domain names.
• The interesting domains are small. Claude Code is 3.1% and eval and debugging is 2.6% — about three items between them.
• Front-load this domain. A third of your study days belongs here, starting with the two heaviest skills.