TimoBy Amotion AI

CCDV-F · Free practice exam · No sign-up

Claude Certified Developer Foundations practice exam (CCDV-F)

Take a free 20-question practice exam for Claude Certified Developer Foundations (CCDV-F) in 40 minutes. You get your score, results by topic and an explanation for every answer option.

You can practise these 20 questions free, without signing up. For more practice, enroll as a Timo consultant to get 5 full-length mock exams of 53 questions each. Enrolled Timo consultants can also book and take the official Claude certification exams.

Loading your practice exam…

Employer not a Claude partner?

If your employer is not a Claude partner but you want to become Claude certified, enroll with Timo.

Enroll with Timo

Covers: Building with Claude, working with the API and testing your integrations.

From practice to certified

  1. Practise free

    Take the free 20-question CCDV-F practice exam. No sign-up.

  2. Enroll with Timo (paid)

    Enrolled users get 1,180 practice questions in 20 full-length mock exams, plus OpenAI partner courses and badges.

  3. Book your exam

    As a Timo consultant, you register for all four Claude certification exams under Amotion AI, which is Certified in the Claude Partner Network. You pay the exam fee to Anthropic.

Join TimoHow to book the exam without a partner employer

Independent Timo preparation material. This is not an official exam and is not supplied or endorsed by Anthropic. A practice score is not a prediction of passing.

What the 20 questions cover

Official domainOfficial weightFree questions
1. Agents and Workflows14.7%3
2. Applications and Integration33.1%3
3. Claude Code3.1%2
4. Eval, Testing, and Debugging2.6%1
5. Model Selection and Optimization16.8%3
6. Prompt and Context Engineering11.0%3
7. Security and Safety8.1%3
8. Tools and MCPs10.6%2
Total100%20

Study each topic: CCDV-F study guide.

This free set does not follow the official domain weights. The table shows the actual number of questions in each domain.

Claude Certified Developer Foundations exam guide

The official exam has 53 questions in 120 minutes and a pass mark of 720 on a 100 to 1,000 scale.

All 20 CCDV-F practice questions with answers

These are the same 20 questions as the practice exam above. Take the timed practice exam first, then use this list to check each answer and its source.

Show all 20 questions

  1. Question 1

    2. Applications and Integration

    Your team changed the system prompt and one tool schema of a Claude application that issues customer refunds. The new version passed every development test, and the product owner wants to switch all production traffic to it today. A faulty change would send wrong refunds to real customers. What is the best next step for this release?

    • A. Switch all traffic to the new version today, since it passed every one of the development tests.
    • B. Switch all traffic, then watch token usage and API error rates on a daily dashboard.
    • C. Edit the live prompt in place so that any problem can be fixed without a new deployment.
    • D. Send a small share of traffic to the new version, check its refunds, and keep rollback ready.
    Show answer and explanation

    Answer: D

    Reasoning. A change that can send wrong refunds should reach production gradually, with monitoring of refund results and a ready way back, rather than all at once.

    Why A is incorrect. Development tests cannot show every kind of real customer request or integration problem, so a full switch exposes every refund to an untested failure.

    Why B is incorrect. Token usage and error rates do not show whether refunds are correct, and every customer is already exposed by the time a problem appears.

    Why C is incorrect. Editing the live prompt leaves no fixed version to compare against or roll back to, so a bad refund cannot be traced to the prompt that caused it.

    Why D is correct. A small monitored release limits how many refunds a faulty change can affect and gives evidence for either promoting the version or rolling it back.

  2. Question 2

    6. Prompt and Context Engineering

    A bank runs two Claude agents at the same time, each helping an analyst investigate a different customer. Both agents need the same long set of investigation instructions. A developer proposes running both investigations in one shared conversation so the instructions are written only once. Which design keeps each customer's data out of the other investigation while still reusing the instructions?

    • A. Use one shared conversation and tell each agent in the system prompt to ignore the other customer.
    • B. Run each investigation in its own conversation with the same instructions in its system prompt.
    • C. Keep separate conversations but sync both histories after each tool call so analysts can compare.
    • D. Keep separate conversations and give both agents one shared scratchpad for the facts they find.
    Show answer and explanation

    Answer: B

    Reasoning. Reusing instructions and isolating customer data are compatible: the instructions are shared, and each customer's data stays in a separate conversation.

    Why A is incorrect. Once both customers' data sit in one conversation, each agent can already see the other customer's details; a prompt instruction cannot undo that exposure.

    Why B is correct. The shared instructions can be reused in both system prompts, while each customer's data stays in its own conversation.

    Why C is incorrect. Syncing the histories copies each customer's data into the other investigation after every tool call, which is the exposure the bank must avoid.

    Why D is incorrect. A shared scratchpad of customer facts puts both customers' data in front of both agents, so it creates the same exposure as a shared conversation.

  3. Question 3

    1. Agents and Workflows

    An onboarding agent opens customer accounts. It pauses while the customer uploads identity documents, and when the task resumes, a different worker process may pick it up. In one incident, a worker created the account, then timed out before recording that the step was done, so the next worker ran the step again. Which TWO changes let any worker resume the task safely?

    Choose two.

    • A. Save the outstanding document requests and approval status in a shared database that every worker reads.
    • B. Keep the task's progress in the first worker's memory and route the resumed task back to that worker.
    • C. Record each completed account action with its idempotency key and reuse that key whenever a step is retried.
    • D. Restart the task from the beginning on the new worker and give each account action a fresh operation ID.
    Show answer and explanation

    Answer: A and C

    Reasoning. Safe resumption needs two things: progress stored where every worker can read it, and a way to recognize an account action that already ran even though its completion was never recorded.

    Why A is correct. A shared store lets whichever worker resumes the task see which documents and approvals are still outstanding.

    Why B is incorrect. The first worker may be the one that timed out, so its memory can be lost, and a task tied to it cannot resume elsewhere.

    Why C is correct. A recorded outcome and a reused idempotency key let the account system recognize the repeated step and return the earlier result instead of creating a second account.

    Why D is incorrect. A fresh operation ID makes the repeated account step look new, so the account system cannot detect the duplicate and may open a second account.

  4. Question 4

    5. Model Selection and Optimization

    A team uses Claude to label customer feedback as positive, negative or mixed. When they send the same borderline comment several times, Claude sometimes returns different but reasonable labels. The manager believes identical prompts should always produce identical results and asks the developer to explain. What should the developer tell the manager?

    • A. The different labels point to a network retry fault, so duplicate responses should be filtered out.
    • B. Claude's output is probabilistic, so the team should test repeated runs to measure consistency.
    • C. The first label Claude returns is its main answer, so the application should keep only the first one.
    • D. Setting temperature to 0 guarantees the same label every time, so no further testing is needed.
    Show answer and explanation

    Answer: B

    Reasoning. Claude's output is not fully deterministic, so label reliability has to be measured with repeated, representative tests and managed with clear task rules.

    Why A is incorrect. The requests succeed; the labels differ because generation is probabilistic, and filtering duplicates does not tell the team how reliable the labels are.

    Why B is correct. Running representative comments many times shows how stable the labels are and where the team needs clearer rules or review.

    Why C is incorrect. Nothing makes the first response more correct than later ones; its position in time is not evidence of accuracy.

    Why D is incorrect. Temperature 0 does not guarantee identical output: Anthropic notes that results are not fully deterministic even at 0.0, and newer models accept only the default temperature, so consistency must still be measured.

  5. Question 5

    7. Security and Safety

    A reporting tool serves many customer companies. Today it places one administrator API token in the system prompt, and Claude includes that token in tool calls to fetch each customer's data. Which credential design should replace this?

    • A. The host issues short-lived credentials scoped to each customer and adds them when it runs tools.
    • B. The host keeps the administrator token in a secret store and adds it when it runs any tool.
    • C. The system prompt holds a separate long-lived token per customer, and Claude picks the right one.
    • D. The token is encrypted in the system prompt, and the tool code decrypts it before each call.
    Show answer and explanation

    Answer: A

    Reasoning. Credentials should be handled by the host, never placed in model context, and scoped to the customer and the minimum access each action needs.

    Why A is correct. The host adds the credential outside the model's context, and a short-lived, per-customer scope limits what any single call or leaked credential can reach.

    Why B is incorrect. Moving the token out of the prompt helps, but every tool call still carries administrator access to all customers, so one customer's request could reach another's data.

    Why C is incorrect. The tokens are still visible in the model's context, and relying on Claude to pick the right one does not enforce which customer a call can reach.

    Why D is incorrect. The encrypted token still sits in model-visible text, and the call still runs with administrator access to every customer's data.

  6. Question 6

    8. Tools and MCPs

    A team is building an MCP server for HR. It must offer the company policy handbook, which clients browse section by section, and a payroll calculator that takes an employee's salary and hours and returns take-home pay. How should the server expose these two capabilities?

    • A. Expose both as prompts, since each of them returns text that Claude reads and uses.
    • B. Expose both as resources, since clients read the results that each one of them returns.
    • C. Expose the handbook as a tool that returns sections on request, and the calculator as a resource.
    • D. Expose the handbook sections as resources and the calculator as a tool with typed inputs.
    Show answer and explanation

    Answer: D

    Reasoning. Choose MCP primitives by what the capability is: resources for data to read, and tools for operations that take inputs and do work.

    Why A is incorrect. MCP prompts are reusable message templates; they are not the right primitive for reference data or for running a calculation.

    Why B is incorrect. Resources are for reading data by URI; they do not define the calculator's inputs or the fact that it runs a computation.

    Why C is incorrect. This reverses the primitives: handbook sections are data to read, while the calculator is an operation that takes inputs and runs.

    Why D is correct. Handbook sections are addressable reference data, which fits resources, and the calculator takes parameters and runs, which fits a tool.

    Source: modelcontextprotocol.io

  7. Question 7

    3. Claude Code

    A CI pipeline needs to run Claude Code with no interactive terminal, collect output that a script can parse, and prevent any file changes the team has not approved. Which TWO setup choices meet these needs?

    Choose two.

    • A. Run Claude Code in non-interactive mode with the -p flag instead of an interactive session.
    • B. Pass an explicit list of allowed tools and request JSON with --output-format json.
    • C. Skip permission prompts with --dangerously-skip-permissions, since CI runners are discarded.
    • D. Start an interactive session and drive it with a script that types prompts and answers.
    Show answer and explanation

    Answer: A and B

    Reasoning. A reliable CI job needs a non-interactive mode plus enforced tool permissions and machine-readable output.

    Why A is correct. Non-interactive mode with -p is built for automation such as CI jobs.

    Why B is correct. In a -p run, tool calls that would need approval are denied unless the allowed-tools list covers them, and JSON output gives the pipeline something reliable to parse.

    Why C is incorrect. A discarded runner can still push changes to the repository or other systems, so skipping permissions breaks the approval requirement.

    Why D is incorrect. Scripted keystrokes are fragile, hide failures, and do not produce output a script can reliably parse.

  8. Question 8

    4. Eval, Testing, and Debugging

    A tool trace shows that the tool returned the correct customer record, yet the phone number written to the database is not in that record. Retrying reproduces the same wrong value. Which TWO debugging steps best show where the wrong number comes from?

    Choose two.

    • A. Keep the failing trace and inspect each step that transforms the data before the write.
    • B. Retry many more times and compare the outputs to see whether the wrong value changes.
    • C. Add assertions that check the tool result and the final write payload separately.
    • D. Swap in a different model and check whether the wrong value still appears.
    Show answer and explanation

    Answer: A and C

    Reasoning. Finding the origin needs evidence at each boundary, from the tool result through Claude's output to the database write.

    Why A is correct. The trace shows each transformation, so the team can find the first point where the wrong number appears.

    Why B is incorrect. The failure already reproduces reliably; more retries add noise without separating model output from application code.

    Why C is correct. Separate checks show whether Claude introduced the number or the application changed it between the tool result and the write.

    Why D is incorrect. Changing the model before locating the fault removes the reliable reproduction the team needs.

  9. Question 9

    2. Applications and Integration

    A Python web service built on an async framework handles each request in an async handler but calls Claude through the SDK's synchronous client. Under load, even requests that do not use Claude stall while Claude is responding. What is the right fix?

    • A. Switch to the SDK's async client, or run the synchronous call in a bounded worker pool.
    • B. Shorten the system prompt so Claude responds faster and each call holds the handler for less time.
    • C. Raise the server's request timeout so stalled requests wait longer instead of failing.
    • D. Wrap the synchronous call in a try/except block and retry it when a timeout occurs.
    Show answer and explanation

    Answer: A

    Reasoning. The stalls come from blocking network calls inside an asynchronous server, so the fix is to make the call non-blocking or move it off the event loop.

    Why A is correct. The synchronous call blocks the event loop; the async client or a bounded worker pool lets other requests keep running while Claude responds.

    Why B is incorrect. A shorter prompt may cut response time a little, but each call still blocks the event loop, so unrelated requests keep stalling.

    Why C is incorrect. A longer timeout leaves the event loop blocked for even longer and does not let other requests run.

    Why D is incorrect. Catching exceptions and retrying does not change the fact that the call blocks the event loop while it waits.

  10. Question 10

    6. Prompt and Context Engineering

    An accounts-payable system asks Claude to extract invoice data as JSON and creates accounting records from the results automatically. One response matches the invoice schema exactly, but its tax amount does not fit the tax rate for the region given in the request. What should happen before a record is created?

    • A. Code checks the tax amount and other business rules against the request and rejects failures.
    • B. The record is created, because the response passed JSON schema validation without any errors.
    • C. The response is sent back to Claude in the same conversation to confirm its own tax calculation.
    • D. The record is created and flagged so that finance can correct any tax errors at month-end close.
    Show answer and explanation

    Answer: A

    Reasoning. JSON that matches the schema still needs business-rule checks before it drives an accounting record, because correct structure does not mean correct values.

    Why A is correct. A deterministic check of the tax against the region's rate catches a response that has the right shape but the wrong numbers, before it reaches the ledger.

    Why B is incorrect. Schema validation only confirms the structure of the JSON; it cannot tell whether the tax amount is correct for the region.

    Why C is incorrect. Asking the same conversation to check its own work is not independent, and it can repeat the same mistake.

    Why D is incorrect. Correcting at month-end lets a known-wrong entry sit in the accounts when it could have been rejected before it was written.

  11. Question 11

    1. Agents and Workflows

    A warehouse uses Claude for two jobs. Most requests are routine stock checks that always run the same database query. A few are stock discrepancies, where Claude must compare barcode scans, delivery notes and camera summaries, and the steps differ from case to case. Which design gives each job only as much freedom as it needs?

    • A. Send every request, including routine stock checks, to one agent that plans its own steps.
    • B. Handle stock checks with a fixed workflow and send discrepancies to an agent that plans its steps.
    • C. Handle both jobs with one fixed workflow that runs every comparison step on every request.
    • D. Use one agent for both jobs and let it write to the inventory system to correct stock counts.
    Show answer and explanation

    Answer: B

    Reasoning. Match the orchestration to the uncertainty of each job: a fixed workflow for the predictable path and an agent for the cases whose steps cannot be known in advance.

    Why A is incorrect. Routine stock checks always follow the same query, so letting an agent plan them adds cost and unpredictability with no benefit.

    Why B is correct. The fixed workflow keeps common stock checks predictable, and the agent is used only for discrepancies, where the steps genuinely vary.

    Why C is incorrect. Discrepancies need different steps from case to case, which one fixed sequence cannot handle, and running every comparison on routine checks wastes work.

    Why D is incorrect. One agent for everything gives routine checks needless freedom, and direct write access adds risk that neither job requires.

  12. Question 12

    5. Model Selection and Optimization

    A dashboard shows a long Claude analysis to the user while it is being written. After the response finishes, the backend must save one complete copy of it to the conversation history. How should the application receive and store the response?

    • A. Stream the response and save each text delta to the history as its own assistant message.
    • B. Open a WebSocket to the API, because the Messages API cannot stream over plain HTTP.
    • C. Send a non-streaming request with a progress spinner, then show and save the full response.
    • D. Stream the response over server-sent events, show each delta, and save the final message.
    Show answer and explanation

    Answer: D

    Reasoning. Streaming serves the live display, while the history should store one complete message only after the stream has finished.

    Why A is incorrect. Deltas are fragments of one response, so saving each as its own message breaks the conversation history into many partial turns.

    Why B is incorrect. The Messages API streams over HTTP using server-sent events, so a WebSocket is not needed.

    Why C is incorrect. A non-streaming request cannot show the analysis while it is being written, which the dashboard requires.

    Why D is correct. Server-sent events let the dashboard show text as it arrives, and saving the accumulated final message keeps one complete record.

    Source: platform.claude.com

  13. Question 13

    7. Security and Safety

    A Claude Code PreToolUse hook checks shell commands. When a command touches the secrets/ directory, the hook prints "blocked" and exits with code 0. Traces show the command still runs. What change and test would make this a working guardrail?

    • A. Have the hook write its warning to a log file, then check the log after a test run.
    • B. Move the check to a PostToolUse hook and test that it reports the command.
    • C. Add a system prompt rule not to touch secrets/, then test it with sample commands.
    • D. Return a blocking result, such as exit code 2, and test that the files are untouched.
    Show answer and explanation

    Answer: D

    Reasoning. A hook guardrail works only if its result actually blocks the call, and only a test that checks for the side effect proves it does.

    Why A is incorrect. The hook still exits with code 0, so the command still runs; the log only records that it was not stopped.

    Why B is incorrect. A PostToolUse hook runs after the command, so the secrets have already been accessed when it fires.

    Why C is incorrect. A prompt rule depends on the model's compliance, and the hook still allows the command to run.

    Why D is correct. Exit code 2 tells Claude Code to block the tool call, and a test that checks the secrets directory proves the command never ran.

  14. Question 14

    8. Tools and MCPs

    Your application defines a check_stock tool that your own code implements. Claude returns a response with stop_reason set to tool_use and a tool_use block asking for a stock lookup. What should your application do next?

    • A. Wait for Claude's next message, since Claude has already queried the inventory service on its own.
    • B. Validate the input, run the lookup, and return a tool_result with the matching tool_use_id.
    • C. Run the lookup and send the result to Claude as plain text at the start of a new conversation.
    • D. Run the lookup and add its result to the system prompt of the next request sent to Claude.
    Show answer and explanation

    Answer: B

    Reasoning. Tool use is a protocol: Claude requests the call, and the host validates it, runs it and returns a correlated tool_result.

    Why A is incorrect. Claude only requests a client tool; your code must run it, so no result arrives unless your application supplies it.

    Why B is correct. Client tools run in your code, and the tool_result block with the matching tool_use_id continues the same tool exchange.

    Why C is incorrect. A new conversation loses the request that asked for the lookup, so Claude cannot connect the result to its tool call.

    Why D is incorrect. The result belongs in a tool_result block in the conversation; moving it into the system prompt breaks the link between the request and its result.

    Source: platform.claude.com

  15. Question 15

    3. Claude Code

    A repository has six short conventions that should apply in every Claude Code session. It also has a 20-page database migration procedure that the team uses twice a year. How should the team set these up?

    • A. Put the six conventions in CLAUDE.md and package the migration procedure as a Skill.
    • B. Put both in CLAUDE.md so Claude always has the migration procedure available.
    • C. Put both in each developer's personal user settings so everyone has a copy.
    • D. Put the conventions in a subagent's system prompt and link the procedure from it.
    Show answer and explanation

    Answer: A

    Reasoning. Keep always-on guidance short in CLAUDE.md, and package long, occasional procedures so they load only when needed.

    Why A is correct. CLAUDE.md keeps the short conventions in every session, and the Skill loads the long procedure only when a migration is under way.

    Why B is incorrect. CLAUDE.md is loaded in every session, so a 20-page procedure used twice a year would take up context almost all the time for no benefit.

    Why C is incorrect. Personal settings are not shared or reviewed through the repository, so copies drift and new contributors do not get them.

    Why D is incorrect. A subagent's prompt applies only when that subagent runs, so the conventions would not reach every session.

  16. Question 16

    2. Applications and Integration

    Two teams work on a shared service that extracts order details with Claude. One team changes the JSON schema of the service's response; the other changes how the service retries failed calls. Each branch passes its own tests, but the merged code fails. Which TWO practices would most directly prevent this kind of failure?

    Choose two.

    • A. Let each team keep its own copy of the response schema in its branch until the release.
    • B. Add contract tests that check the shared response format that both teams depend on.
    • C. Run each branch's own test suite twice before merging to catch any intermittent failures.
    • D. Require both teams to review any change to the shared interface before it is merged.
    Show answer and explanation

    Answer: B and D

    Reasoning. The failure happens at an interface both teams share, so the fixes are an executable check of that interface and review of changes to it by both teams.

    Why A is incorrect. Separate schema copies are what allowed the two branches to drift apart and fail together after the merge.

    Why B is correct. Contract tests check the shared response format directly, so a change that breaks the other team's assumptions fails before the merge.

    Why C is incorrect. Each branch already passes its own tests; running them again does not test how the two changes interact.

    Why D is correct. Cross-team review makes one team's interface change visible to the other before it is accepted.

  17. Question 17

    6. Prompt and Context Engineering

    An agent reviewing a long legal case is close to its context limit, mostly because of raw results from searches it has already finished. The final report still needs three source document IDs, and a partner's approval is still pending. When the conversation is compacted, what must the summary keep?

    • A. The three source document IDs, the decisions made so far, and the pending approval.
    • B. The full search results, so the report can quote them, with the decisions left out.
    • C. Only the latest user message, since the earlier turns can be rebuilt if they are needed.
    • D. A short account of the searches and the decisions made, leaving out any open items.
    Show answer and explanation

    Answer: A

    Reasoning. Compaction should drop bulk the agent no longer needs while keeping the evidence it still depends on and any unfinished steps such as pending approvals.

    Why A is correct. These are the facts and open state the agent needs to finish the report and to wait for the partner's approval.

    Why B is incorrect. The raw search results are what filled the context; keeping them defeats the compaction, and dropping the decisions loses the case state.

    Why C is incorrect. The latest message alone loses the source IDs, the decisions and the pending approval that the report depends on.

    Why D is incorrect. Leaving out the pending approval can lead the agent to finish the report without the partner's sign-off.

    Source: platform.claude.com

  18. Question 18

    1. Agents and Workflows

    A payroll team always follows the same four steps: check the employee record, fetch approved hours, calculate deductions, and submit the payment. Any exception must stop for a person to review before submission. Which design gives the clearest control over this fixed sequence?

    • A. A coded workflow that runs the four steps in order and routes exceptions to human review.
    • B. An agent that is given the four steps as tools and decides which one to call next.
    • C. Four specialized agents, one per step, that each update the same payroll record when ready.
    • D. One prompt that lists every payroll policy and asks Claude to complete the whole process.
    Show answer and explanation

    Answer: A

    Reasoning. The steps are known and the human review is mandatory, so a deterministic workflow with an explicit exception branch is the right foundation.

    Why A is correct. The workflow enforces the known order in code and sends exceptions to a person before anything is submitted.

    Why B is incorrect. Letting an agent choose the next step adds variation to a process whose order is already fixed.

    Why C is incorrect. Agents that update one record whenever they are ready can conflict and do not guarantee the required order.

    Why D is incorrect. A prompt can describe the rules, but it does not control the order of steps or force the exception stop.

  19. Question 19

    5. Model Selection and Optimization

    A company has two Claude endpoints. One pulls five fields from invoices and must respond within one second. The other combines conflicting audit evidence into findings; a missed item there is costly, but speed matters less. How should the team choose models for them?

    • A. Test candidate models on each workload and pick a model for each endpoint from the results.
    • B. Use the most capable model for both endpoints so that neither workload loses any accuracy.
    • C. Use the fastest model for both endpoints and add a second review pass for the audit findings.
    • D. Pick one model for both endpoints based on its score on a widely used public benchmark.
    Show answer and explanation

    Answer: A

    Reasoning. Model choice is workload-specific: each endpoint's model should be chosen from measured quality, latency and cost on that endpoint's real task.

    Why A is correct. Testing each workload separately lets the team meet the invoice endpoint's latency target and the audit endpoint's quality need, with different models if needed.

    Why B is incorrect. The most capable model may miss the one-second target on simple invoice extraction and costs more than that task needs.

    Why C is incorrect. A fast model may miss conflicting evidence, and a second pass by the same kind of model does not guarantee the audit quality the team needs.

    Why D is incorrect. A public benchmark does not measure either of these tasks, so it cannot show which model meets each endpoint's requirement.

  20. Question 20

    7. Security and Safety

    An agent reads project issues through an MCP resource. One issue description contains instructions telling the agent to export all customer records. The agent is allowed to read issues, but exporting customer data requires separate authorization. How should the application handle this?

    • A. Treat the text as a valid request, because it came from the company's own MCP server.
    • B. Let Claude judge whether the author of the issue has the authority to request an export.
    • C. Treat the issue text as untrusted data and enforce export authorization in the backend.
    • D. Give the issue tool its own database credential so that it can check the author's role.
    Show answer and explanation

    Answer: C

    Reasoning. Untrusted content and the authority to act must be separated at a boundary the backend enforces, not left to the model's judgment.

    Why A is incorrect. Arriving through the company's MCP server does not make issue text an authorized instruction; anyone who can file an issue can write it.

    Why B is incorrect. Claude cannot verify who wrote the text or what they are allowed to do, and persuasive text can mislead it.

    Why C is correct. Claude can still read and summarize the issue, while the backend refuses any export that lacks the required authorization.

    Why D is incorrect. Giving the tool broader database access increases what a successful injection could reach, and it does not enforce export authorization.

    Source: modelcontextprotocol.io

Free practice vs paid Timo enrollment

FeatureTimoPractice-only sites
Free 20-question practice exam, no sign-upFreeVaries
Full-length mock exams for all four Claude certificationsWith paid enrollment: 20 exams, 1,180 questionsVaries
Register for official Claude examsWith paid enrollment: you register under Amotion AI, which is Certified in the Claude Partner NetworkNot offered
OpenAI learningWith paid enrollment: OpenAI partner courses and badges for ChatGPT, Codex and APINot offered
Expert profile and job matchingWith paid enrollmentNot offered

Timo is a brand of Amotion AI. Amotion AI is Certified in the Claude Partner Network and an OpenAI Select Partner.

Claude exam fees are paid separately to Anthropic when you book an exam. Joining Timo does not guarantee certification, a project or income.

Enroll to get 5 full-length CCDV-F mock exams

100+ Claude and OpenAI certified and ready for AI work through Timo

Claude Certified Associate Foundations badge issued by AnthropicClaude Certified Architect Foundations badge issued by AnthropicClaude Certified Developer Foundations badge issued by AnthropicClaude Certified Architect Professional badge issued by Anthropic

Sample questions with explanations

Validate extracted invoice fields before use, then separately check their accuracy against the invoice.

This section has three original worked sample questions for Claude Certified Developer – Foundations (CCDV-F). They are independent study material, not official Anthropic questions, recalled exam content, a full timed exam, or a prediction of your result. Choose an answer before reading each explanation, then identify which part of the application must enforce it.

Developer practice should help you locate errors in both the model’s response and the software around it. The questions focus on clear inputs, enforced permissions, validated outputs and recovery paths that preserve what actually happened.

A Claude application tells a customer an item is out of stock. The sentence is clear, but the inventory service never returned a stock count: its request timed out. The defect began before Claude wrote the answer, when application code treated a failed request as an empty result.

Timo is run by Amotion AI. These original Developer practice questions focus on where application code must enforce permissions, validate data and preserve a failed tool call.

What you are practising at Developer level

CCDV-F concerns building and integrating Claude applications, agents, and workflows. The provider's Developer Foundations guide describes areas including integration, testing, debugging, security, model choice, and the instructions and context supplied to the model. The Timo Developer Foundations guide summarises the role.

Use the provider’s certification listing and current guide to confirm eligibility and assessment details before planning your exam.

The questions focus on implementation responsibilities. A tool is a function the application makes available for Claude to request, such as an order lookup. Its contract defines the inputs accepted, the results returned, and the errors callers must handle. A good contract makes the safe behaviour explicit, while application code enforces it.

Practice question 1: a safer tool contract

An authenticated customer uses an order-support agent that can call get_order_status. Authentication means the application has verified the customer's identity through its sign-in process. The tool's first version accepts one free-text field called details. Claude sometimes includes several numbers in that field, and the tool selects the wrong order.

The customer should be able to read only their own orders, and no order contents may reach Claude unless that rule is met. The application holds the signed-in identity in its session. Any value Claude puts in a tool call comes from the chat, where a customer can type any order or customer number. Which change best improves the interface while enforcing that access rule?

Show answer and explanation

Best answer: D. A typed input has a defined shape, such as an order identifier string in the expected format, rather than an unrestricted description from which the tool must guess. That reduces ambiguity, but it does not establish permission. The service must also check that the requested order belongs to the authenticated principal: the user identity established by the trusted sign-in process.

That identity should come from the application session, not from a customer_id invented or repeated by Claude. The server can enforce ownership through an authorized lookup that combines the requested order ID with the signed-in customer's scope. No order contents should be returned to Claude unless the check succeeds.

A typed error is a distinct result the application can recognise, such as ACCESS_DENIED, rather than a vague sentence mixed with normal data. The application can then offer the appropriate recovery without exposing another customer's order. Where policy requires it, the user-facing wording can avoid revealing whether that order exists.

Why the alternatives are weaker: A sends the order record to Claude before anyone checks the owner, so another customer's order has already reached Claude even if the reply is blocked. B makes the field less ambiguous, but nothing in it checks that the order belongs to the signed-in customer. C checks the order against a customer_id that Claude took from the chat, where the customer can type any number. A model-supplied customer identifier is not evidence that the signed-in user may access the order.

A tool request passes server-side identity and ownership checks before returning an authorized record or a distinct error.
Figure 1. Enforce identity and ownership checks in the application before returning a record.

Practice question 2: structured output at an API boundary

A service asks Claude to extract invoice fields for another application. The receiving application expects JavaScript Object Notation (JSON), a structured text format made of named fields and values, and requires dates in a particular format. Most responses are usable, but some include an extra explanatory sentence or an unsupported date representation.

The receiving application cannot convert other date formats or remove extra text, so it needs one record per invoice that already matches its format. Any invoice that cannot be extracted in that format must be flagged the same day for a person to check. An application programming interface (API) defines how software components communicate. Its boundary is where information passes from one component to another under that contract. Which implementation provides the strongest protection at this boundary?

Show answer and explanation

Best answer: A. A schema defines the expected fields, types, and restrictions. The validator checks the returned data against those rules before it enters the consuming workflow. Parsing only establishes that text can be read as JSON; validation establishes whether that JSON meets the contract.

For instance, a response can be valid JSON while containing a date the receiving service cannot interpret. A required key can also be present with the wrong type or an unusable value. The application should distinguish those conditions rather than treating successful parsing as acceptance.

Some failures are correctable: the service may ask for a response in the required format and validate it again. Keep that retry bounded so persistent failures do not create an endless loop. If the source invoice itself has an ambiguous date, a formatting retry should not guess its meaning. Route that uncertainty for review. Structural validity also does not prove the extracted amount or date matches the invoice; source accuracy remains a separate check where the workflow requires it.

Why the alternatives are weaker: B hands dates to the receiving application to convert, but the stem says it cannot convert other date formats, and checking that keys exist does not check their values. C gives Claude a helpful example, but nothing checks the dates, and a failed invoice waits for a weekly engineering review instead of being flagged the same day. Handle parsing failures before downstream use, then retain the evidence for investigation. D keeps useful debugging evidence, but passes two versions to an application that needs one record in its own format. The producing service should provide one validated result or a clear failure state.

In the Claude API, structured outputs can constrain the response to a JSON schema; strict tool use constrains tool inputs. Use those features where supported, then check completion status and business meaning. A refusal or a response cut off at the token limit can require separate handling. A correctly formatted date such as 2026-04-05 still does not resolve whether an invoice showing 04/05/2026 meant 4 May or 5 April without a known date convention.

Practice question 3: isolating an intermittent failure

An agent occasionally tells customers that inventory is unavailable. The inventory tool can return a positive stock count, a confirmed count of zero, or a timeout when the service does not respond in time. The integration currently maps zero stock and timeout to the same “unavailable” state before sending the result to Claude.

Recorded request traces show that timeouts account for some of the misleading replies, and the inventory service sometimes stays unavailable for several minutes. The team wants customers never to be told an item is out of stock unless the service confirmed zero stock. Which test and code change should come first?

Show answer and explanation

Best answer: C. A zero-stock response is evidence about inventory. A timeout is evidence that the application did not obtain an answer. Once integration code collapses those outcomes into one value, Claude cannot reliably reconstruct the distinction.

An integration test exercises the connection between components. Here, controlled tool responses should verify that the application preserves a positive count, a confirmed zero, a timeout, and an invalid response as different outcomes. A malformed response, such as a stock count in an unexpected format, must not silently become zero either.

The user message can then follow the state: “There are five available” for a supported count, “This item is currently out of stock” for a confirmed zero, and “I couldn't check stock just now” for a failed lookup. Those examples illustrate the required distinction; exact wording can vary without changing the underlying meaning.

Why the alternatives are weaker: A gives Claude examples of a difference the integration has already erased, because zero stock and timeout reach Claude as the same state. B helps with short delays, but when the service stays down for several minutes both attempts fail and the customer is still told the item is out of stock. D finds affected customers after they have received the wrong answer; it does not correct the state mapping that causes it.

Available stock, confirmed zero stock and a timeout require different application states and messages.
Figure 2. A timeout is an unknown result and must not be reported as confirmed zero stock.

Use the Developer Foundations study guide to turn a missed implementation concept into a test you can demonstrate in a small application.

Apply the same distinction to a log search

An empty successful search means that no matching entries were returned within the query’s filters, time window and accessible sources. It does not prove that no event happened or that no logs were recorded. A permission error establishes neither presence nor absence.

Tool outcomeWhat the application may report
Success; zero matches in service A, 10:00–10:05 UTCNo matching entries were returned for that service and time window.
Access deniedThe application could not inspect that log source.
TimeoutThe query did not finish; the matching entries remain unknown.

Keep the outcome and query scope in the tool result. The Claude Messages API supports tool execution errors through is_error. Application code must still supply the correct status; an error flag cannot repair a timeout that your integration already converted into an empty success.

How to review your result

For every question, identify the input or output contract, the possible failure, and the layer responsible for handling it. In the order example, ownership belongs at the server boundary. In the invoice example, acceptance belongs in validation before downstream use. In the inventory example, the integration must preserve the tool outcome before text generation.

Then name a test that would fail under the original design and pass under the revised design. For ownership, use a signed-in test customer requesting another test customer's order. Verify that the agent receives no protected contents. For inventory, hold the prompt constant while supplying a timeout fixture. A fixture is a controlled sample response used to make the case repeatable.

Build one small preparation exercise

This Python example isolates the inventory-state mapping. It uses invented tool responses and makes no API request. Run it locally, then use the same cases against your own integration.

def stock_state(reply):
    if not isinstance(reply, dict):
        return "invalid_response"
    status = reply.get("status")
    if not isinstance(status, str):
        return "invalid_response"
    if status == "ok":
        count = reply.get("count")
        # Reject booleans, strings and negative counts.
        if type(count) is not int or count < 0:
            return "invalid_response"
        return "in_stock" if count > 0 else "out_of_stock"
    return {
        "timeout": "unknown",
        "denied": "access_denied",
    }.get(status, "invalid_response")

cases = [
    ({"status": "ok", "count": 5}, "in_stock"),
    ({"status": "ok", "count": 0}, "out_of_stock"),
    ({"status": "timeout"}, "unknown"),
    ({"status": "denied"}, "access_denied"),
    ({"status": "ok", "count": "0"}, "invalid_response"),
    ({"status": "ok"}, "invalid_response"),
    ({"status": "ok", "count": -1}, "invalid_response"),
    ({"status": "ok", "count": False}, "invalid_response"),
]
for reply, expected in cases:
    assert stock_state(reply) == expected, (reply, expected)
print("8 state-mapping checks passed")

The checks establish only the behaviour of this small mapping function. They do not test authentication, network handling, Claude or a production inventory service. In an integration test, also inspect the final message: a denied request must reveal no protected stock data, and a timeout must never become an out-of-stock claim. Hold the prompt constant while changing the controlled tool result so you can locate the first step that changes its meaning.

Retain the tool response, interpreted state and final message as separate test evidence. Use the Claude certification readiness checklist to choose further preparation that explains those implementation boundaries.

How to review your practice exam result

Register for the CCDV-F exam · how to get Claude certified

CCDV-F practice exam FAQs

Is this a complete CCDV-F practice exam?

No. It is an independent 20-question practice exam with three worked sample questions. It does not claim full blueprint coverage.

Do these questions come from the live exam?

No. Timo wrote these scenarios independently and does not publish recalled, copied, or protected exam items.

What should I practise beyond multiple-choice questions?

Build a small integration with a narrow tool contract, server-enforced access, validated output, and controlled failures. Show both what the application knows and what the user sees.

Should I memorise SDK methods?

A software development kit (SDK) provides tools and methods for building an integration. Use the current provider guide to set your study scope. Alongside relevant product details, practise explaining where permissions are enforced, why an output is accepted, and how an operation recovers from failure.

Can a high practice score predict whether I will pass?

No. A 20-question practice exam cannot reproduce the breadth or conditions of the official exam. Review the questions you missed and any correct answers you guessed. Study those topics before another attempt.

How can Timo help me prepare for CCDV-F?

Use these worked questions and the linked Developer study guide to practise authorization, validated extraction and distinct tool-result states. Keep a small test showing the tool result, application state and user message.

For Timo’s learning route, read the current enrollment, agreement and account process, then submit your profile for review. Enrolled consultants sign a consulting agreement with Amotion AI, which is Certified in the Claude Partner Network, register for their Claude exam with their Amotion AI consultant email, and use their expert profile and Timo Scout AI to find enterprise AI projects. Provider eligibility and exam requirements still apply; completing Timo practice does not award an Anthropic credential.

How many questions are on the CCDV-F exam?

The CCDV-F exam has 53 questions in 120 minutes. You need a scaled score of 720 out of 1,000 to pass.

Are there CCDV-F exam dumps?

Dumps claim to be recalled live exam questions. Anthropic's certification policy treats cheating and theft of exam content as misconduct that can lead to an invalidated result. Timo writes original practice questions and does not publish, buy or use recalled exam questions.

How do I book the CCDV-F exam?

Register and pay in Anthropic Partner Academy with a Claude Partner Network account, then book with Pearson VUE. See the registration steps.

More Claude practice exams

See average practice scores by exam and country from recorded Timo attempts.

Also: GH-700 practice test for GitHub Certified: Agentic AI Business Professional.

Latest Claude jobs

225 open jobs ask for Claude skills. Updated 7 Nov 2026.

  1. Lead Product Manager, Agentic CommerceImprint

    San Francisco; New York City; San Francisco · Remote · Posted today

    $190k to $210k a year

    AI agentsLLMs and generative AIClaude and Anthropic

  2. Senior AI/ML EngineerTempo

    Canada; United States · Remote · Posted today

    AI agentsLLMs and generative AIRAG and retrievalMCP

  3. Staff+ Software Engineer, STEMAnthropic

    San Francisco, CA | New York City, NY | Seattle, WA · Posted today

    EvaluationsClaude and AnthropicOpenAI and GPT

  4. AI Enablement LeadCrux Climate

    Remote (US) · Remote · Posted 1 day ago

    $126k to $145k a year

    Claude and Anthropic

  5. AI Operations EngineerCoast

    New York, NY · Posted 1 day ago

    $150k to $180k a year

    AI agentsLLMs and generative AIMCPEvaluations

See all 225 Claude jobsBrowse all 1032 AI jobs