15 Free Claude Certified Developer – Foundations (CCDV-F) Practice Questions with Answers (2026)

Model selection is a trade-off between quality, latency and cost. When the smallest tier already meets the quality bar on a high-volume, latency-sensitive task, it is the right pick. Keep measuring, because the trade-off can shift.

• B is wrong because it pays for capability the eval says you do not need and makes latency worse.
• C is wrong because batches can take up to 24 hours, which breaks the one-second requirement.
• D is wrong because extra reasoning adds latency and tokens to a task that is already accurate enough.

When the steps are known in advance and the order is fixed, a workflow (prompt chaining with gates in code) is simpler, cheaper and more predictable than an agent. Agents earn their cost when the path cannot be specified ahead of time.

• A is wrong because it hands an open-ended choice of path to the model when the path is already known.
• B is wrong because a multi-agent hierarchy adds cost and failure points for a linear process.
• C is wrong because one prompt gives you no place to validate between steps.

This is context bloat. Verbose tool output fills the context window with tokens that do not help. Pruning tool results to what matters is a standard context engineering fix, and it cuts cost and confusion at the same time.

• A is wrong because max_tokens limits the output, not the input context that is overflowing.
• C is wrong because moving the bloat to the system prompt keeps every token and breaks the conversation structure.
• D is wrong because it pushes the problem onto users instead of fixing the design.

Client tools, like your get_inventory, are executed by your application, which then returns a tool_result. Server tools, like web search, run on Anthropic's infrastructure and their results appear as content blocks in the same response.

• A is wrong because server tool calls do not need you to run them.
• B is wrong because Anthropic cannot reach your private database.
• C is wrong because it has the two types backwards.

Streaming returns the response as server-sent events while it is generated, so users see text within moments instead of waiting for the full message. The SDKs also recommend streaming for long outputs to avoid HTTP timeouts.

• A is wrong because it cuts the answer the users need.
• C is wrong because batches are asynchronous and much slower to return.
• D is wrong because retrying a working request wastes money and makes the wait longer.

Anything shipped to a client device can be extracted. API keys belong on the server, loaded from a secrets store, with your backend handling user authentication, authorisation and rate limits.

• A is wrong because obfuscation slows an attacker down but does not protect the key.
• B is wrong because a prompt instruction is not an access control, and anyone with the key can call the API directly.
• D is wrong because rotation limits the damage window but leaves the key exposed every month.

A 429 means you hit a rate limit, and a 529 means the API is temporarily overloaded. Both are transient, so backing off and retrying is the right response. Respect the retry-after header when it is present.

• B is wrong because a malformed request will fail the same way every time until you fix it.
• C is wrong because a bad or missing API key will not fix itself on retry.

One nuance from the docs: a 429 caused by hitting your tier's monthly spend cap keeps failing until access resumes, so do not retry those forever.

Caching is a prefix match. Any change early in the prompt invalidates everything after it. Move volatile content like timestamps after the last cache breakpoint, and keep stable content first.

• B is wrong because caching works on normal Messages API requests.
• C is wrong because tools are part of the cacheable prefix; they come first, before the system prompt.
• D is wrong because system prompts are one of the most common things to cache.

Structured outputs constrain the response to your JSON schema, so syntax and required fields are guaranteed. Schema compliance does not prove the values are correct, so keep checking business rules in your own code.

• A is wrong because louder instructions still leave a non-zero failure rate.
• B is wrong because the newest Claude models no longer accept assistant prefill, and prefill never guaranteed the schema anyway.
• D is wrong because it hides malformed output instead of preventing it.

The Claude Agent SDK packages the Claude Code harness as a library. It ships built-in file, search and shell tools, the agent loop, context management, hooks, permissions and subagents, and you host it yourself.

• A is wrong because a single call is not a loop, and you would have to build every tool yourself.
• C is wrong because batches cannot run multi-turn tool calls inside a request.
• D is wrong because it is a chat product, not something you deploy and control in code.

Claude behaves according to what each interface puts in its context. Claude Code reads CLAUDE.md files and adds them for you. The Messages API is stateless and only sees what your request contains.

• A is wrong because the API reads no files at all.
• B is wrong because tools have nothing to do with it.
• C is wrong because the file was never sent, so there is nothing to truncate.

MCP defines two standard transports. stdio runs the server as a local subprocess of the client. Streamable HTTP runs it as an independent service that many clients can reach, which suits a central, authenticated deployment.

• B is wrong because stdio is designed for a client launching a local process, not for many remote users.
• C is wrong because it spreads production credentials across 40 laptops and loses central control.
• D is wrong because Streamable HTTP replaced the HTTP+SSE transport in the 2025 versions of the spec.

Behaviour can change between model releases. Configuration management means pinning the model version, versioning prompts with it, and treating an upgrade as a change you test before you ship.

• A is wrong because it removes automation instead of controlling change.
• C is wrong because a prompt line cannot stop a behaviour change you never tested.
• D is wrong because it creates more unplanned change, not less.

/init analyses the codebase and writes a starting CLAUDE.md. If one already exists, it suggests improvements instead of overwriting it.

• A is wrong because /compact summarises the current conversation to save context.
• B is wrong because /memory opens and shows the memory files that are loaded; it does not generate one from the code.
• D is wrong because /clear starts a fresh conversation.