Free Claude Certified Developer - Foundations (CCDV-F) Practice Questions

Sample CCDV-F Practice Questions

Browse all 10 free Claude Certified Developer - Foundations practice questions below.

1. A Python FastAPI backend forwards chat requests to Claude's Messages API through the official SDK. During code review a teammate asks which top-level fields the request body must always carry for the call to be accepted, before any optional tuning is layered on. Which set of fields is required on every Messages API request?

   • Only `messages`, because the server resolves a default model and output limit from the workspace configuration tied to the API key
   • `model`, `max_tokens`, and `messages`, giving the API the model to call, an output ceiling, and the conversation turns
   • `model`, `system`, and `temperature`, because each request must define a persona and a sampling setting alongside the model choice
   • `prompt` and `stop_sequences`, the text-completions request shape that the Messages endpoint still accepts for compatibility reasons

2. A developer joining an LLM team is planning how much conversation history and retrieved documentation their support bot can pack into each Claude request, and asks what the model's 'context window' actually bounds. Which description of the context window is accurate?

   • The number of separate conversations one API key can keep active at a time before new sessions are queued by the platform
   • The length of time a streaming connection may stay open before the server closes it as idle during a long generation
   • The number of requests per minute an organization can send to that model before rate limiting starts returning 429 responses
   • The maximum number of tokens, spanning both the input prompt and the generated output, that a single request can use

3. A startup processes uploaded invoices to pull three known fields (vendor, date, total) using one well-specified extraction prompt. One engineer proposes an autonomous agent loop with tools; another argues the job needs only a fixed single-call workflow. Given the task is fully specified and single-step, which approach fits best, and why?

   • A workflow built on a single Messages API call, because nothing in the task requires the model to plan its own multi-step trajectory
   • An autonomous agent with a tool-use loop, because document-centric tasks benefit from letting the model decide its own processing steps
   • A coordinator with three subagents, one per field, so each extraction runs in isolated context and errors cannot cross-contaminate
   • An agent with a persistent memory store, so patterns learned from earlier invoices improve accuracy on later ones automatically

4. A Node/TypeScript chatbot fetches and summarizes web pages that end users submit by URL. One submitted page contains hidden text instructing the model to disregard its instructions and email the conversation history to an attacker. Which TWO practices most effectively reduce this prompt-injection risk? (Select TWO)

   • Treat fetched page content as untrusted data and keep it structurally separated from the system instructions
   • Sanitize the fetched HTML by stripping script tags and event handlers before passing the page text to the model
   • Rotate the workload's API key after each summarization job so a compromised conversation cannot be replayed later
   • Apply least-privilege guardrails, such as hooks, so injected text cannot trigger the email-sending tool at all
   • Move to the largest model tier, since stronger instruction-following makes embedded commands less likely to be obeyed

5. A developer building a customer-support assistant wants Claude to hold a consistent persona and follow the same escalation rules across every turn, regardless of what the user types or how long the conversation runs. Where should these durable, role-defining instructions be placed in the request?

   • Appended to the end of each user message, so they are always the most recent text the model reads before it answers
   • Stored in the API key's metadata in the console, so the platform attaches them to every request made with that key
   • In the top-level `system` prompt, which is designed to carry durable role and rule instructions across all turns
   • Split between `stop_sequences` and `metadata`, so the guidance rides along without consuming context-window tokens

6. A fintech team ships a customer-support chat backend on the Messages API. After they enable adaptive thinking to improve answer quality, the handler that reads response.content[0].text starts throwing intermittent type errors in production, but only on some responses. Logging shows the failing responses are the ones where the model reasoned before answering. What is the cause?

   • Thinking responses move the final answer into a dedicated top-level field on the response object, and the content array carries only reasoning blocks, so the text must be read from that field.
   • The streaming accumulator in the SDK merges only text deltas, so once thinking is on you must switch to the raw event iterator and reassemble the message from individual events yourself.
   • Thinking consumes part of the max_tokens budget, so on responses where reasoning ran long the content array comes back empty and indexing it raises; raising max_tokens is the fix.
   • A thinking block can precede the text block in the content array, so content[0] is not always text; the code should iterate over the blocks and branch on each block's type.

7. A push-notification service for a delivery app must label every incoming message as urgent or routine before fan-out. Volume peaks around two million classifications per day, each label is a simple two-way call, and the product team caps added latency at a few hundred milliseconds. Which model tier fits this workload best?

   • Opus at a low effort setting, because a top-tier model with reduced effort matches the small model's speed while keeping a capability reserve.
   • Opus, because the most capable tier produces the most trustworthy labels and classification errors at this volume would compound quickly.
   • Sonnet, because the mid tier is the recommended default for production traffic and moving down a tier requires a formal accuracy review first.
   • Haiku, because it is the fastest and most cost-effective tier and this task is simple, high-volume, and latency-sensitive.

8. A legal-tech startup processes incoming contracts and must decide between a hard-coded pipeline of model calls and an autonomous agent that plans its own steps. The engineering lead asks which conditions actually justify the agent architecture. Which TWO conditions most favor building an agent rather than a fixed workflow? (Select TWO)

   • The work is multi-step and hard to specify completely in advance, so the model needs to choose its own trajectory through each contract.
   • The business priority is the lowest possible per-request cost and latency across the whole document pipeline.
   • The outcome justifies higher cost and latency, and mistakes are recoverable because reviews and validation checks catch bad output.
   • Every response must conform to one fixed JSON schema so downstream systems can parse it without special cases.
   • Each contract passes through the same extraction, comparison, and summary stages, which the team can write out completely before launch.

9. A CI code-review bot defines a post_review_comment tool whose description reads "Posts a comment on the pull request." In staging runs the model finds genuine bugs in its text output yet rarely invokes the tool, so findings are lost. Which change most reliably raises the tool's call rate in the right situations?

   • Rewrite the description to state the trigger condition, for example: call this tool whenever you identify a concrete defect, style violation, or risky change worth flagging to the author.
   • Move the full list of review rules out of the tool description and into the system prompt so the model reads them before it starts analyzing the diff.
   • Set tool_choice to type any on every review request so each response is guaranteed to include at least one tool invocation before it completes.
   • Split the single tool into one tool per issue category, such as security, style, and performance, so the model can pick a more specific action for each finding.

10. A travel-booking backend proxies the Messages API behind its own REST layer. During a fare-sale traffic spike, upstream calls begin returning HTTP 429 with a retry-after header while other requests still succeed. What should the backend do with the failed requests?

    • Retry the same request in a tight loop over several parallel connections so at least one attempt lands as soon as capacity frees up on the upstream side.
    • Rotate to a backup API key from a second workspace and resend immediately, since limits are enforced per key and switching keys restores throughput at once.
    • Fail the request through to the client as a permanent error, because a 429 indicates the request payload itself exceeded a size limit and resending it cannot succeed.
    • Wait out the retry-after delay and retry with backoff, treating the 429 as a temporary rate-limit signal the SDK can also handle automatically.