Question 55, 30 Minutes Left: How I Prepared for the AWS GenAI Developer Professional Exam
I passed the AWS Certified Generative AI Developer - Professional exam (AIP-C01), and on exam day I reached question 55 with about 30 minutes left, because this exam punishes skimming. Here is how I prepared: the materials I used, a four-step method for reading questions, managed versus custom knowledge bases, what each core service is actually for, the traps that came up again and again, and how I would pace it next time.
Series: AWS Certification Prep (1 article)
- 1Question 55, 30 Minutes Left: How I Prepared for the AWS GenAI Developer Professional Exam This article
I passed the AWS Certified Generative AI Developer - Professional exam (AIP-C01) recently. At one point I looked at the clock and I was on question 55 with about 30 minutes left.
I was reading every question deliberately, making sure every condition in it was covered before I committed to an answer. This exam punishes skimming. Most of the wrong options are technically real AWS features that answer part of the question, and the part they miss is usually one clause you read too quickly.
I was reading every question deliberately, making sure every condition in it was covered before I committed to an answer. This exam punishes skimming. Most of the wrong options are technically real AWS features that answer part of the question, and the part they miss is usually one clause you read too quickly.
This is the guide I wanted when I started: what the exam covers, what I studied, how I learned to read the questions, what each of the main services is actually for, and the traps that come up again and again.
The exam at a glance
- 75 questions, of which 65 are scored and 10 are unscored. You can't tell which are which.
- 180 minutes, which works out at 2.4 minutes per question.
- Scaled score from 100 to 1,000. You need 750 to pass.
- Multiple choice has one right answer out of four. Multiple response has two or more right answers out of five or more, and you must pick all of them to get any credit.
- No penalty for guessing, and unanswered questions are marked wrong. Never leave a blank.
- Scoring is compensatory, so you don't need to pass each domain. You need to pass the exam overall.
| Domain | Weight |
|---|---|
| 1. Foundation Model Integration, Data Management, and Compliance | 31% |
| 2. Implementation and Integration | 26% |
| 3. AI Safety, Security, and Governance | 20% |
| 4. Operational Efficiency and Optimization for GenAI Applications | 12% |
| 5. Testing, Validation, and Troubleshooting | 11% |
Domains 1 and 2 are 57% of the scored content between them. If your time is limited, that is where it goes.
The exam guide also lists what is out of scope: model development and training, advanced ML techniques, and data and feature engineering. This is an exam about building with foundation models on AWS, so don't spend a week on training theory.
What I used
The main course. Stéphane Maarek and Frank Kane's "Ultimate AWS Certified Generative AI Developer - Professional" course on Udemy, with its full-length practice exam. It follows the official exam guide closely and has hands-on labs, which matter for this exam because so many questions turn on what a specific API or parameter actually does.
QA learning platform. I had access through the AWS Community Builders programme and used it alongside the course.
AWS Skill Builder. AWS's own training platform, with official exam preparation material for this certification.
The official exam guide. Each domain lists tasks and skills, and many skills include a "for example" list of AWS services. Those lists are a good map of where answer options come from. I turned the whole guide into a checklist and rated myself on every skill: built it, know it but would hesitate between it and a neighbouring service, or couldn't pick it out of four options. The third group became my study plan.
The in-scope services list. It sits in the exam guide too. When I compared it with my practice material, a handful of in-scope services never appeared in any practice question at all, including Cost Explorer and Cost Anomaly Detection. Practice questions can only test what their authors wrote, so read the in-scope list yourself and fill the gaps from the docs.
AWS documentation, checked live. Whenever a practice explanation and my own understanding disagreed, I went to the current AWS docs and kept a log of what I checked. Bedrock changes fast. A few practice explanations had fallen behind the service, and the docs were right every time.
Hands-on work. I build and run a production generative AI system on AWS, including Bedrock fine-tuning, retrieval and evaluation. That helped most on the operational questions, where the trap is something you only learn by being caught by it, like an async job that says "accepted" long before the work is done.
How I read questions
Exam writers call the question text the stem: the scenario and the question above the answer options.
Partway through preparing, I went back through every practice question I'd got wrong and sorted the mistakes. I expected to find gaps in my knowledge. Mostly I didn't. In most cases I already knew the rule that decided the question. I had read the question in the wrong order.
The pattern was always the same. I read the stem, saw an option that sounded right, and then reread the stem looking for reasons to agree with it. The wrong options on this exam are written to match the most memorable phrase in the stem, so that habit picks the wrong answer again and again.
So I replaced my checklist with four steps, done in order on every question.
1. Find the constraint sentence before reading any option
Almost every stem has one sentence that acts as a filter rather than background: "with the least custom code", "without redeploying the API", "must not require client changes", "using a fully managed service". It's rarely the first sentence. Find it and hold it before your eyes reach the options, because once you've seen a plausible answer you'll read everything else to justify it.
Ask: what is this question forbidding?
2. If options share an opening, compare the endings
It's common for all four options to be identical for three or four lines and differ only in the final clause. Reading left to right means deciding on the part that's the same in every option, which by definition decides nothing. Ignore the shared part.
Ask: where do these options actually disagree?
3. Eliminate on violation, never select on match
Don't ask which option sounds right. Cross an option out the moment it breaks a constraint. A distractor usually satisfies one requirement very well and quietly fails another.
Ask: which constraint does each option break?
4. Check your pick against every constraint
An option that fails one requirement is out, however good it looks on the others. If you can't say what ruled out each of the other options, you haven't finished the question.
Ask: what ruled out each of the others?
These four steps took me longer per question. They were also what moved my practice results. More on the cost of that in the pacing section at the end.
Managed versus custom knowledge bases
This one deserves its own section, because the same question shape can have opposite answers depending on a single phrase.
Amazon Bedrock Knowledge Bases now come in two flavours. A custom knowledge base is the one most people know: you choose the vector store (OpenSearch Serverless, Aurora, and so on), the parsing, the chunking, and how retrieval runs. A fully managed knowledge base has the service manage those pieces for you. The two do not support the same APIs and options, and the exam leans on that.
What changes between them:
| Feature | Custom knowledge base | Managed knowledge base |
|---|---|---|
| Generating an answer | RetrieveAndGenerate, or Retrieve and then your own model call | Not RetrieveAndGenerate. The API reference says to use AgenticRetrieveStream or Retrieve instead |
| Breaking a question into sub-questions | Turn on query decomposition in RetrieveAndGenerate, or decompose it yourself (for example in Lambda), call Retrieve per sub-query and combine the results | AgenticRetrieveStream plans sub-queries, retrieves until it judges the evidence sufficient, deduplicates chunks, cites sources and streams its planning as trace events. Managed only |
| Chunking | All strategies, including semantic | Semantic chunking not supported |
| Parsing | Default, foundation model or Bedrock Data Automation parsing | Smart parsing by default. Foundation model and Bedrock Data Automation parsing not supported |
| Metadata filters | Full set | startsWith and stringContains not supported |
| Guardrails on agentic retrieval | Not applicable | Blocking only. Masking not supported |
A worked example
The ask. A team wants answers that break complex questions into sub-questions, show the planning steps, and cite sources, "using a fully managed knowledge base".
The tempting option.
RetrieveAndGenerate with query decomposition switched on. It sounds perfect, because it really does decompose queries.Why it's wrong.
RetrieveAndGenerate is barred from managed knowledge bases, and it doesn't stream planning traces. The answer is AgenticRetrieveStream.What flips it. Change one phrase so the team runs its own vector store, and the answer becomes decomposing the question yourself and calling
Retrieve per sub-query.When a knowledge base question appears, find out which flavour it is before you read the options.
What each service is for
Most wrong options on this exam are real services used for the wrong job. Knowing what each one is for, and what it isn't for, rules out options quickly.
Calling models
- Converse gives you one request shape across models. If the requirement is "swap models without changing the client code", it's Converse.
- InvokeModel takes a model-specific JSON body. It works, but every model family has its own format.
- ApplyGuardrail checks text against a guardrail without calling a model at all. That's how you reject input before any model is invoked.
- CountTokens estimates a request's token count before you send it. You don't need to call a small model to "estimate" it.
- Guardrails attach to Converse through
guardrailConfig. Header-based guardrails are for InvokeModel.
Retrieval
- Retrieve returns raw chunks with their metadata and relevance scores. Use it when you need to inspect or verify what was retrieved.
- RetrieveAndGenerate returns a generated answer with citations. Use it on custom knowledge bases when you want the answer and where it came from.
- Hybrid search combines vector search with search over the raw text. It's only supported for Amazon RDS, OpenSearch Serverless and MongoDB vector stores that have a filterable text field. Otherwise the query falls back to semantic search. Part numbers, codes and IDs are the classic case that needs it.
- Reranking reorders results that were already retrieved. It improves ordering. It can't find documents the search missed.
Chunking
There are four strategies, and you choose one when you connect the data source. You can't change it afterwards: a different strategy means a new data source.
- Default / fixed size splits into roughly equal chunks. With no configuration, it's 300 tokens with 20% overlap.
- Hierarchical matches on small child chunks and returns the larger parent chunk. Use it when you need precise matching but the answer needs the surrounding context.
- Semantic splits on meaning, so chunks don't break mid-thought. It fixes bad boundaries. It doesn't add surrounding context, and it isn't available on managed knowledge bases.
- None treats each file as one chunk. It only makes sense if you've already split your data into one record per file, which is custom preprocessing. A stem that says "without custom preprocessing" rules it out.
Keeping data current
- Sync (
StartIngestionJob) crawls a data source and picks up new, changed and deleted content. Third-party connectors such as Confluence use this route. - Direct ingestion (
IngestKnowledgeBaseDocuments) adds or updates individual documents without a sync. It's only available for S3 and custom data sources. On S3 sources, don't mix the two at the same time: changes indexed directly aren't written back to S3 and can be overwritten by the next sync.
Safety and privacy
Bedrock Guardrails is the policy engine for prompts and responses, applied to both input and output. Its filters each do a different job:
| Filter | What it does |
|---|---|
| Content filters | Grade harmful content by category, including prompt attacks |
| Denied topics | Block a subject outright, however politely it's asked |
| Word filters | Block specific words or phrases |
| Sensitive information filters | Block or mask PII and custom patterns |
| Contextual grounding checks | Catch answers not supported by the retrieved source |
| Automated Reasoning checks | Validate answers against logical rules |
The other services that come up next to it:
- Amazon Macie finds sensitive data stored in S3. It doesn't inspect live prompts.
- AWS WAF works at the HTTP layer. It can't judge what a prompt is trying to do.
- Amazon Comprehend detects PII and entities in text. It's useful as a pre-processing step, for example redacting before storage.
Prompts and orchestration
- Prompt Management stores versioned prompt templates. Production should point at a published version, never the editable draft.
- Bedrock Flows chains prompts, conditions and knowledge base lookups without much code. Flows also go to production as published versions behind an alias.
- Step Functions Standard suits long-running, auditable workflows (up to a year) with exactly-once execution. It's the one that supports waiting for a human callback.
- Step Functions Express suits high-volume, short work (up to five minutes) with at-least-once execution. It doesn't support the callback or
.syncpatterns, so it can't wait for a human approval. - AWS AppConfig changes configuration at runtime without redeploying. Switching models or providers without a redeploy is its classic use.
Evaluation
- Automatic evaluation runs without people and can serve as an unattended release gate. Each job takes at most 1,000 prompts, from a
.jsonlfile in S3. - Human evaluation uses human workers, so it can't be unattended. It needs CORS configured on the S3 output bucket; automatic jobs don't.
- Starting an evaluation job returns a job ARN. That means it started, not that it passed.
Operations and cost
- Model invocation logging captures the full request and response bodies, to CloudWatch Logs or S3 in the same account and Region. It only covers calls through the
bedrock-runtimeendpoint. - CloudWatch metrics give counts, latency and token usage, but no prompt text.
- CloudTrail records API calls, meaning who called what, without the content.
- Provisioned Throughput is for steady, predictable, committed volume. Prompt caching is for repeated prompt prefixes. They solve different problems.
- Cost Explorer and Cost Anomaly Detection cover spend analysis and alerting. Remember they exist; practice material rarely mentions them.
The traps worth knowing
These shapes came up again and again. Each comes with an example.
Reading traps
One word apart. Two options identical except for a single token: a different chunking strategy,
Retrieve against RetrieveAndGenerate, Standard against Express. The answer is always in the part you haven't read yet.Half of a multiple-response. With no partial credit, one wrong pick zeroes the question. The correct picks usually cover different requirements or different layers, such as prevent plus detect, or real-time updates plus a scheduled rebuild. Two picks that solve the same requirement is a warning sign.
The limit you didn't check. A suspiciously specific number in the stem usually means a documented limit is being tested. 1,600 prompts won't fit in one automatic evaluation job. Lambda can't run past 15 minutes. An Express workflow stops at five minutes. Do the arithmetic.
The setting you can't change later. Chunking strategy is fixed once the data source is connected, and a Step Functions workflow type is fixed once the state machine is created. When a stem says the team "is creating the data source now", that sentence is there for a reason.
Wrong tool for the job
Monitoring offered for prevention. The stem says prevent, block or reject, and an option offers a metric, alarm, log or dashboard. Those detect after the fact. Prevention means something in the request path: an IAM deny, a guardrail on the invocation, schema validation, an organisation policy.
Right service, wrong place. A real, sensible service used at a point where it can't act. Macie scans S3, so it never sees a live prompt. A reranker reorders chunks that were already retrieved, so it can't fix poor recall. Ask where in the request path each option actually runs.
Custom build where a managed feature exists. When the stem says "least operational overhead" or "least custom code", it is telling you to use the managed service, even when the custom Lambda version would clearly work. Glue Data Quality instead of a Lambda rule engine, Prompt Management instead of prompts in a Git repo, Bedrock Data Automation instead of a hand-built Textract and Comprehend pipeline.
Fixing the symptom. If documents were parsed badly at ingestion, no retrieval setting will repair them. Fix parsing and re-sync. Hybrid search and reranking can't recover text that was never extracted properly.
The wrong endpoint. Bedrock has separate endpoints for the control plane (
bedrock), model inference (bedrock-runtime), agent and knowledge base setup (bedrock-agent) and agent and retrieval calls (bedrock-agent-runtime). Private inference from a VPC needs the bedrock-runtime interface endpoint. An option offering the bedrock endpoint for inference sounds right and isn't.Logs, metrics and audit trails mixed up. If the requirement is the actual prompt and response text, only model invocation logging has it. Metrics have numbers. CloudTrail has who called what. An option that looks for prompt text in CloudTrail is wrong.
Human versus automatic evaluation. "Unattended" rules out human evaluation. "Humans must compare the outputs" rules out LLM-as-a-judge. And if the stem mentions CORS on the output bucket, it's quietly telling you the job uses human workers.
Wrong state or scope
Accepted is not complete. An async call that returns a job ID or an "in progress" status has only started the work. Anything that treats submission as success skips the poll, the final status and the result.
Draft against published version. If the stem mentions production, stability, auditability or reproducibility, a mutable draft is already ruled out. Prompts, flows and guardrails all follow this rule.
A real parameter on the wrong API. Sampling parameters such as temperature on an embeddings call, or
messages added to a call that already uses a managed prompt template. Check that each parameter belongs to the API named in the option.Scoped too narrowly. Cross-Region inference routes requests to several Regions, so IAM and any organisation policies must allow the model in every destination Region of the profile. Scoping permissions to the calling Region looks tighter and fails at runtime with access denied.
Topics I'd make sure of
This is a study map built from the exam guide's tasks.
Domain 1: Foundation Model Integration, Data Management, and Compliance
- Choosing foundation models and switching between them without code changes
- Resilience, including cross-Region inference and graceful degradation
- Data validation before ingestion
- Vector store choices and Bedrock Knowledge Bases, including managed versus custom, chunking strategies and metadata filtering
- Retrieval design: hybrid search, reranking and query decomposition
- Prompt engineering and Prompt Management with versioning
Domain 2: Implementation and Integration
- Bedrock Agents and tool use, action groups and orchestration
- Deployment options: on-demand, provisioned throughput and custom model deployment
- Integration patterns with API Gateway, Lambda, Step Functions and event-driven designs
- The Bedrock runtime APIs, including Converse against InvokeModel, streaming, and what each request accepts
Domain 3: AI Safety, Security, and Governance
- Bedrock Guardrails in detail: every filter type, where guardrails apply, and versioning them across accounts
- Prompt injection defence
- Encryption, VPC endpoints and data residency
- Governance: logging, lineage and audit trails
- Responsible AI principles and how AWS expects you to put them into practice
Domain 4: Operational Efficiency and Optimization for GenAI Applications
- Token cost and its drivers
- Caching
- Choosing between on-demand, batch and provisioned capacity
- Latency tuning
- Monitoring with CloudWatch and invocation logging, and cost tracking with Cost Explorer and Cost Anomaly Detection
Domain 5: Testing, Validation, and Troubleshooting
- Bedrock model evaluation, both automatic and with a judge model, plus human evaluation
- RAG evaluation, separating retrieval quality from answer quality
- Troubleshooting retrieval, throttling, timeouts and quota problems
Pacing: what question 55 taught me
180 minutes for 75 questions sounds generous. It isn't, once you start reading carefully.
I took my time on every question. I found the constraint sentence, compared the endings of the options, eliminated on violation, and checked my pick against every condition before moving on. That's what this exam rewards, and I'd do it again. But by question 55 I had about 30 minutes left for the last 20 questions, and those had to move a lot faster than the first 55.
What I'd do differently is set checkpoints before starting:
| Time | Aim to be at |
|---|---|
| 55 minutes | Question 25 |
| 110 minutes | Question 50 |
| 110 to 180 minutes | The last 25 questions and a short review |
That keeps the careful reading and still leaves room at the end. If one question is eating your time, make your best elimination, flag it and move on. A blank scores the same as a wrong answer, and a guess costs nothing.
Read slowly, but keep an eye on the clock.
If you're preparing for AIP-C01 and want to compare notes, leave a comment.
Series: AWS Certification Prep (1 article)
- 1Question 55, 30 Minutes Left: How I Prepared for the AWS GenAI Developer Professional Exam This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article