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

Sample CCDV-F Practice Questions

Browse all 20 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.

11. A fintech startup's worker service must tag 50,000 archived support tickets with product categories before a Monday-morning report. The job kicks off Friday evening, nobody reads the output until the report runs, and finance has flagged API spend as the number to minimize this quarter. Which processing approach fits these constraints best?

    • Fan the tickets out across a large pool of concurrent Messages API calls so the whole set completes within the first hour
    • Submit the tickets as a Message Batches API job, which processes them asynchronously within 24 hours at half the standard price
    • Move the job to the Haiku tier while keeping the existing synchronous request path the team already runs in production
    • Enable prompt caching on each ticket body so repeated requests reread the ticket text from cache at a tenth of the normal input price

12. An invoicing platform converts foreign-currency amounts through the same three steps on every document: extract the amount, call an FX rate service, then write the converted value back. The sequence has not changed in two years, and each step's inputs and outputs are fully specified. Should the team build an autonomous agent or a workflow?

    • A workflow with the three steps orchestrated in code, because a fixed, fully specified sequence gains nothing from model autonomy
    • A coordinator agent that hands each of the three steps to its own subagent so the stages can proceed in parallel
    • An autonomous agent, because calling an external rate service mid-task is the kind of action that benefits from model-driven orchestration
    • An autonomous agent with adaptive thinking, so the model can reconsider the ordering whenever an unusual invoice format arrives

13. A dating app labels each incoming chat message as positive, neutral, or negative to feed a safety dashboard. Traffic peaks at hundreds of messages per second, product wants labels back in well under a second, and the classification itself is short and simple. Which model tier is the best default for this profile?

    • Claude Sonnet with effort raised to max, trading a little extra latency for the strongest label quality available
    • Claude Opus for messages caught by a keyword pre-filter and Sonnet for the remainder, so capability scales with apparent risk
    • Claude Opus, because a safety-adjacent feature justifies paying for the most capable tier on each classification
    • Claude Haiku, the tier positioned for simple, high-volume work where per-request cost and latency dominate the decision

14. A research assistant built on the Claude API fetches and summarizes web pages submitted by end users. One submitted page hides white-on-white text instructing the model to call the agent's send_email tool and forward internal meeting notes to an outside address. Which TWO practices best reduce this prompt-injection risk? (Select TWO)

    • Move to a larger model tier, since stronger instruction following makes a model harder to redirect with embedded commands
    • Raise the effort setting so the model reasons more carefully before acting on anything a fetched page says
    • Treat fetched page content as untrusted data, clearly delimited and kept separate from the trusted system instructions
    • Enforce least-privilege guardrails in the harness, such as a hook that gates send_email behind approval
    • Sanitize the fetched HTML by stripping script tags and event handlers before the page text enters the prompt

15. A coding harness exposes a search_codebase tool that works whenever it runs, yet transcripts show Claude answering repository questions from general knowledge instead of calling it. The team wants searches to happen when an answer depends on actual repo contents, while requests that need no search stay untouched. What is the most effective first fix?

    • Rewrite the tool description to state when to call it, for example whenever an answer depends on code not visible in the conversation
    • Set tool_choice to type 'tool' naming search_codebase so repository questions are guaranteed to search before answering
    • Trim the tool's input schema to a single query field so invoking it costs the model fewer tokens per call
    • Set tool_choice to type 'any' so the model must invoke at least one tool before it is allowed to answer

16. A developer's internal inventory MCP server exposes a get_stock tool, but Claude regularly calls it with a missing warehouse_id or passes a SKU where a location code belongs. The tool's own logic tests clean in isolation. Which TWO changes most directly improve how reliably Claude forms the call? (Select TWO)

    • Set tool_choice to {"type": "any"} so the model is required to call one of the tools on each request
    • Raise max_tokens so the model has more room to emit the complete set of arguments in its reply
    • Tighten the input schema with typed properties, enums for the location codes, and required fields marked
    • Expand the tool description to state what it does, when to call it, and what each parameter means
    • Lower the temperature so the sampled tool calls vary less from one request to the next

17. A Node.js team is wiring its first Messages API integration for a legal-review assistant. A standing persona and strict formatting rules must apply on every turn, while each request also carries the lawyer's current question about a contract. Where does each piece belong in the request?

    • Concatenate the rules and the current question into a single user message on every call
    • Send the standing rules in the top-level system parameter and the question as a user message
    • Open the messages array with an assistant turn that states the rules as the model's own words
    • Attach the rules in the request's metadata object so they accompany each outgoing API call

18. A support platform classifies roughly two hundred thousand inbound tickets per day into twelve fixed categories. Each label decision is simple, but the pipeline must stay fast and cheap enough to run on every ticket as it arrives. Which model choice best matches this workload?

    • Claude Haiku, the fastest and lowest-cost tier, sized for simple high-volume classification
    • Claude Opus, since the strongest reasoning tier will maximize label accuracy on each ticket
    • A round-robin rotation across the tiers so no single model becomes a throughput bottleneck
    • Claude Sonnet with extended thinking enabled, giving every ticket extra deliberation first

19. During a security review, a fintech startup discovers its ANTHROPIC_API_KEY sitting in the JavaScript bundle every visitor's browser downloads. Anyone can extract the key and bill the company's account. Which remediation actually removes the exposure rather than papering over it?

    • Shorten the key's exposure window with weekly rotation while leaving the client code unchanged
    • Keep the key on a backend service and route all model calls from the browser through it
    • Minify and obfuscate the production bundle so the key string is no longer human-readable
    • Move the key into a build-time environment variable that is inlined during the frontend build

20. A chat interface built on the Messages API feels sluggish because nothing renders until the whole completion finishes, sometimes fifteen seconds for long answers. The product team wants text to appear word by word while the model is still generating. Which API capability delivers this?

    • Request streaming, which returns the reply incrementally as server-sent events the UI renders
    • Lower max_tokens so completions finish fast enough that a loading spinner feels acceptable
    • Poll the request identifier on a short interval and render whatever partial progress the server reports back
    • Split each prompt into several smaller requests and render every short answer as it returns