AWS Certified Generative AI Developer - Professional (AIP-C01) — Free Practice Questions
10 free sample questions from a bank of 10, with the correct answers and explanations. No signup required — start practising right now.
1A retail company has a generative AI (GenAI) product recommendation application that uses Amazon Bedrock. The application suggests products to customers based on browsing history and demographics. The company needs to implement fairness evaluation across multiple demographic groups to detect and measure bias in recommendations between two prompt approaches. The company wants to collect and monitor fairness metrics in real time. The company must receive an alert if the fairness metrics show a discrepancy of more than 15% between demographic groups. The company must receive weekly reports that compare the performance of the two prompt approaches.
Which solution will meet these requirements with the LEAST custom development effort?
Configure an Amazon CloudWatch dashboard to display default metrics from Amazon Bedrock API calls. Create custom metrics based on model outputs. Set up Amazon EventBridge rules to invoke AWS lambda functions that perform post-processing analysis on model responses and publish custom fairness metrics.
Create the two prompt variants in Amazon Bedrock Prompt Management. Use Amazon Bedrock Flows to deploy the prompt variants with defined traffic allocation. Configure Amazon Bedrock guardrails that have content filters to monitor demographic fairness. Set up Amazon CloudWatch alarms on the GuardrailContentSource dimension that use InvocationsIntervened metrics to detect recommendation discrepancy threshold violations.
Set up Amazon SageMaker Clarify to analyze model outputs. Publish fairness metrics to Amazon CloudWatch. Create CloudWatch composite alarms that combine SageMaker Clarify bias metrics with Amazon Bedrock latency metrics to provide a comprehensive fairness evaluation dashboard.
Create an Amazon Bedrock model evaluation job to compare fairness between the two prompt variants. Enable model invocation logging in Amazon CloudWatch. Set up CloudWatch alarms for InvocationsIntervened metrics with a dimension for each demographic group.
Answer: C
The short version
C — SageMaker Clarify computes the per-group fairness metrics and CloudWatch composite alarms turn them into a real-time alert.
The question needs measured bias across demographic groups, published as numbers and thresholded at 15%, and only Clarify produces that fairness math as a managed service.
Key concepts
Amazon SageMaker Clarify: AWS service for ML explainability that includes bias detection, comparing outcomes across facets (demographic groups) and emitting metrics such as demographic parity and disparate impact.
Facet: the attribute you split the data by (age, gender, region); the "discrepancy between demographic groups" is computed from one metric value per facet.
CloudWatch custom metric: a numeric datapoint published into a namespace so it can be graphed and alarmed on; a composite alarm fires when several metrics or alarms combine to breach a threshold.
Bedrock model evaluation job: an on-demand, batch scoring run used to compare prompt or model variants offline; it is not a continuous metric feed and cannot drive real-time alarms.
Bedrock Guardrails: content filters, denied topics, sensitive-information filters and word filters that block content; they do not calculate demographic fairness statistics.
Why C is correct
Clarify's bias detection is purpose-built for exactly the measurement described: you supply model outputs plus the facet attribute, and it returns fairness metrics per group, which is where the ">15% discrepancy" number comes from. Publishing those metrics to CloudWatch makes them continuously visible, and a composite alarm is the AWS mechanism that combines multiple metrics into one threshold evaluation and one notification, so the 15% rule is enforced by configuration instead of code. Adding Bedrock latency into the composite alarm means the weekly two-prompt comparison dashboard shows fairness and responsiveness of the same traffic, which covers the reporting requirement too. Nothing has to be written in Lambda, so this is the least custom development effort of the four.
Why the others are wrong
A. This is the hand-rolled version: the company must build the fairness calculation itself, publish the results as custom metrics, and orchestrate EventBridge plus Lambda for every response. That is exactly the substantial custom development the question asks you to avoid, and EventBridge/Lambda give no built-in notion of demographic fairness.
B. Guardrails content filters classify prompts and responses into harm categories and detect prompt attacks; they have no awareness of demographic attributes and emit no bias metrics, so nothing can be compared across groups or thresholded at 15%. Traffic-splitting prompt variants is useful, but the fairness requirement is simply not what guardrails measure.
D. A Bedrock model evaluation job is an offline batch comparison of prompt variants, so it cannot produce the real-time metric stream the scenario demands. InvocationsIntervened counts guardrail interventions from an InvokeModel call, not bias, and adding a per-demographic dimension to an API metric does not create per-group fairness measurement.
AIP-C01 exam tip
Bias questions are two-part puzzles: Clarify (or model explainability) measures fairness, CloudWatch alarms enforce the threshold. Any option that asks you to compute the comparison yourself in Lambda or use guardrails for demographics is the wrong service for the stated requirement.
2A finance company is developing an AI assistant to help clients plan investments and manage their portfolios. The company identifies several high-risk conversation patterns such as requests for specific stock recommendations or guaranteed returns. High-risk conversation patterns could lead to regulatory violations if the company cannot implement appropriate controls.
The company must ensure that the AI assistant does not provide inappropriate financial advice, generate content about competitors, or make claims that are not factually grounded in the company's approved financial guidance. The company wants to use Amazon Bedrock Guardrails to implement a solution.
Which combination of steps will meet these requirements? (Choose three.)
Add the high-risk conversation patterns to a denied topics guardrail.
Configure a content filter guardrail to filter prompts that contain the high-risk conversation patterns.
Configure a content filter guardrail to filter prompts that contain competitor names.
Add the names of competitors as custom word filters. Set the input and output actions to block.
Set a low grounding score threshold.
Set a high grounding score threshold.
Answer: A, D, F
The short version
A, D and F — denied topics for high-risk patterns, custom word filters with block for competitors, and a high grounding threshold for factual grounding.
Each of the three guardrail controls has exactly one correct native feature behind it, and the two rejected options are the classic wrong-version traps.
Key concepts
Denied topics: a guardrail policy that defines a topic definition plus examples and classifies a prompt or response against it, then applies the configured action.
Custom word filters: lists of banned or regulated words, each with an input and/or output action; set both to BLOCK to stop the word being processed or produced.
Content filters: a fixed set of harmful-content categories (hate, violence, sexual content, misconduct, prompt attack) plus prompt-attack filtering — domain-neutral safety, not company policy.
Grounding check / grounding score: compares the model response against the supplied source context and returns a 0–1 score; the threshold is a strictness dial where a higher value requires stronger evidence of grounding.
Guardrail action: BLOCK or ANONYMIZE, applied to prompts, responses, or both.
Why A and D and F are correct
A. Requests for a specific stock recommendation or for guaranteed returns are company-defined high-risk topics, and denied topics is the guardrail feature built for defining exactly that kind of custom topic with representative examples. A content filter only knows generic harm categories, so it can never express "specific stock recommendation" as a topic definition.
D. Competitor brand names are a closed vocabulary, which is precisely what custom word filters are for. Configuring both the input and output actions to block means the name is refused whether the user types it or the model produces it, which satisfies the "no content about competitors" requirement from both directions.
F. The grounding check scores how much of the response is supported by the provided source context. A low threshold is permissive and lets loosely grounded claims through; a high threshold demands stronger supporting evidence, so unsupported claims about approved financial guidance are blocked. Since the requirement is to avoid claims "not factually grounded" in approved guidance, strictness is the correct direction.
Why the others are wrong
B. Content filters are hard-wired to AWS's harm taxonomy (hate, violence, sexual, misconduct, jailbreak). They have no mechanism to hold a custom high-risk conversation definition, so a request for "guaranteed returns" would sail through unless it tripped a generic category.
C. Competitor names are not one of the content filter categories. Content filters work on harmful-content classification, not on named entities, so this does not stop competitor mentions from appearing in a response.
E. A low grounding threshold is the permissive setting — it is the opposite of what is needed. Low thresholds let weakly grounded answers pass, which is the failure mode the scenario is trying to prevent.
AIP-C01 exam tip
Memorise the guardrail menu as: custom topic -> denied topics, custom word -> custom word filters, generic harm category -> content filters, source fidelity -> grounding threshold. And remember grounding is strict at high threshold, lenient at low.
3A company has deployed an AI assistant as a React application that uses AWS Amplify, an AWS AppSync GraphQL API, and Amazon Bedrock Knowledge Bases. The application uses the GraphQL API to call the Amazon Bedrock RetrieveAndGenerate API for knowledge base interactions. The company configures an AWS Lambda resolver to use the RequestResponse invocation type.
Application users report frequent timeouts and slow response times. Users report these problems more frequently for complex questions that require longer processing.
The company needs a solution to fix these performance issues and enhance the user experience.
Which solution will meet these requirements?
Use AWS Amplify AI Kit to implement streaming responses from the GraphQL API and to optimize client-side rendering.
Increase the timeout value of the Lambda resolver. Implement retry logic with exponential backoff.
Update the application to send an API request to an Amazon SQS queue. Update the AWS AppSync resolver to poll and process the queue.
Change the RetrieveAndGenerate API to the InvokeModelWithResponseStream API. Update the application to use an Amazon API Gateway WebSocket API to support the streaming response.
Answer: A
The short version
A — Streaming the response through AppSync subscriptions with AWS Amplify AI Kit removes the buffering wait without a rewrite.
The RequestResponse Lambda resolver makes users wait for the entire Knowledge Bases answer, so the fix is to deliver partial output as it is produced.
Key concepts
RequestResponse invocation type: Lambda returns only after the handler completes, so the caller sees one final payload and no intermediate output — this is the root cause of the perceived slowness.
AppSync subscriptions: a GraphQL subscription on a mutation result lets a client receive updates as they happen, keeping the existing GraphQL API shape rather than adding a second protocol.
AWS Amplify AI Kit: Amplify's component/tooling set (Chat components, GraphQL helpers, @aws_subscribe wiring) that streams model output token-by-token into the UI and reduces client-side re-renders.
Streaming inference: an API that returns incremental chunks (Bedrock's InvokeModelWithResponseStream) so perceived latency drops to time-to-first-token even when total generation time is unchanged.
Lambda timeout ceiling: Lambda invocations can run at most 15 minutes, so raising the timeout can never turn a non-streaming call into a progressive one.
Why A is correct
The users' problem is not that generation takes too long but that nothing arrives until the whole answer is ready; complex questions simply make that dead time more obvious. Turning the interaction into a subscription means the first tokens reach the React client while the model is still working, which removes the perceived timeout and is why the issue is worst on long questions. Amplify AI Kit supplies the streaming client and GraphQL plumbing that already match an Amplify-hosted React app, so it fits the existing architecture instead of replacing it, and its rendering optimizations cut the per-chunk UI churn that would otherwise eat the latency gain.
Why the others are wrong
B. Raising the timeout and adding exponential backoff only lengthens the wait and multiplies it on retry. It addresses a failure, not the buffering behaviour of a synchronous resolver, and 15 minutes of Lambda runtime still produces nothing until the handler returns.
C. Moving the request to SQS and polling from the resolver is a queueing pattern, not a streaming pattern. It adds hops, delivery-delay tuning and operational surface while the client still receives one batched response at the end.
D. This rewrites the whole integration: Bedrock Knowledge Bases exposes RetrieveAndGenerate, a non-streaming RAG API, so swapping in a raw streaming model API discards the knowledge base, and standing up an API Gateway WebSocket layer means a new endpoint, auth path and client rewrite. That is the heavyweight option, not the minimal one.
AIP-C01 exam tip
When a GraphQL/Lambda app feels slow and times out, the default reflex should be streaming: AppSync subscription for GraphQL, WebSocket API for REST clients. Timeouts and retries never make a synchronous call feel incremental.
4An ecommerce company operates a global product recommendation system that needs to switch between multiple foundation models (FM) in Amazon Bedrock based on regulations, cost optimization, and performance requirements. The company must apply custom controls based on proprietary business logic, including dynamic cost thresholds, AWS Region-specific compliance rules, and real-time A/B testing across multiple FMs. The system must be able to switch between FMs without deploying new code. The system must route user requests based on complex rules including user tier, transaction value, regulatory zone, and real-time cost metrics that change hourly and require immediate propagation across thousands of concurrent requests.
Which solution will meet these requirements?
Deploy an AWS Lambda function that uses environment variables to store routing rules and Amazon Bedrock FM IDs. Use the Lambda console to update the environment variables when business requirements change. Configure an Amazon API Gateway REST API to read request parameters to make routing decisions.
Deploy Amazon API Gateway REST API request transformation templates to implement routing logic based on request attributes. Store Amazon Bedrock FM endpoints as REST API stage variables. Update the variables when the system switches between models.
Configure an AWS Lambda function to fetch routing configurations from the AWS AppConfig Agent for each user request. Run business logic in the Lambda function to select the appropriate FM for each request. Expose the FM through a single Amazon API Gateway REST API endpoint.
Use AWS Lambda authorizers for an Amazon API Gateway REST API to evaluate routing rules that are stored in AWS AppConfig. Return authorization contexts based on business logic. Route requests to model-specific Lambda functions for each Amazon Bedrock FM.
Answer: C
The short version
C — Fetching routing config from the AppConfig Agent inside Lambda puts hourly business rules in the request path with no redeployment.
AppConfig is designed for dynamic configuration, so thresholds, compliance zones and A/B weights can change without new code.
Key concepts
AWS AppConfig: managed service for validating, deploying and retrieving dynamic configuration; deployments can be versioned, validated and rolled back independently of application code.
AppConfig Agent: a sidecar or Lambda extension that caches configuration locally and exposes it over localhost, so a Lambda can read the latest value per invocation with very low latency and no re-deploy.
Lambda environment variables: updated through a function configuration update; the change applies to new execution environments, but it is an update-and-deploy mechanism, not a live rules feed.
API Gateway mapping templates / stage variables: VTL-based transformation with simple string substitution; no arithmetic, no external lookups, and stage variable changes require a deployment.
Lambda authorizer caching: authorizer responses are cached (default 300 seconds) and are intended for authentication/authorization decisions, not for per-request model selection.
Why C is correct
The hard constraints are that rules change hourly, must propagate immediately across thousands of concurrent requests, and must not require a new deployment. Reading the configuration from the AppConfig Agent on each request satisfies all three: the agent serves the latest deployed configuration locally to every execution environment, so a rule change is effective within seconds without touching code or redeploying. Because the routing logic stays in Lambda, the company can express the complex conditions it needs — user tier, transaction value, regulatory zone and current cost metrics — and can implement real-time A/B testing and dynamic cost thresholds as ordinary program logic. Exposing a single API Gateway endpoint keeps clients decoupled, so swapping the model behind the endpoint is invisible to callers.
Why the others are wrong
A. Environment variables are the wrong home for rules that change hourly. Every change needs a Lambda configuration update via the console, which is manual and slow, creates an inconsistent fleet while instances roll over, and cannot express values that must be recomputed from live cost metrics.
B. API Gateway VTL mapping templates can only do simple string substitution and conditional matching on request attributes. They cannot call out to get hourly cost metrics or run the multi-factor business logic described, and updating stage variables still requires a deployment.
D. Lambda authorizers exist to make auth decisions and are cached by default, so they are both the wrong purpose and too slow for immediate propagation. Routing to one model-specific Lambda per FM also multiplies the functions to maintain, which is the code-coupling the requirement rules out.
AIP-C01 exam tip
Dynamic-behaviour question, three words: change without deploying. That points at AppConfig (Agent for the request path), not environment variables, not stage variables, not authorizers.
5A company is developing an internal generative AI (GenAI) assistant that uses Amazon Bedrock to summarize corporate documents for multiple business units. The GenAI assistant must generate responses in a consistent format that includes a document summary, classification of business risks, and terms that are flagged for review. The GenAI assistant must adapt the tone of responses for each user's business unit, such as legal, human resources, or finance. The GenAI assistant must block hate speech, inappropriate topics, and sensitive information such as personal health information.
The company needs a solution to centrally manage prompt variants across business units and teams. The company wants to minimize ongoing orchestration efforts and maintenance for post-processing logic. The company also wants to have the ability to adjust content moderation criteria for the GenAI assistant over time.
Which solution will meet these requirements with the LEAST maintenance overhead?
Use Amazon Bedrock Prompt Management to configure reusable templates and business unit-specific prompt variants. Apply Amazon Bedrock guardrails that have category filters and sensitive term lists to block prohibited content.
Use Amazon Bedrock Prompt Management to define base templates. Enforce business unit-specific tone by using system prompt variables. Configure Amazon Bedrock guardrails to apply audience-based threshold tuning. Manage the guardrails by using an internal administration API.
Use Amazon Bedrock with business unit-based instruction injection in API calls. Store response formatting rules in Amazon DynamoDB. Use AWS Step functions to validate responses. Use Amazon Comprehend to apply content filters after the GenAI assistant generates responses.
Use Amazon Bedrock with custom prompt templates that are stored in Amazon DynamoDB. Create one AWS Lambda function to select business unit-specific prompts. Create a second Lambda function to call Amazon Comprehend to filter prohibited content from responses.
Answer: A
The short version
A — Bedrock Prompt Management for reusable, per-business-unit prompt variants, and guardrails category plus sensitive-information filters for moderation.
It covers format, tone and content blocking with managed features and no post-processing code to maintain.
Key concepts
Amazon Bedrock Prompt Management: store, version and parameterise prompt templates centrally, including variant prompts so teams can iterate without overwriting each other's work.
Prompt variant: a named alternative of the same template (for example a legal-tone variant) that can be promoted to the active version after testing.
Guardrail category filters: block the harmful-content categories (hate, violence, sexual, misconduct, jailbreak) at the prompt or response boundary.
Guardrail sensitive-information / PII filters: detect entities such as personal health information and either block or anonymise them.
Guardrail versioning: moderation criteria are themselves a versioned, deployable artefact, so they can be tightened over time without code changes.
Why A is correct
The scenario has three separable jobs, and A maps each to a managed feature. Consistent output structure plus tone variation per business unit is prompt work, which Prompt Management handles centrally through templates and variants so a legal or finance tone is a configuration change rather than a fork of the code. Blocking hate speech and inappropriate topics is the category filter's job. Catching personal health information is the sensitive-information filter's job, because PHI is a recognised entity type rather than a harm category. Because moderation and prompting both live inside Bedrock, there is no downstream Lambda, Step Functions or third-party filter to orchestrate, and the moderation criteria can be adjusted as a guardrail version whenever policy shifts.
Why the others are wrong
B. Guardrails have no "audience-based threshold tuning" capability and no built-in per-business-unit tone switch; tone is prompt content, not a guardrail policy. Managing guardrails through an internally built admin API adds exactly the ongoing orchestration and maintenance effort the question says to minimise.
C. Injecting business-unit instructions on every API call scatters prompt content across clients so there is nothing central to manage. Storing formatting rules in DynamoDB, orchestrating with Step Functions and filtering after generation with Amazon Comprehend means a hand-built post-processing pipeline — and Comprehend is a natural-language NLP service, not a content moderation filter.
D. Prompts held in DynamoDB with a Lambda selector is the DIY version of Prompt Management, so versioning and reuse are manual. A second Lambda that calls Comprehend to strip prohibited content is post-processing that must be written, deployed and maintained, and Comprehend does not perform content moderation.
AIP-C01 exam tip
Two rules of thumb: prompt content belongs in Prompt Management, safety belongs in guardrails. If an option wants Step Functions, DynamoDB prompt tables or Comprehend as a content filter, it is rebuilding features Bedrock already has.
6A financial services company is building a customer support application that retrieves relevant financial regulation documents from a database based on semantic similarities to user queries. The application must integrate with Amazon Bedrock to generate responses. The application must be able to search documents that are in English, Spanish, and Portuguese. The application must filter documents by metadata such as publication date, regulatory agency, and document type.
The database stores approximately 10 million document embeddings. To minimize operational overhead, the company wants a solution that minimizes management and maintenance effort. The application must provide low-latency responses for real-time customer interactions.
Which solution will meet these requirements?
Use Amazon OpenSearch Serverless to provide vector search capabilities and metadata filtering. Connect to Amazon Bedrock Knowledge Bases to enable Retrieval Augmented Generation (RAG) capabilities that use an Anthropic Claude foundation model (FM).
Deploy an Amazon Aurora PostgreSQL database with the pgvector extension. Define tables to store embeddings and metadata. Use SQL queries to perform similarity searches. Send retrieved documents to Amazon Bedrock to generate responses.
Use Amazon S3 Vectors to configure a vector index and non-filterable metadata fields. Integrate S3 Vectors with Amazon Bedrock to enable Retrieval Augmented Generation (RAG) capabilities.
Set up an Amazon Neptune Analytics graph database. Configure a vector index that has appropriate dimensionality to store document embeddings. Use Amazon Bedrock to perform graph-based retrieval and to generate responses.
Answer: A
The short version
A — OpenSearch Serverless gives managed vector search with metadata filtering, and Bedrock Knowledge Bases supplies the RAG layer on top of it.
At roughly 10 million embeddings with millisecond latency and a three-language corpus, a fully managed vector index is the operational minimum.
Key concepts
Vector search: nearest-neighbour search over embedding vectors so that semantically similar passages are retrieved without needing exact keyword matches.
Metadata filtering: narrowing a vector search to a subset (publication date, regulatory agency, document type) using non-vector attributes, applied before or during scoring.
Amazon OpenSearch Serverless: a serverless collection type that provisions and scales vector search capacity automatically, removing index and cluster management.
Amazon Bedrock Knowledge Bases: managed RAG — it ingests documents, creates embeddings and indexes, and exposes a RetrieveAndGenerate API that retrieves context and asks an FM to answer.
pgvector / Neptune Analytics: respectively a PostgreSQL extension that you must index and tune yourself, and a graph database whose traversal model and operational overhead are unwarranted for document similarity search.
Why A is correct
The constraints are scale (about 10M embeddings), low latency for live customer interactions, multilingual content in English, Spanish and Portuguese, metadata filtering, and minimal management effort. OpenSearch Serverless satisfies the scale and latency part because capacity is managed by the service, and it supports metadata filtering on the indexed fields, which is what the publication date, agency and document type requirements need. Bedrock Knowledge Bases sits on top to provide RAG, handling document ingestion, chunking, embedding generation and the retrieve-then-generate flow, so the company chooses the FM (here Anthropic Claude, which handles the multilingual corpus well) rather than writing that plumbing. Nothing has to be sized, tuned or patched by the team.
Why the others are wrong
B. Aurora PostgreSQL with the pgvector extension can do similarity search, but the customer now owns index build time, vacuum and autovacuum behaviour, memory and connection tuning, and vector query tuning as the collection grows — the opposite of minimising operational overhead at 10M vectors under real-time latency demands.
C. The option explicitly configures non-filterable metadata fields, so the requirement to filter by publication date, agency and document type cannot be satisfied. It also leaves the company assembling its own RAG flow instead of using the managed Knowledge Bases path.
D. A graph database optimises for relationship traversal, which is not what this workload needs; it adds a specialised engine, index dimensionalisation decisions and tuning work while providing no advantage over a purpose-built vector index.
AIP-C01 exam tip
Vector workload + "minimise operations" almost always means a managed vector engine (OpenSearch Serverless or Bedrock Knowledge Bases). If an option mentions pgvector, Neptune, or non-filterable metadata, check which stated requirement it quietly breaks.
7A medical company is building a generative AI (GenAI) application that uses RAG to provide evidence-based medical information. The application uses Amazon OpenSearch Service to retrieve vector embeddings. Users report that searches frequently miss results that contain exact medical terms and acronyms and return too many semantically similar but irrelevant documents. The company needs to improve retrieval quality and maintain low end user latency, even as the document collection grows to millions of documents.
Which solution will meet these requirements with the LEAST operational overhead?
Configure hybrid search by combining vector similarity with keyword matching to improve semantic understanding and exact term and acronym matching.
Increase the dimensions of the vector embeddings from 384 to 1536. Use a post-processing AWS Lambda function to filter out irrelevant results after retrieval.
Replace OpenSearch Service with Amazon Kendra. Use query expansion to handle medical acronyms and terminology variants during pre-processing.
Implement a two-stage retrieval architecture in which initial vector search results are re-ranked by an ML model that is hosted on Amazon SageMaker AI.
Answer: A
The short version
A — Hybrid search (vector similarity plus keyword matching) is the built-in fix for missed exact terms and acronyms.
Vector search alone is weak on rare literal strings like drug names and abbreviations, and OpenSearch does hybrid retrieval natively, so overhead stays near zero.
Key concepts
Vector (semantic) search: ranks by embedding similarity, which handles paraphrase but treats rare acronyms and exact identifiers as noisy.
Keyword / lexical search: BM25-style term and phrase matching, which is unbeatable for exact strings such as "HbA1c" or a dosage code.
Hybrid search: runs both retrievers and fuses the ranked lists (for example reciprocal rank fusion), getting semantic recall and literal precision together.
Embedding dimensions: a larger dimension improves representational capacity but multiplies index size, storage cost and query latency proportionally.
Re-ranking: a second ML stage that reorders the first stage's candidate set; it improves precision but adds a hosted model, inference latency and cost.
Why A is correct
The symptom pattern is diagnostic: exact terms and acronyms are missed, while semantically similar but irrelevant documents crowd the results. That is precisely the blind spot of pure vector search — embeddings blur literal strings — and adding a keyword retriever closes it without changing the data model or adding infrastructure. Because hybrid search is a native capability of the existing OpenSearch vector index, enabling it costs configuration rather than a new service or model, which is what keeps the operational overhead low and end-user latency unchanged as the collection grows into the millions of documents.
Why the others are wrong
B. Going from 384 to 1536 dimensions quadruples index storage and query cost while still doing nothing for exact-token matching — it cannot fix the stated failure. The extra Lambda post-filter adds processing on every query, which increases latency and adds a component to operate, directly contradicting both requirements.
C. Replacing OpenSearch with Amazon Kendra means migrating the index and standing up a different service, which is a large operational increase. Query expansion also does preprocessing work on each query, and it partially duplicates what lexical matching already guarantees; it is not the least-overhead path.
D. A two-stage SageMaker re-ranker is a genuine quality technique, but it requires hosting and serving an ML model in front of retrieval, adding inference latency, cost and a new operational surface. The scenario explicitly asks for the least overhead while maintaining low latency.
AIP-C01 exam tip
Rule of thumb for RAG retrieval quality: if exact strings are missed, add lexical matching (hybrid search); if relevance ordering is wrong, add a re-ranker. Raising embedding dimensions solves neither.
8A company runs a generative AI (GenAI)-powered summarization application in an application AWS account that uses Amazon Bedrock. The application architecture includes an Amazon API Gateway REST API that forwards requests to AWS Lambda functions that are attached to private VPC subnets. The application summarizes sensitive customer records that the company stores in a governed data lake in a centralized data storage account. The company has enabled Amazon S3, Amazon Athena, and AWS Glue in the data storage account.
The company must ensure that calls that the application makes to Amazon Bedrock use only private connectivity between the company's application VPC and Amazon Bedrock. The company's data lake must provide fine-grained column-level access across the company's AWS accounts.
Which solution will meet these requirements?
In the application account, create interface VPC endpoints for Amazon Bedrock runtimes. Run Lambda functions in private subnets. Use IAM conditions on inference and data-plane policies to allow calls only to approved endpoints and roles. In the data storage account, use AWS Lake Formation LF-tag-based access control to create table and column-level cross-account grants.
Run Lambda functions in private subnets. Configure a NAT gateway to provide access to Amazon Bedrock and the data lake. Use S3 bucket policies and ACLs to manage permissions. Export AWS CloudTrail logs to Amazon S3 to perform weekly reviews.
Create a gateway endpoint only for Amazon S3 in the application account. Invoke Amazon Bedrock through public endpoints. Use database-level grants in AWS Lake Formation to manage data access. Stream AWS CloudTrail logs to Amazon CloudWatch Logs. Do not set up metric filters or alarms.
Use VPC endpoints to provide access to Amazon Bedrock and Amazon S3 in the application account. Use only IAM path-based policies to manage data lake access. Send AWS CloudTrail logs to Amazon CloudWatch Logs. Periodically create dashboards and allow public fallback for cross-Region reads to reduce setup time.
Answer: A
The short version
A — Interface VPC endpoints for Bedrock runtimes plus endpoint-restricted IAM, and Lake Formation LF-tag policies for column-level data lake access.
This is the only option that satisfies both halves: Bedrock reachable only over private connectivity, and column-level control across accounts.
Key concepts
Interface VPC endpoint (AWS PrivateLink): an ENI in a subnet with private IPs that exposes an AWS service privately; Bedrock runtime endpoints keep inference traffic inside the VPC.
Private subnet Lambda: a function with no route to the internet, so its only path to Bedrock is the VPC endpoint (or S3 gateway endpoint for the data lake).
Endpoint-scoped IAM: identity policies conditioned on aws:SourceVpce (and account/resource conditions) so calls succeed only against the approved endpoint from approved roles.
AWS Lake Formation LF-tags: attribute-based tags attached to databases, tables and columns, used by LF-tag-based data lake permissions to grant access to individual columns across accounts.
NAT gateway: provides outbound internet access; it is a public-internet path and therefore disqualifies private-only connectivity.
Why A is correct
The first requirement is that Bedrock calls never touch the public internet. Creating interface VPC endpoints for the Bedrock runtimes in the application account and keeping the Lambda functions in private subnets means DNS for the Bedrock endpoint resolves to the PrivateLink ENI, so inference calls stay on the VPC network path. Endpoint and role conditions in IAM then make that guarantee enforceable rather than merely conventional, so only approved endpoints and approved principals can invoke the model. The second requirement is fine-grained column-level access in the data storage account: Lake Formation LF-tag-based permissions and data lake resource policies can grant access to specific columns and be evaluated against the requesting principal's tags, which is exactly what bucket policies and ACLs cannot express.
Why the others are wrong
B. A NAT gateway routes the Bedrock call out over the public internet, which violates the private-connectivity requirement outright. S3 bucket policies and ACLs operate at bucket and object granularity and cannot restrict individual columns; ACLs are also deprecated, and CloudTrail-to-S3 weekly reviews are neither continuous detection nor alerting.
C. It invokes Bedrock through public endpoints, failing the first requirement, and database-level grants in Lake Formation are not column-level control. It also explicitly creates no metric filters or alarms, so the audit/monitoring bar is not met either.
D. It adds a "public fallback for cross-Region reads", which reintroduces the public path the question forbids. IAM path-based policies describe who a principal is, not which columns of a governed table it may see, so the column-level requirement is unmet.
AIP-C01 exam tip
Private connectivity = interface endpoints + private subnets, and never a NAT gateway "because it is easier". Column-level data lake access = Lake Formation LF-tags, not bucket policies, ACLs or IAM paths.
9A media company must use Amazon Bedrock to implement a robust governance process for AI-generated content. The company needs to manage hundreds of prompt templates. Multiple teams use the templates across multiple AWS Regions to generate content. The solution must provide version control with approval workflows that include notifications for pending reviews. The solution must also provide detailed audit trails that document prompt activities and consistent prompt parameterization to enforce quality standards.
Which solution will meet these requirements?
Configure Amazon Bedrock Studio prompt templates. Use Amazon CloudWatch to create dashboards that display prompt usage metrics. Store the approval status of content in Amazon DynamoDB. Use AWS Lambda functions to enforce approvals.
Use Amazon Bedrock Prompt Management to implement version control. Configure AWS CloudTrail for audit logging. Use IAM policies to control approval permissions. Create parameterized prompt templates by specifying variables.
Use AWS Step Functions to create an approval workflow. Store prompts as documents in Amazon S3. Use tags to implement version control. Use Amazon EventBridge to send notifications.
Deploy Amazon SageMaker Canvas with prompt templates that are stored in Amazon S3. Use AWS CloudFormation to implement version control. Use AWS Config to enforce approval policies.
Answer: B
The short version
B — Bedrock Prompt Management for versioned, variable-based prompt templates, CloudTrail for the audit trail, and IAM policies to control who may edit or approve.
Every requirement in the question already has a native home in Bedrock plus CloudTrail, with no custom workflow to build.
Key concepts
Amazon Bedrock Prompt Management: central repository for prompt templates with version history, variants, tags, and human approval before a variant becomes active.
Prompt variables: {{variable}} placeholders in a template that callers fill at run time, which is what makes parameterisation consistent across many teams.
Amazon CloudTrail: records API calls, including Bedrock prompt management operations, giving an immutable audit trail of who created, edited or ran which version.
IAM policies: control who can create, edit, approve and invoke prompt templates — the approval permissions are enforced by who holds which action.
EventBridge / Step Functions DIY workflow: custom orchestration that can approximate approval flows but has no knowledge of prompt versions or template variables.
Why B is correct
The company needs governance, not a workflow application. Prompt Management stores hundreds of templates centrally with real version control and supports an approval step so a variant is reviewed before it becomes the active version, which is the approval workflow the security requirement describes. Templates are parameterised with variables so every team fills the same slots consistently, enforcing quality standards across Regions rather than each team copying a prompt into its own code. CloudTrail captures the detailed record of prompt activities — creation, modification, invocation — for audit, and IAM policies decide who is permitted to approve and publish changes, so authorisation is enforced by the platform rather than by an application. It is also multi-Region and multi-team by construction, which is what the scenario calls for.
Why the others are wrong
A. Storing approval status in DynamoDB and enforcing it with Lambda means the company is rebuilding Prompt Management's versioning and approval features by hand, adding components to operate. CloudWatch dashboards of invocation counts give usage metrics, not an audit trail of who changed which prompt version.
C. Prompts stored as objects in S3 have no native prompt version control, and S3 object tags are metadata, not versions. A Step Functions plus EventBridge approval flow is custom engineering that still does not deliver consistent prompt parameterisation or prompt-level audit history.
D. SageMaker Canvas is a no-code workspace for classical ML and SageMaker entities; it is not the system of record for Bedrock prompt governance. CloudFormation version-controls infrastructure stacks and AWS Config evaluates resource configuration — neither versions prompt content.
AIP-C01 exam tip
Prompt governance question, answer is always: Prompt Management for versions and variables, IAM for who may approve, CloudTrail for the audit trail. If the option builds an approval system out of DynamoDB or Step Functions, it is the distractor.
10A company is developing a customer support application that uses Amazon Bedrock foundation models (FMs) to provide real-time AI assistance to the company's employees. The application must display AI-generated responses character by character as the responses are generated. The application needs to support thousands of concurrent users with minimal latency. The responses typically take 15 to 45 seconds to finish.
Which solution will meet these requirements?
Configure an Amazon API Gateway WebSocket API with an AWS Lambda integration. Configure the WebSocket API to invoke the Amazon Bedrock InvokeModelWithResponseStream API and stream partial responses through WebSocket connections.
Configure an Amazon API Gateway REST API with an AWS Lambda integration. Configure the REST API to invoke the Amazon Bedrock standard InvokeModel API and implement frontend client-side polling every 100 ms for complete response chunks.
Implement direct frontend client connections to Amazon Bedrock by using IAM user credentials and the InvokeModelWithResponseStream API without any intermediate gateway or proxy layer.
Configure an Amazon API Gateway HTTP API with an AWS Lambda integration. Configure the HTTP API to cache complete responses in an Amazon DynamoDB table and serve the responses through multiple paginated GET requests to frontend clients.
Answer: A
The short version
A — An API Gateway WebSocket API with a Lambda integration calling InvokeModelWithResponseStream streams partial responses to thousands of concurrent users.
Responses taking 15–45 seconds demand a persistent bidirectional connection and incremental chunks; anything request-response turns a 45-second wait into a user-visible stall.
Key concepts
WebSocket API: a persistent, bidirectional connection on API Gateway designed for streaming and for holding many concurrent long-lived clients, which suits 15–45 second generations.
InvokeModelWithResponseStream: the Bedrock streaming inference operation that returns the completion chunk by chunk, so time-to-first-token is low even when total generation is long.
Lambda response streaming: allows the function to stream partial output back through the WebSocket integration instead of buffering a complete payload.
API Gateway REST / HTTP API: request-response only, with integration timeouts in the tens of seconds and no server-initiated push — the wrong shape for token streaming.
Client-side polling: repeatedly calling the API to check for more data adds request volume and still cannot reveal tokens before the underlying call completes.
Why A is correct
The two hard requirements are character-by-character output and support for thousands of simultaneous users with minimal latency. A WebSocket connection is persistent and bidirectional, so it can stay open for the full 15–45 seconds of generation without timing out and it scales to large fleets of long-lived connections on API Gateway. Behind it, InvokeModelWithResponseStream is the Bedrock operation that actually produces incremental chunks; forwarding each chunk through the Lambda integration means the employee sees text appear as it is generated, which directly solves the "display character by character" requirement.
Why the others are wrong
B. The standard InvokeModel API returns the completion only when generation has finished, so there is nothing to display incrementally. Polling every 100 ms multiplies API calls per user — ruinous at thousands of concurrent users — and still returns nothing until the model call completes, because the integration is synchronous and hits the REST API timeout for a 45-second generation.
C. Handing IAM user credentials to a browser or client so it can call Bedrock directly would embed long-term AWS credentials in client software: they can be extracted and used from anywhere, and there is no review, logging or guardrail layer in front of the model. It is a security failure, not an architecture.
D. Caching completed answers in DynamoDB and serving them through paginated GET requests is batch delivery of a finished result, not live streaming; the client still waits for the entire generation and then reassembles pages, and it adds a cache, pagination calls and staleness as extra operational burden.
AIP-C01 exam tip
Long generations (tens of seconds) plus "stream as it is generated" always means WebSocket API plus InvokeModelWithResponseStream. Never put IAM user credentials in a client, and never try to fake streaming with polling.