Pass the AIP-C01 Exam: Strategy, Mock Exam, and My Debrief (AWS GenAI Developer Pro, Module 16)

This is Module 16 of AWS GenAI Pro Mastery, a free 16-module course that takes you from your first Amazon Bedrock call to AWS-certified.

The night before the exam. You have built Relay: triage that emits clean JSON, a Knowledge Base that cites its sources, an agent that calls tools and escalates safely, a guardrail that blocks the injection, a dashboard that shows the cost per ticket. You have seen all five exam domains in code that runs. By every measure that matters at work, you know this material.

And there is still a knot in your stomach. Not because of the content — you wrote the content. It is the format. 75 questions in 180 minutes is about 2.4 minutes each, on scenarios that take real reading. Two of the four question types — ordering and matching — do not exist on classic AWS associate exams, so you have never seen them under a clock. Knowing how to build Relay and passing a three-hour Professional exam are two different skills, and the gap between them is everything this module closes.

Here is the pain this module fixes: you can know the material cold and still fail the AIP-C01 if you meet the format for the first time on exam day. By the end, you will know the real format, have a passing strategy, have sat a weighted mock exam that tells you — per domain — exactly what to re-read, and have read my debrief of the real thing.

In this module

You’ll learn how to:

Understand the real AIP-C01 format: 75 questions / 180 minutes, the four question types (multiple choice, multiple response, ordering, matching), and compensatory scoring (a scaled score of 100–1,000, passing score 750, no per-section minimum).
Strategize the sitting: ~2.4 min/question, flag-and-return, distractor elimination, and the wording traps that flip the right answer.
Use the official prep resources — exam guide, Skill Builder exam-prep plan, Official Practice Question Set — and know what each is worth.
Self-assess with a weighted mock exam (30+ questions sampled in the real domain proportions) and a per-domain readiness grid.
Review with surgical focus: map each weak domain to the exact modules to re-read, so you revise what counts instead of re-reading everything.

You’ll self-assess: a weighted mock exam and a per-domain review map that tells you exactly what to re-read before you book.

Exam domains covered: all five domains, weighted — D1 31% · D2 26% · D3 20% · D4 12% · D5 11%. The mock exam samples them in these proportions.

D1 — Foundation Model Integration, Data Management, and Compliance — 31%
D2 — Implementation and Integration — 26%
D3 — AI Safety, Security, and Governance — 20%
D4 — Operational Efficiency and Optimization for GenAI Applications — 12%
D5 — Testing, Validation, and Troubleshooting — 11%

Prerequisites: Modules 1–15. Relay v1.0 is built, hardened, evaluated, observed, demonstrated, and tagged — you have met every domain in running code.

Where you are in the build

✅ M1–M14 — Relay triages, answers from a Knowledge Base with citations, acts through tools and an agent, is guarded and PII-redacted, ships behind an API with CI/CD, knows what every ticket costs, evaluates itself on a golden set, and is observed in production.
✅ M15 — the capstone: Relay v1.0 assembled, hardened, reviewed against the Generative AI Lens, proven on a costed 20-ticket run, tagged, and torn back to ~$0/month.
👉 M16 — you are here, the last one. You’ve built Relay; now get certified. Strategy, a weighted mock exam, my debrief.

Relay before this module: built and demonstrated, never confronted with the exam. Relay after: unchanged — there is nothing to code. This module changes you, from builder to exam-ready.

The real format: 75 questions, 180 minutes, two new question types

The fear the night before is rarely the content. It is the shape of the test. So let us pin the shape down, sourced to the documents that own it — not to a blog, and never to a dump.

The numbers. Per the official AIP-C01 exam guide, the exam contains 75 questions: 65 scored questions that affect your result plus 10 unscored questions that AWS is piloting for future exams. The unscored ten are not flagged on screen, so you treat all 75 as real. Unanswered questions are scored as incorrect, and there is no penalty for guessing — meaning you should never leave a question blank. Per the AWS certification page, the exam runs 180 minutes, costs 300 USD (as of June 2026), and is delivered through Pearson VUE at a test center or online with a remote proctor, in English, Japanese, Korean, and Simplified Chinese.

The scoring. Your result is a scaled score from 100 to 1,000; the passing score is 750 (exam guide). Crucially, the exam uses a compensatory scoring model: per the exam guide, you do not need to achieve a passing score in each section — you need to pass only the overall exam. A weak domain can be carried by your strong ones. Your score report may show a per-section classification of strengths and weaknesses, but that table is feedback, not a set of gates. (More on the misconception this breeds below.)

The four question types. This is where the AIP-C01 differs from the associate exams most people sat first. Paraphrasing the exam guide’s definitions:

Question type	What defines it	How to attack it
Multiple choice	One correct response, three distractors.	Eliminate two distractors on a single out-of-scope keyword, then decide between the last two on the superlative in the stem.
Multiple response	Two or more correct out of five or more options; you must select all correct ones — no partial credit.	Do not half-answer. Judge each option independently as true/false against the scenario; one wrong toggle loses the whole question.
Ordering	Select and sequence 3–5 responses to complete a task; correct order required, no partial credit.	Solve the logical sequence first on the scratch board (dependencies, causal order), then map it to the UI.
Matching	Match a list of responses to 3–7 prompts; all pairs must be correct.	Anchor the pairs you are certain of, then reduce the rest by elimination.

Two of these — ordering and matching — are new relative to classic AWS exams, and both are all-or-nothing. That property is the trap. An ordering question is not “pick the right answers”; it is “pick the right answers and put them in the one correct sequence.” A matching question is not four mini multiple-choice questions; it is one question that is only right when every pair is right. Treat them as fancy multiple choice and you bleed points you did not have to lose.

⚠️ Common misconception: “You must pass each domain to pass the exam.” False. The scoring is compensatory (exam guide): only the overall 750/1,000 counts, and there is no per-section minimum. A domain you find hard can be compensated by the four others — which is exactly why your study time should follow the domain weights, not spread evenly. A second, quieter trap: “ordering and matching are just dressed-up multiple choice.” Also false — both are all-or-nothing with their own logic (correct sequence / every pair correct), and approaching them as multiple choice is a straight loss of points with no partial credit to soften it.

A passing strategy

You have ~2.4 minutes per question on average, but the average lies. The D1 and D2 scenarios — 57% of the exam between them — are the long ones, the paragraphs that describe a whole architecture before they ask anything. The short D4 and D5 questions subsidise them. So budget time by domain, not by the clock alone, and never let one hard question eat the time three easy ones need.

Flag-and-return, in two passes. On the first pass, answer everything you are sure of and flag-and-return anything that makes you stop and think for more than about 90 seconds — mark it, put down a provisional answer (remember: no penalty for guessing, so never leave it blank), and move on. The second pass is for the flags, now with a calmer head and a known time budget. Never spend more than ~3 minutes on a single question on the first pass; a 180-minute exam punishes the person who dies on a hill at question 12.

Eliminate on keywords. On four- and five-option questions, two distractors are usually killable on a single out-of-scope word. A scenario that stresses low idle cost and offers “provisioned OpenSearch Serverless” has just handed you a wrong answer (~$174/month idle, as of June 2026, versus ~$0 for Amazon S3 Vectors). A scenario that wants a recent model and offers a bare regional model ID is wrong — recent models require an inference profile. These are the reflexes you trained building Relay; the exam rewards them.

Read the superlatives. The stem word changes the answer. “MOST cost-effective,” “LEAST operational overhead,” “FIRST step” — each turns a list of technically-valid options into a ranking problem with exactly one best answer. Underline the superlative before you read the options. Half the trap answers are correct in general and wrong for this stem.

These are not new skills. They are the trade-offs you already made: cost levers in Module 12, deployment choices in Module 11, the security order-of-operations in Module 10. The exam just asks them faster.

My honest read, going in

A word of honesty, because this series runs on it: I have not sat the AIP-C01 yet as I publish this, so I am not going to invent a war story about exam day. Everything here is what I can actually stand behind — from the official documents and from having built every domain in running code. When I do sit it, I will come back and enrich this from real experience. That is the whole bargain of the series: documented facts now, lived detail later, never fabrication in between.

On paper, the exam is an endurance test as much as a knowledge test: 180 minutes is three hours of dense reading, and the questions that cost you are rarely the ones you do not know — they are the ones you know but misread under time pressure. The architecture scenarios in D1 and D2 are long enough that skimming them is a real risk; the discipline that pays is reading the constraint in the stem (cheapest, fastest, least overhead, most secure) before you read the options, because that constraint is the whole question.

If you have built Relay, the content should hold no surprises. Every service the blueprint names, you have either deployed or deliberately reasoned about as theory: Converse and inference profiles (M1, M3), Knowledge Bases on S3 Vectors (M4, M5), Strands Agents and MCP (M7), AgentCore Runtime and Memory (M8), Bedrock Guardrails (M9), PII redaction and least-privilege IAM (M10), serverless deployment and CI/CD (M11), the cost levers (M12), LLM-as-a-judge and the golden dataset (M13), observability and the runbook (M14). The mock exam below tests exactly this surface.

My one prediction — the thing I will check hardest against reality later — is about emphasis. The agentic surface (Strands, AgentCore Runtime, MCP, the handoff-and-HITL pattern) is the freshest, most AWS-specific material on this exam, and the market read (07-RECHERCHE-MARCHE §5) is that it lands heavier than its raw blueprint percentage suggests. So if you are short on time, over-invest in D2 and the agent half of D1 — that is where building Relay pays the most exam points per hour. And the single thing I would tell my pre-exam self: trust the reflexes the labs trained — inference-profile-not-a-bare-ID, redact-at-the-edge, judge-≠-candidate, one grounding constant at 0.8. On a timed Professional exam, a trained reflex beats a half-recalled fact every time, and you trained these by shipping them.

Exam day logistics

What changes on the day is logistics, not knowledge. Book through your AWS Certification account, which hands you off to Pearson VUE. You choose a physical test center or an online proctored sitting. Online means a clear desk, an empty room, no notes and no second monitor, a webcam room-scan, and a photo-ID check before the proctor unlocks the exam — so if you take it online, clear your desk the night before, not five minutes before. Arrive (or log in) with a margin; the connection and ID checks eat time that is not part of your 180 minutes.

The Early Adopter badge is worth a mention: AWS has awarded an Early Adopter badge to the first cohort of people to pass a new certification, displayable on your Credly profile. If that program is running for AIP-C01 when you read this, it is a real reason to sit early rather than wait — confirm it on the certification page, since the offer and any cohort size are AWS’s to announce.

If you do not pass, it is not the end — AWS lets you retake after a waiting period (re-pay each attempt). The right move after a fail is mechanical: take the per-domain grid from this module, find the domain that dragged the score, re-read its mapped modules, and re-book. The grid below is built for exactly that loop.

⚠️ Re-verify before you book. A March 2026 AWS blog cited “85 questions / ~204 minutes” — that was the beta format. The reference for the live exam is the exam guide v1.0: 75 questions / 180 minutes. AWS already revised v1.0 once (the AgentCore integration in March 2026), so confirm the question count, time, price, and domain weights on the certification page at the moment you book. If AWS has moved them, trust the live page over this article.

The mock exam

No lab this time — there is nothing to deploy, nothing to code, no AWS resources, and so $0 of cost and nothing to tear down. The deliverable is this weighted mock exam plus the self-assessment grid that follows it.

Thirty-two questions, sampled in the real domain proportions: roughly D1 ten, D2 eight, D3 six, D4 four, D5 four. The value is the fidelity, not the volume — these mirror what the exam over-tests. Two questions use the new formats (one ordering, one matching) so you meet them before exam day; the rest are multiple choice and multiple response.

Every question is an original, CloudCart/Relay-flavored scenario written from this course and the exam-guide vocabulary — never copied from a dump (that violates the NDA and teaches you nothing). Answer all 32, then read the grouped answer key below them. Each explanation points to the module that covered it, which feeds the review grid.

How to take it: cover the answer key, give yourself ~75 minutes (the real per-question pace), flag-and-return as you would on the day, and write your letter answers down per domain so you can score by domain afterward.

Domain 1 — Foundation Model Integration, Data Management, and Compliance (Q1–Q10)

Q1 (multiple choice). A new Relay tier needs Amazon Nova 2 Lite for complex answers. A developer hardcodes amazon.nova-2-lite-v1:0 and the on-demand call fails with “Invoke with an inference profile.” What is the MOST correct fix?

A. Open a “request model access” form for the model.
B. Call the model with InvokeModel instead of the Converse API.
C. Use the cross-Region inference profile ID (e.g. us.amazon.nova-2-lite-v1:0) via relay/config.py.
D. Switch the Region to the model’s home Region.

Q2 (multiple choice). Relay’s triage.py must return a Triage object with exactly intent, priority, and sentiment, and nothing free-form. Which approach is MOST reliable in production?

A. Parse the model’s prose with a regex and hope the keys appear.
B. A Prompt Management template plus Triage.model_validate_json with one validation retry.
C. Raise the temperature so the model is more creative about formatting.
D. Ask the model to “please return JSON” with no schema enforcement.

Q3 (multiple choice). CloudCart wants Relay to answer from its private docs with citations and the LOWEST idle cost. Which retrieval backing is the best fit?

A. A Bedrock Knowledge Base on Amazon S3 Vectors.
B. A provisioned OpenSearch Serverless collection kept always-on.
C. No retrieval — put all docs in the system prompt.
D. A relational database with LIKE queries.

Q4 (multiple response). Which TWO are true about chunking and embeddings for Relay’s ingestion pipeline? (Choose two.)

A. The same embedding model and dimensionality must back both the DIY index and the KB-owned index.
B. Larger chunks always improve retrieval precision.
C. Chunking strategy is a measurable trade-off you should benchmark on a question set.
D. Embeddings are generated through the Converse API.
E. The vector bucket must sit in a different Region from the data bucket.

Q5 (multiple choice). A compliance reviewer asks where Relay enforces that customer PII never reaches a foundation model. At which point in the pipeline does the redaction belong?

A. After the FM call, before storing the answer.
B. At the intake edge, before any FM call including vision.
C. Only inside the guardrail’s PII filter at generation time.
D. In the CI/CD pipeline before deploy.

Q6 (multiple choice). CloudCart adds Korean docs and customers. Relay’s retrieval quality on Korean queries drops. Which lever is the FIRST to evaluate?

A. Increase the smart-tier model’s temperature.
B. Add a reranker to re-score the retrieved passages.
C. Provision more Lambda concurrency.
D. Double the guardrail’s word filters.

Q7 (multiple response). A customer uploads a screenshot of an error with their email address visible. Which TWO statements about Relay’s multimodal intake are correct? (Choose two.)

A. The screenshot is read with a vision-capable model through the Converse API content blocks.
B. The email in the image is exempt from redaction because it is “just an image.”
C. The vision read can use a bare regional model ID instead of an inference profile.
D. Vision requires switching relay/llm.py to InvokeModel.
E. The attachment summary is appended to the normalized ticket.

Q8 (multiple choice). Which statement about Relay’s model-ID governance is correct?

A. Each module may hardcode its own model ID where it is convenient.
B. Model IDs live only in relay/config.py, mapped tier→inference profile.
C. Bare regional IDs are the recommended default for recent models.
D. The judge model and the candidate model should be the same for consistency.

Q9 (multiple choice). CloudCart’s legal team requires that Relay’s answers stay grounded in approved documentation and never invent policy. Which control directly addresses grounding?

A. IAM least-privilege roles on the Lambda functions.
B. A contextual-grounding check that sets Answer.grounded and escalates ungrounded answers.
C. Encrypting the S3 bucket at rest.
D. Raising the API Gateway throttle limit.

Q10 (multiple choice). Relay must keep European customer data resident in-Region while still running on Bedrock. For an exam scenario, which is the appropriate THEORY-level mechanism to name for keeping inference at the edge / in a specific locality?

A. AWS Outposts / Wavelength for locality-bound deployment.
B. Cross-Region inference profiles that fan out to any Region.
C. Public internet egress to a global endpoint.
D. Disabling encryption to reduce latency.

Domain 2 — Implementation and Integration (Q11–Q18)

Q11 (multiple choice). Relay’s agent needs to look up a CloudCart order and create a ticket through an external service. Which integration pattern does the course use?

A. Hardcode CloudCart’s database credentials into the agent.
B. A Strands Agents ReAct agent calling tools, with lookup_order/create_ticket exposed over an MCP server on AWS Lambda.
C. Bedrock Agents classic with an inline OpenAPI blob.
D. A cron job that polls CloudCart every minute.

Q12 (ordering). CloudCart submits a refund ticket through Relay’s public API. Put these steps in the correct end-to-end order. (Select and sequence.)

worker_handler consumes the SQS message and invokes the deployed agent.
POST /tickets returns 202 with a ticket_id and enqueues the message on SQS.
The agent reaches the refund step and parks the ticket in awaiting_approval (HITL gate).
A human approves via POST /tickets/{id}/approve, and the action executes.

Q13 (multiple choice). Relay deploys behind API Gateway with a worker Lambda invoked off an SQS queue. Why is POST /tickets designed to return 202 Accepted immediately instead of the final answer?

A. To hide the answer from the customer.
B. Because agent processing can exceed a synchronous request’s budget; the queue decouples intake from processing.
C. Because 202 is cheaper than 200.
D. Because API Gateway cannot return 200.

Q14 (multiple choice). Which statement about deploying the agent is correct for Relay’s architecture?

A. worker_handler re-implements the agent logic inline.
B. worker_handler invokes the deployed agent through the frozen run.py / AgentCore Runtime contract.
C. The agent runs only on the developer’s laptop in production.
D. Each deploy rebuilds the agent from scratch in the Lambda.

Q15 (multiple choice). A refund action is sensitive and must not auto-execute. Which mechanism realizes the human-in-the-loop gate end to end?

A. A guardrail topic filter.
B. The awaiting_approval status plus POST /tickets/{id}/approve, with AgentAction.approved flipping from None to True.
C. An email to support with no state change.
D. Raising the model temperature for refunds.

Q16 (multiple response). CloudCart needs Relay’s API to scale predictably under bursty load without over-provisioning. Which TWO levers fit? (Choose two.)

A. Lambda reserved/provisioned concurrency on the hot handlers.
B. API Gateway request throttling.
C. Switching every call to the frontier model.
D. Running the agent on a single always-on EC2 instance.
E. Removing the SQS queue to answer synchronously.

Q17 (multiple choice). CloudCart wants non-engineers to consume Relay’s API and a UI generated from a contract rather than hand-wired. Which pairing fits (THEORY-level)?

A. An OpenAPI spec over the existing routes plus an AWS Amplify front end.
B. Direct database access for the support team.
C. A second copy of the agent per UI.
D. Embedding AWS credentials in the browser.

Q18 (multiple choice). A teammate proposes orchestrating Relay’s chains with LangGraph “because everyone uses it.” Within this AWS course’s stack, what is the correct framing?

A. Replace Strands Agents with LangGraph immediately.
B. The course’s agent stack is Strands Agents on Bedrock; LangGraph is not the AWS-native path taught here.
C. LangGraph is required for MCP.
D. LangGraph is the only way to do tool calling.

Domain 3 — AI Safety, Security, and Governance (Q19–Q24)

Q19 (matching). Match each safety/security concern to the Relay control that addresses it. (Match all pairs.)

Prompts:

Prompt-injection attempt in a customer message
PII text leaking to a foundation model
An over-permissive Lambda able to call any Bedrock action
Verifying who created or modified the guardrail (a bedrock:CreateGuardrail call) and when

Responses:

W. Least-privilege IAM role per component with explicit ARNs
X. Comprehend DetectPiiEntities redaction at the intake edge
Y. Bedrock Guardrails prompt-attack filter through converse()
Z. CloudTrail management-event audit

Q20 (multiple choice). Relay’s guardrail blocks most injection attempts in the attack suite, but two still slip through. What is the right interpretation?

A. The guardrail is broken and should be removed.
B. Guardrails reduce but do not eliminate risk; residual attacks are measured, not assumed away, and inform layered defenses.
C. Two passing attacks mean the model is compromised.
D. Run every request through the guardrail twice to reach 100%.

Q21 (multiple choice). Which statement about Bedrock Guardrails in Relay is correct?

A. The guardrail is wired in by adding a guardrail parameter to converse() without changing its signature.
B. Each model needs its own guardrail implementation.
C. Guardrails replace PII redaction entirely.
D. The guardrail must run as a separate model invocation through InvokeModel.

Q22 (multiple choice). A CloudCart auditor wants the record of every management API call (who invoked what, from which role). Which service provides it?

A. Model Invocation Logs (they carry prompt/response content, not the caller identity for management calls).
B. AWS CloudTrail management events.
C. The CloudWatch relay-ops dashboard.
D. The guardrail’s blocked-prompt log.

Q23 (multiple response). Which TWO are correct about Relay’s PII handling? (Choose two.)

A. Comprehend DetectPiiEntities masks by offset before any FM call.
B. The guardrail’s PII filter and intake redaction are the same thing.
C. Redaction runs before the vision read of an attachment.
D. PII is redacted only after the agent finishes.
E. PII redaction is optional because the model “won’t remember.”

Q24 (multiple choice). Relay’s IAM policies grant exactly the actions and resource ARNs each component needs, with zero wildcards. What governance principle is this, and why does the exam care?

A. Defense in depth via encryption only.
B. Least privilege — it bounds blast radius and is a Responsible-AI / security control the exam scores under D3.
C. Cost optimization.
D. High availability.

Domain 4 — Operational Efficiency and Optimization (Q25–Q28)

Q25 (multiple choice). CloudCart’s Bedrock bill doubled over a weekend with flat ticket volume. Which lever set BEST reduces per-ticket cost without dropping quality?

A. The auto complexity router plus prompt caching and semantic caching, with per-task tiering.
B. Provisioned throughput on the smart model for all traffic.
C. Running every ticket on the frontier model.
D. Sending all tickets to the fast tier regardless of difficulty.

Q26 (multiple choice). Relay backfills evaluations over thousands of historical tickets where latency does not matter. Which option is MOST cost-effective for that batch workload?

A. Interactive on-demand calls on the smart tier.
B. Batch inference and/or the Flex service tier (≈ −50%), used only for non-interactive work.
C. Provisioned throughput sized for peak.
D. The frontier model for accuracy.

Q27 (multiple choice). Where does Relay’s per-ticket cost number come from?

A. A flat estimate hardcoded in the article.
B. TicketRecord.cost_cents, populated from token usage times the per-tier price map defined in config.py.
C. The AWS invoice, read in real time.
D. The model returns its own price.

Q28 (multiple choice). Which statement about Flex / batch tiers is correct for Relay?

A. Flex is fine for interactive customer traffic.
B. Flex/batch (≈ −50%) is for non-interactive work only; a model that does not offer the requested tier degrades to its default and is billed at default.
C. Every model offers the Flex tier.
D. Batch inference doubles the token price.

Domain 5 — Testing, Validation, and Troubleshooting (Q29–Q32)

Q29 (multiple choice). Relay’s answers are error-free but getting vaguer over weeks. Every infra metric is green. Which signal catches this quality regression?

A. Lambda duration.
B. The golden dataset re-run in production and its grounding score.
C. API Gateway 5xx count.
D. SQS queue depth.

Q30 (multiple choice). Which design choice keeps Relay’s LLM-as-a-judge evaluation trustworthy?

A. The judge model equals the candidate model for consistency.
B. The judge model differs from the candidate to avoid self-preference bias; outputs are Pydantic-validated with one retry.
C. The judge runs at temperature 1.0 for variety.
D. The judge grades free-form prose with no schema.

Q31 (multiple choice). Relay’s regression gate fails a deploy when grounding drops below a threshold. Which value is that threshold, and where else does it appear?

A. 0.5 — used only in the gate.
B. 0.8 — the same constant reused as the M14 relay-ops grounding alarm and the escalation threshold.
C. 0.95 — set independently in three places.
D. There is no fixed threshold.

Q32 (multiple choice). A cost doubling with flat traffic most often points at which root cause, and what are the FIRST signals to check?

A. A Region outage; check the AWS status page.
B. An agent tool-calling loop burning tokens; check the dashboard and the agent traces, not the (weeks-late) invoice.
C. A DNS misconfiguration; check Route 53.
D. A schema change; check models.py.

Answer key

Read these only after attempting all 32. Each explanation names the module that covered it — use it to score by domain in the grid below.

Q1 — C. Recent models require a cross-Region inference profile (us./global.), held only in config.py; “request model access” disappeared with serverless auto-activation, and Converse — not InvokeModel — is the call path. (Module 1, Module 3.)

Q2 — B. Structured output is enforced with a Prompt Management template plus Pydantic validation (model_validate_json) and one validation retry — not regex, not higher temperature. (Module 2.)

Q3 — A. A Knowledge Base on S3 Vectors gives grounded, cited answers at ~$0 idle; provisioned OpenSearch Serverless bills ~$174/month idle (as of June 2026), and stuffing docs in the prompt drops grounding. (Module 4, Module 5.)

Q4 — A and C. Both indexes share the same Titan-1024 embedder and dims, and chunking is a measurable trade-off you benchmark. Larger chunks do not always help, embeddings use InvokeModel (not Converse), and the vector and data buckets sit in the same Region. (Module 4.)

Q5 — B. Redaction belongs at the intake edge, before any FM call including the vision read; the guardrail PII filter is a second layer, not the primary boundary. (Module 6, Module 10.)

Q6 — B. The reranker is the measured precision lever for retrieval quality; temperature, concurrency, and word filters do not address relevance ranking. (Module 5.)

Q7 — A and E. The screenshot is read via Converse vision content blocks and its summary is appended to the ticket. B is the trap — PII in an image is still PII, so the intake redaction runs before the vision read. C is wrong because the vision read still requires an inference profile (never a bare regional ID), and vision does not switch to InvokeModel. (Module 6.)

Q8 — B. Model IDs live only in config.py as a tier→inference-profile map; bare regional IDs fail on-demand, and the judge must never equal the candidate. (Module 3, Module 13.)

Q9 — B. Grounding is addressed by the contextual-grounding check that writes Answer.grounded and escalates ungrounded answers; IAM, encryption, and throttling are real controls for other risks. (Module 9.)

Q10 — A. For locality-bound inference, the THEORY-level mechanism to name is Outposts/Wavelength (edge/locality); cross-Region profiles do the opposite, and the other two are wrong on their face. (Module 11, data-residency theory box.)

Q11 — B. Relay uses a Strands ReAct agent calling tools, with CloudCart tools exposed over an MCP server on Lambda — not hardcoded credentials, not Bedrock Agents classic, not polling. (Module 7.)

Q12 — 2, 1, 3, 4. Intake returns 202 and enqueues; the worker consumes and invokes the agent; the agent parks the refund at the HITL gate; a human approves and the action executes. Correct sequence required — no partial credit. (Module 8, Module 11.)

Q13 — B. Agent processing can exceed a synchronous budget, so the queue decouples intake from processing and the API returns 202 immediately. (Module 11.)

Q14 — B. worker_handler invokes the deployed agent through the frozen run.py / AgentCore Runtime contract — it never re-implements the agent or runs it on a laptop in production. (Module 8, Module 11.)

Q15 — B. The HITL gate is the awaiting_approval status plus the POST /approve route, with AgentAction.approved flipping None → True. A guardrail or an email does not gate state. (Module 8, Module 11.)

Q16 — A and B. Lambda reserved/provisioned concurrency and API Gateway throttling are the predictable-scaling levers; the frontier model, an always-on EC2 box, and removing SQS all hurt. (Module 11.)

Q17 — A. Publish an OpenAPI contract over the existing routes and stand up an Amplify front end so clients are generated from the contract — not raw DB access or browser-side credentials. (Module 11, “where to go next.”)

Q18 — B. The taught stack is Strands Agents on Bedrock; LangGraph is not the AWS-native path this course teaches, and tool calling/MCP do not require it. (Module 7.)

Q19 — 1-Y, 2-X, 3-W, 4-Z. Injection → Guardrails prompt-attack filter; PII to FM → Comprehend redaction at intake; over-permissive role → least-privilege IAM; who-changed-the-guardrail (a management API call) → CloudTrail management events. (Runtime inference like bedrock:Converse is a data-plane call captured by model-invocation logging, not CloudTrail management events — that distinction is the trap.) All pairs must be correct. (Modules 9, 10.)

Q20 — B. Guardrails reduce but do not eliminate risk; residual passing attacks are measured and inform layered defense — you do not remove the guardrail or double-run it. (Module 9.)

Q21 — A. The guardrail is threaded in by adding a guardrail parameter to converse() with the signature unchanged; it is model-independent and does not replace intake redaction or require InvokeModel. (Module 9.)

Q22 — B. CloudTrail management events record who invoked which management API and when; invocation logs carry call content, not the management-caller audit. (Module 10, Module 14.)

Q23 — A and C. Comprehend masks PII by offset before any FM call, and redaction runs before the vision read. The intake redaction and the guardrail PII filter are distinct layers; redaction is not optional or after-the-fact. (Module 6, Module 10.)

Q24 — B. Explicit per-component ARNs with zero wildcards is least privilege — it bounds blast radius and the exam scores it under D3 (security/governance). (Module 10.)

Q25 — A. The auto router plus prompt and semantic caching with per-task tiering cuts cost while preserving quality; provisioning, frontier-everywhere, and fast-everywhere all trade wrong. (Module 12.)

Q26 — B. Batch inference and/or the Flex tier (≈ −50%) fit non-interactive backfill; interactive on-demand, peak-sized provisioning, and the frontier model are more expensive for the same work. (Module 12.)

Q27 — B. cost_cents is summed from token usage times the per-tier price map in config.py — not a hardcoded estimate, the live invoice, or the model itself. (Module 7 field, Module 12 populated.)

Q28 — B. Flex/batch (≈ −50%) is non-interactive only; a model lacking the requested tier degrades once to its default and is billed at default — no phantom discount. (Module 12.)

Q29 — B. Vague-but-error-free answers are a quality regression caught only by the golden-set re-run and its grounding score; every infra metric stays green. (Module 13, Module 14.)

Q30 — B. The judge must differ from the candidate (self-preference bias) and produce Pydantic-validated output with one retry — not the same model, not free-form, not high-temperature. (Module 13.)

Q31 — B. The threshold is 0.8, defined once and reused as the M14 grounding alarm and the escalation threshold — one constant, never a divergent literal. (Module 9, Module 13, Module 14.)

Q32 — B. A cost doubling on flat traffic usually means an agent tool-calling loop burning tokens; the first signals are the dashboard and the agent traces, because the invoice is weeks late. (Module 14.)

Exam corner: the self-assessment grid

This is the heart of the module. Score your mock per domain, then read the grid as a verdict — ready or review, with the exact modules to re-read. The rule: any domain below ~70% → re-read its mapped modules before you book. The mock samples each domain in its real weight, so a low domain score is a real signal, not noise.

Domain (official weight)	Mock questions	Ready if you scored	If you missed these, review
D1 — Foundation Model Integration, Data Management, and Compliance (31%)	Q1–Q10	≥ 7 / 10	Modules 1, 2, 3, 4, 5, 6
D2 — Implementation and Integration (26%)	Q11–Q18	≥ 6 / 8	Modules 7, 8, 11 (+ Module 3 streaming/routing)
D3 — AI Safety, Security, and Governance (20%)	Q19–Q24	≥ 5 / 6	Modules 9, 10
D4 — Operational Efficiency and Optimization (12%)	Q25–Q28	≥ 3 / 4	Modules 12, 14
D5 — Testing, Validation, and Troubleshooting (11%)	Q29–Q32	≥ 3 / 4	Modules 13, 14

The verdict is not a score guarantee — it is an estimate of where your gaps are. Then run the revision loop until every domain clears the line:

flowchart TD
    A[Take the weighted mock] --> B[Score each domain]
    B --> C{Any domain below ~70%?}
    C -->|Yes| D[Re-read that domain's mapped modules]
    D --> A
    C -->|No| E[Book the AIP-C01]

Per-domain readiness checklist. Before you book, you should be able to answer each of these without notes:

D1 (31%): Why does a recent model need an inference profile? How do you enforce structured output? When do you reach for a Knowledge Base over DIY retrieval, and what is the S3-Vectors-vs-OpenSearch-Serverless idle-cost trade-off? Where does PII redaction belong in the pipeline?
D2 (26%): Walk the full request path from POST /tickets to an approved refund. Why 202-plus-queue? How does the worker invoke the deployed agent, and how does the HITL gate work end to end?
D3 (20%): Which control answers injection, which answers PII-to-FM, which bounds blast radius, and which provides the management audit? Why do residual attacks stay measured rather than assumed away?
D4 (12%): Name the cost levers and when each applies (router, prompt/semantic caching, batch, Flex). Where does cost_cents come from? Why is Flex non-interactive only?
D5 (11%): Which signal catches a quality regression when infra is green? Why must the judge differ from the candidate? What is the 0.8 threshold and the three places it appears? What is the first thing you check on a cost doubling with flat traffic?

Key takeaways

The format, not the content, is the trap — ordering and matching are new, all-or-nothing, and reward a different reading than multiple choice.
Scoring is compensatory: aim for 750/1,000 overall; there is no per-domain minimum, so study by the domain weights.
Budget time by domain — D1 and D2 are 57% of the exam and the longest scenarios; flag-and-return in two passes, and never leave a blank (no penalty for guessing).
Multiple response, ordering, and matching give no partial credit — one wrong toggle, one wrong position, one wrong pair loses the whole question.
Use official prep only — the exam guide, the Skill Builder exam-prep plan, and the Official Practice Question Set — never a dump.
Score your mock per domain; any domain below ~70% tells you exactly which modules to re-read before you book.
Sit early if the Early Adopter badge is offered — and re-verify the live format on the certification page at booking time.
If you built Relay, over-invest your last hours in D2 and the agent half of D1 — the agentic surface (Strands, AgentCore, MCP) is the freshest, most AWS-specific material and rewards the labs you shipped.

Want the full AIP-C01 question bank and news of future courses in your inbox? Subscribe here — it’s free, like everything in this series. This mock exam is the public sample of that bank.

You built a production GenAI agent and you’re ready to certify — that’s the whole course. There is no Module 17; there is just you, the certification page, and a booking.

Links: ← Module 15 (the capstone) · Start at Module 1 · Course index

References

AWS Certified Generative AI Developer - Professional (AIP-C01) exam guide — the source of truth for question types, the 65-scored-plus-10-unscored split, the 100–1,000 scaled score, the 750 passing score, the compensatory scoring model, and the five domain weights (31/26/20/12/11%).
AWS Certified Generative AI Developer - Professional certification page — duration (180 minutes), price (300 USD, as of June 2026), Pearson VUE delivery (test center or online proctored), languages, and booking. Re-verify the format here before you book (the v1.0 guide superseded an 85-question beta).
AWS Skill Builder — AIP-C01 exam prep — the official exam-prep plan and the free Official Practice Question Set; the only practice questions worth your time besides this mock.
AWS GenAI Pro Mastery — course index — Modules 1–15 build Relay across all five domains; this module tests them. The review grid maps each weak domain back to the modules that cover it.