Amazon Practice Questions, Discussions & Exam Topics by our Authors
A company has an application that uses an Amazon API Gateway REST API, AWS Lambda functions, and an Amazon DynamoDB table. The application currently runs in a single AWS Region. The company wants to make the application highly available across two Regions. User traffic must be routed...
Let's carefully analyze the problem and the options. The scenario is:
Current architecture: API Gateway REST API → Lambda → DynamoDB.
Requirement: Highly available across two AWS Regions.
Requirement: Route traffic to the Region with the least latency.
We need to choose three options that satisfy these requirements.
---
Step 1: Multi-region DynamoDB
Option A: Create a replica of the DynamoDB table in a second Region. ✅
Why selected: For multi-region HA, you need a replicated DynamoDB table so that both Regions can serve read/write requests. This uses DynamoDB Global Tables, which is exactly for multi-region replication.
Scenario: Use when you want your database to be highly available and synchronized across multiple Regions.
Why others like B are rejected:
Option B: Create a global secondary index for the DynamoDB table. ❌
A GSI helps with querying and indexing, not multi-region availability. It does not solve the HA or latency routing requirement.
---
Step 2: Multi-region API Gateway & Lambda
Option C: Create copies of the REST API and the Lambda functions in a second Region. ✅
Why selected: For HA across Regions, both the API Gateway and Lambda functions must exist in each Region. Traffic nee...
Author: Emily · Last updated Jun 14, 2026
A company has a web application that is hosted on Amazon EC2 instances. The company is deploying the application into multiple AWS Regions.
The application consists of dynamic content such as WebSocket-based real-time product updates. The company uses Amazon Route 53 to...
Let's analyze this AWS multi-Region architecture problem carefully. The key requirements are:
Multi-Region deployment
Low latency for users
Dynamic content including WebSocket-based real-time updates
Route 53 is used for DNS management
We need to pick the solution that provides multi-Region access with the least latency, and supports dynamic, connection-oriented traffic like WebSockets.
---
Option A: ALB in each Region + Route 53 latency-based routing
Pros:
ALBs can handle HTTP/HTTPS traffic.
Route 53 latency-based routing directs users to the Region with the lowest latency.
Cons:
The A record would require IP addresses, but ALBs do not have static IPs, their IPs can change, so this approach is not supported.
ALBs are regional, so you would need Route 53 to handle failover, but this won't work properly with the IP-based record.
Use case: Only suitable for regional access if using DNS alias (not IPs).
Conclusion: Rejected because you cannot point a Route 53 A record to an ALB by IP.
---
Option B: ALB in each Region + CloudFront + Route 53 alias
Pros:
CloudFront caches content globally, reducing latency for static content.
Route 53 alias to CloudFront is valid.
Cons:
Dynamic content and WebSockets are poorly supported by CloudFront, especially for real-time bidirectional connections. CloudFront mainly benefits static content.
Use case: Best for global delivery of static web content (images, JS, CSS).
Conclusion: Rejected because CloudFront will not efficiently handle WebSocket traffic.
---
Option C: NLB in each Region + Route 53 multivalue answer routing
Pros:
NLBs support TCP, UDP, and WebSocket traffic, so real-time connections work.
Multivalue answer routing pro...
Author: Emma Brown · Last updated Jun 14, 2026
A company manages its multi-account environment by using AWS Organizations and AWS Control Tower. The company must deploy standardized security controls and compliance policies across all of its AWS accounts and AWS Regions. Any changes to these controls must be automatically applied to all accounts simultaneously.
The company has the required security controls and compliance policies defined in AWS Clo...
Let’s carefully break this down.
---
Key Requirements:
1. Multi-account environment using AWS Organizations + Control Tower.
2. Deploy standardized security controls and compliance policies across all accounts and regions.
3. Any changes must be automatically applied to all accounts simultaneously.
4. Security controls are already defined in CDK as a construct.
5. Minimize operational overhead.
Key AWS services to consider:
CloudFormation StackSets: Can deploy a template across multiple accounts and regions, but requires managing StackSets.
EventBridge + Lambda automation: Can update StackSets automatically, but requires building and maintaining custom automation.
CloudFormation Macros: Allow template transformations, but still require stack deployment and manual StackSet management.
AWS Control Tower Customizations (Landing Zones): Can automatically enforce guardrails and policies across all accounts, including new accounts, with minimal operational overhead.
---
Option Analysis
---
Option A
> CDK app creates a CloudFormation StackSet from the security controls construct. Targets specific accounts and regions. Automation to deploy the CDK app manages the StackSet.
✅ Works across multiple accounts and regions.
❌ Requires manual automation to redeploy StackSet when controls change.
❌ Moderate operational overhead.
Scenario: Useful if you want full StackSet control manually.
---
Option B
> CDK app synthesizes...
Author: Madison · Last updated Jun 14, 2026
A company needs to manage shared libraries for various projects across its development AWS account and production AWS account. The company has configured IAM roles for developers and has defined an AWS CodePipeline pipeline by using the AWS Cloud Development Kit (AWS CDK).
A DevOps engineer must implement a solution to ensure that only developers can access the latest versions of the libraries. The solution mus...
Let’s carefully analyze this AWS scenario step by step. The key requirements are:
Key Requirements:
1. Manage shared libraries for multiple projects across development and production AWS accounts.
2. Only developers can access the latest versions of libraries.
3. Test shared packages independently before they are consumed by applications or go to production.
4. Integration with AWS CDK / CodePipeline.
We are comparing 4 options. Let’s examine each one.
---
Option A
> Create a single AWS CodeArtifact repository for development and production in a central account. Use IAM policies for developer roles to allow only developers to access the shared libraries. Create an EventBridge role to start CodeBuild and test each package before copying to production.
Analysis:
✅ Pros:
CodeArtifact is specifically designed for package management.
IAM policies can restrict access to developers.
❌ Cons / Issues:
Using a single repository for both dev and production mixes environments, making it hard to isolate testing and production deployments.
A failure in testing could potentially affect production if not managed carefully.
⚠️ This violates the best practice of environment isolation (dev vs prod).
Scenario where this could work: Small teams where isolation between dev and prod is less critical.
---
Option B
> Create a CodeArtifact repository in the dev account and another in the production account. Add a repository policy to allow only developers to access the dev repository. Use EventBridge to start CodePipeline and test each package before it is copied to production.
Analysis:
✅ Pros:
Clear separation between development and production environments, which is a best practice.
IAM policies limit access to developers for the dev repository.
Packages can be independently tested in dev before promotion to production.
Fits naturally with CodePipeline and CodeBuild testing stages.
✅ Cons: Minimal; more resources needed (two repositories), but this is standard practice.
Scenario where this works best: Multi-account setups where dev and prod need strict isolation. Thi...
Author: Charlotte · Last updated Jun 14, 2026
A 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 freq...
The key to this question is identifying what is causing the timeout and what improves user experience for long-running LLM responses.
Step 1: Analyze the architecture
Current architecture:
```
React App
│
AWS Amplify
│
AWS AppSync (GraphQL)
│
Lambda Resolver (RequestResponse)
│
Amazon Bedrock RetrieveAndGenerate
```
The Lambda resolver is using RequestResponse (synchronous invocation).
For simple questions, Bedrock returns quickly.
For complex questions, Bedrock spends more time retrieving documents and generating the answer, causing:
GraphQL request waits
Lambda waits
Client waits
Eventually timeout occurs
The question specifically says:
frequent timeouts
slow response
especially for longer processing
improve user experience
This wording strongly hints toward streaming responses, not simply allowing longer waits.
---
Option A
> Use AWS Amplify AI Kit to implement streaming responses from the GraphQL API and to optimize client-side rendering.
Why this looks attractive
Amplify AI Kit supports building AI applications.
Streaming responses definitely improve UX.
Why it is NOT the best answer
The existing backend uses:
AppSync
Lambda
Bedrock RetrieveAndGenerate API
The bottleneck is RetrieveAndGenerate, which does not stream tokens.
Amplify AI Kit cannot magically make RetrieveAndGenerate stream.
Streaming only works if the backend API itself supports streaming.
This option doesn't solve the backend limitation.
Key factor
❌ Frontend enhancement only.
Backend still waits for full RetrieveAndGenerate response.
---
Option B
> Increase the timeout value of the Lambda resolver. Implement retry logic with exponential backoff.
This is a classic AWS exam distractor.
Increasing timeout
This only allows Lambda to wait longer.
It does not
reduce latency
improve UX
eliminate slow responses
Users still stare at a loading spinner.
Retry logic
Retries are useful when failures are transient.
Examples:
throttling
temporary network issue
service unavailable
Here there is no indication of transient failure.
The requests are simply taking a long time.
Retrying makes things worse.
Key factor
Timeout ≠ Performance improvement.
This treats the symptom instead of the cause.
---
Option C
> Update the application to send an API request to an Amazon SQS queue. Update the AWS AppSync resolver to poll and process the queue.
This changes synchronous processing into asynchronous processing.
SQS is excellent when:
jobs take minutes
background processing
image generation
video transcoding
batch work
But this is an interactive chatbot.
A user expects immediate responses.
Using SQS introduces:
```
User
↓
Queue
↓
Worker
↓
Process
```
Now the application has to
poll
wait
check status
This actually hurts the chatbot experience.
Key factor
SQS...
Author: Alexander · Last updated Jul 5, 2026
An international company is building an AI assistant that uses RAG. The company wants the AI assistant to have near real-time, low-latency performance. The AI assistant must provide service to several geographic areas. The company's customers will use proprietary data with the AI assistan...
The key requirements in the question are:
1. RAG (Retrieval-Augmented Generation) is required.
2. Near real-time, low-latency responses.
3. Serve multiple geographic areas.
4. Proprietary data must never leave its immediate geographic area (data residency).
These requirements are the key to eliminating the wrong options.
---
Requirement Analysis
| Requirement | Implication |
| --------------------------- | ------------------------------------------------------------------------------------------------------- |
| RAG | Need a knowledge base + vector database/retrieval system |
| Near real-time, low latency | Deploy inference close to users (multi-Region) |
| Multiple geographic areas | Regional deployment |
| Data cannot leave region | Retrieval and inference should stay in the same Region (or at least customer data must remain regional) |
The biggest keyword here is:
> Data must not leave the company's immediate geographic area.
This usually means:
Regional S3
Regional Knowledge Base
Regional Vector Store
Regional Bedrock inference
Cross-region movement of prompts containing retrieved proprietary data is generally not acceptable.
---
Option A
> Deploy an Amazon Bedrock model with a cross-Region model inference profile.
> Create S3 buckets in each Region.
> Store knowledge base in each Region.
> Configure Amazon Kendra.
> Lambda invokes Kendra + Bedrock.
Good
✔ Regional knowledge bases
✔ Regional storage
✔ Regional retrieval
Problems
The major issue is:
> Cross-Region model inference profile
Cross-Region inference means Bedrock may send inference requests to another Region if capacity is needed.
For RAG:
```
User Prompt
↓
Retrieve proprietary documents
↓
Prompt + retrieved documents
↓
LLM
```
Those retrieved documents are proprietary.
If inference happens in another Region:
```
Retrieved proprietary data
↓
Leaves Region
```
That violates:
> Proprietary data must not leave immediate geographic area.
Another issue
Amazon Kendra is a search service.
Today, Amazon Bedrock Knowledge Bases is the AWS-recommended managed RAG solution.
Using Kendra isn't wrong generally, but it isn't the preferred architecture for Bedrock RAG questions.
Verdict
❌ Reject.
Key rejection factor
> Cross-region inference may move proprietary retrieved context outside the Region.
---
Option B
> Deploy Bedrock model in every Region.
>
> Configure Bedrock Knowledge Bases.
>
> Regional S3 buckets.
>
> Regional vector database.
>
> Configure cross-Region inference profile.
This option is slightly tricky.
Notice the wording:
> Deploy Bedrock model in each Region.
That satisfies locality.
Also:
Knowledge Base is regional.
S3 is regional.
Vector DB is regional.
The questionable part:
> Configure cross-Region inference profile.
In practice, you simply would not use it for requests requiring data residency.
AWS exam writers often include extra configuration that isn't necessary.
The important architecture is:
```
Region A
---------
Bedrock
Knowledge Base
Vector DB
S3
Region B
---------
Bedrock
Knowledge Base
Vector DB
S3
```
Everything needed for RAG exists locally.
Unlike Option A, Bedrock is actually deployed in every Region.
This is the closest match to AWS's recommended architecture.
Verdict
✅ Best answer.
---
Option C
> AWS Outposts
>
> Regional S3
>
> RDS vector DB on Outposts
>
> Bedrock model in one central Region with cross-region inference.
Problems:
Bedrock cannot run on Outposts.
Outposts extends AWS infrastructure on-premises, but Bedrock is a managed AWS service.
Even worse:
```
Outposts
↓
Retrieve data
...
Author: Max · Last updated Jul 5, 2026
A company deploys multiple Amazon Bedrock based generative AI (GenAI) applications across multiple business units for customer service, content generation, and document analysis. Some applications show unpredictable token consumption patterns. The company requires a comprehensive observability solution that provides real-time visibility into token usage patterns across multiple models. The observability solution must support custom dashboards for multiple stakeholder groups and provide alerting ca...
The key phrase in the question is "comprehensive observability" with least operational overhead.
Requirements
Real-time visibility into token usage patterns
Across multiple foundation models (FMs)
Custom dashboards for different stakeholders
Alerting on token consumption
Least operational overhead
The best match is:
D → Native visualization of Amazon Bedrock token usage with Amazon Managed Grafana zero-ETL integration
C → Native CloudWatch dashboards + CloudWatch alarms for monitoring and alerting
---
Option C ✅ Selected
> Create custom Amazon CloudWatch dashboards that combine native Amazon Bedrock token and invocation CloudWatch metrics. Set up CloudWatch alarms to monitor token usage thresholds.
Why this is correct
CloudWatch is the native monitoring service for AWS.
It provides:
Native Amazon Bedrock metrics
Token usage metrics
Invocation metrics
CloudWatch Dashboards
CloudWatch Alarms
The question explicitly requires alerting capabilities, and CloudWatch Alarms are the standard AWS solution.
Key factors
✔ Native integration
✔ Real-time metrics
✔ Built-in alarms
✔ Low operational overhead
When would you choose this?
Whenever the exam mentions:
Monitoring AWS services
Threshold alerts
Native AWS monitoring
Operational simplicity
CloudWatch is usually the first choice.
---
Option D ✅ Selected
> Create dashboards that show token usage trends and patterns across the company's FMs by using an Amazon Bedrock zero-ETL integration with Amazon Managed Grafana.
Why this is correct
The question asks for:
Multiple stakeholder dashboards
Token usage across multiple models
Real-time observability
Least operational overhead
Amazon Managed Grafana is designed for operational dashboards.
The important keyword is:
> zero-ETL
Zero-ETL means:
No pipelines
No custom data movement
No transformation jobs
Minimal maintenance
This directly satisfies least operational overhead.
Grafana also excels at:
Multiple dashboards
Different stakeholder views
Real-time visualization
Rich operational observability
Key factors
✔ Real-time dashboards
✔ Multiple stakeholder views
✔ Zero-ETL
✔ Native integration
---
Why the other options are rejected
---
Option A ❌
> U...
Author: Noah Williams · Last updated Jul 5, 2026
A company is building a legal research AI assistant that uses Amazon Bedrock with an Anthropic Claude foundation model (FM). The AI assistant must retrieve highly relevant case law documents to augment the FM's responses. The AI assistant must identify semantic relationships between legal concepts, specific legal te...
The correct answer is:
> ✅ B) Use Amazon OpenSearch Service to deploy a hybrid search architecture that combines vector search with keyword search. Apply an Amazon Bedrock reranker model to optimize result relevance.
Let's analyze the requirements first.
---
Step 1: Identify the key requirements
The question gives several important clues.
| Requirement | What it means |
| --------------------------------- | --------------------------------- |
| Retrieve highly relevant case law | High retrieval accuracy |
| Augment FM responses (RAG) | Retrieval-Augmented Generation |
| Semantic relationships | Need vector/embedding search |
| Specific legal terminology | Exact keyword matching |
| Legal citations | Exact phrases like "410 U.S. 113" |
| Perform quickly | Efficient retrieval engine |
| Precise results | Ranking/reranking needed |
Notice there are three retrieval needs:
Semantic meaning
Exact legal terms
Exact citations
One search technique alone is usually insufficient.
---
Why Hybrid Search?
Legal data is one of the classic examples where hybrid search performs much better than vector search alone.
Example:
Query:
> cases discussing "strict scrutiny" under the Equal Protection Clause citing Brown v. Board
Vector search finds
Equal protection
Constitutional law
Civil rights
But it might miss
"strict scrutiny"
"Brown v. Board"
exact citation
Keyword search finds
strict scrutiny
Brown
citation numbers
Hybrid combines both.
AWS recommends hybrid search for domains like
Legal
Healthcare
Finance
Scientific research
---
Why reranking?
After retrieving many documents,
the Bedrock reranker evaluates
> Which documents are actually most relevant?
Example
Initial search returns
1. Equal protection article
2. Brown v Board summary
3. Supreme Court opinion
4. Law review paper
The reranker places the truly relevant legal opinion at the top.
This increases precision.
---
Option B Analysis
> Use Amazon OpenSearch service to deploy a hybrid search architecture that combines vector search with keyword search. Apply an Amazon Bedrock reranker model to optimize result relevance.
Why it satisfies every requirement
✅ Semantic relationships
Vector search
---
✅ Legal terminology
Keyword search
---
✅ Citations
Keyword search
---
✅ High relevance
Bedrock reranker
---
✅ Fast
OpenSearch is optimized for low-latency retrieval.
---
This exactly matches AWS best practices for advanced RAG.
---
Why Option A is wrong
> Configure an Amazon Bedrock knowledge base to use a default vector search configuration. Use Amazon Bedrock to expand queries...
At first glance this looks attractive.
But notice two words:
> default vector search
Default Bedrock Knowledge Bases use semantic vector search.
Vector search is excellent for meaning.
But legal datasets require
exact statute names
section numbers
citations
legal phrases
Vector search alone often misses these.
---
Query expansion helps produce more semantic variations.
Example
Original query
> negligence
Expanded
> tort liability
> duty of care
Useful.
But query expansion does not solve
exact citations
keyword precision
---
Key weakness
❌ No hybrid search
❌ No keyword search
❌ No reranking
---
When is Option A appropriate?
Use when
Enterprise FAQs
Product manuals
Internal documents
HR policies
Customer support
where semantic meaning matters more than exact terminology.
---
Why Option C is wr...
Author: RadiantJaguar56 · Last updated Jul 5, 2026
A financial services company is creating a Retrieval Augmented Generation (RAG) application that uses Amazon Bedrock to generate summaries of market activities. The application relies on a vector database that stores a small proprietary dataset that has a low index count. The application must perform similarity searches. The Amazon Bedrock model's responses must maximize accuracy an...
The key to this question is identifying the best vector index algorithm for the given workload.
Step 1: Identify the requirements
The question gives several important clues.
| Requirement | Key Factor |
| ------------------------------------ | ----------------------------------- |
| RAG application using Amazon Bedrock | Needs vector similarity search |
| Small proprietary dataset | Low index count |
| Perform similarity searches | Vector database required |
| Maximize accuracy | Recall is more important than speed |
| Maintain high performance | Efficient query execution |
The biggest deciding factor is:
> Small dataset + Maximum accuracy
This immediately points toward Flat indexing, because Flat performs exact nearest neighbor (ENN) search.
---
Understanding the index algorithms
1. Flat Index
How it works
Compares the query vector against every vector.
Finds the true nearest neighbors.
Exact search.
Advantages
100% recall (highest accuracy)
Best for small datasets
Simple index
No approximation errors
Disadvantages
Slow for very large datasets because every vector is searched.
When AWS expects Flat
Use Flat when:
Small datasets
Accuracy is most important
Low index count
RAG knowledge bases with proprietary documents
---
2. HNSW (Hierarchical Navigable Small World)
Approximate Nearest Neighbor (ANN).
Instead of checking every vector, it builds a graph.
Advantages:
Extremely fast
Very scalable
Good recall
Disadvantages:
Not exact
Slightly lower accuracy
More memory usage
AWS exam keyword
Use HNSW when:
Millions of vectors
Large vector databases
Low latency
Real-time search
---
3. IVFFlat
Clusters vectors.
Search checks only selected clusters instead of the whole dataset.
Advantages
Faster than Flat
Uses less compute
Disadvantages
Approximate
Lower recall than Flat
Needs training before indexing
Doesn't perform well with small datasets
AWS exam keyword
Use IVFFlat when
Large datasets
Speed is preferred over exact accuracy
---
Evaluate each option
Option A
> Launch an Amazon MemoryDB cluster and configure the index by using the Flat algorithm. Configure a horizontal scaling policy based on performance metrics.
Why it matches
MemoryDB supports vector search.
Flat index
✔ Exact nearest neighbor search
Dataset
✔ Small
Accuracy
✔ Highest
Performance
Since dataset is small, Flat remains fast enough.
Horizontal scaling
Adds more nodes if workload increases.
Nothing contradicts the requirements.
Verdict
✅ Best answer.
---
Option B
> Launch ...
Author: Evelyn · Last updated Jul 5, 2026
A company is implementing a serverless inference API by using AWS Lambda. The API will dynamically invoke multiple AI models hosted on Amazon Bedrock. The company needs to design a solution that can switch between model providers without modifying or redeploying Lambda code in real time. The design must i...
The key requirement is not just dynamic configuration, but also:
✅ Switch model providers without modifying/redeploying Lambda
✅ Real-time configuration changes
✅ Safe rollout of configuration changes
✅ Validation
✅ Automatic rollback
These last three requirements are the deciding factors.
---
Option A) Store the active model provider in AWS Systems Manager Parameter Store.
How it works
Lambda reads a parameter like:
```
CurrentProvider = Anthropic
```
Later, you change it to
```
CurrentProvider = Amazon Nova
```
Lambda automatically starts using the new provider.
Advantages
No Lambda redeployment
Runtime configuration
Simple
Good for feature flags or small configuration values
Why it is rejected
The question specifically asks for:
Safe rollout
Validation
Rollback
Parameter Store does not provide deployment strategies.
It cannot:
gradually roll out configuration
validate deployments
automatically roll back bad configurations
You would have to build all those mechanisms yourself.
Key factor
✔ Runtime configuration
❌ No controlled deployment strategy
---
When should you use Parameter Store?
Use it for:
database connection strings
API endpoints
feature toggles
passwords (with SecureString)
environment configuration
when you simply need configuration storage.
---
Option B) Store the active model provider in AWS AppConfig.
How it works
Lambda reads configuration from AppConfig.
Example:
```json
{
"provider":"Anthropic"
}
```
Later AppConfig changes it to
```json
{
"provider":"Amazon Nova"
}
```
without redeploying Lambda.
---
Why this matches every requirement
AWS AppConfig is specifically designed for dynamic application configuration.
It supports:
Runtime configuration
Lambda reads configuration dynamically.
✔ Requirement satisfied.
---
Safe rollout
AppConfig supports deployment strategies such as:
10%
25%
Linear
Canary
Instead of changing configuration instantly.
Example
```
10% traffic
↓
25%
↓
50%
↓
100%
```
If problems occur, deployment stops.
---
Validators
AppConfig supports validation before deployment.
Example
Ensure
```
provider
```
is one of
```
Anthropic
Amazon Nova
Meta
Mistral
```
instead of an invalid value.
---
Automatic rollback
AppConfig integrates with:
CloudWatch alarms
If alarms trigger after deployment,
AppConfig automatically rolls back.
Exactly what the question asks.
---
Key factors
✔ Runtime configuration
✔ Safe deployment
✔ Validators
✔ Automatic rollback
This perfectly matches all requirements.
---
When should you use AppConfig?
Whenever applications need:
feature flags
runtime configuration
gradual rollout
configuration validation
rollback
A/B deployments
production-safe configuration changes
---
Option C) Configure API Gateway to route requests to separate Lambda functions.
How it works
Example
```
API Gateway
|
Lambda A -> Anthropic
Lambda B -> Nova
Lambda C -> Meta
```
Switch integration manually.
---
Advantages
Can switch providers.
---
Wh...
Author: Kunal · Last updated Jul 5, 2026
A company uses Amazon Bedrock to build a Retrieval Augmented Generation (RAG) system. The RAG system uses an Amazon Bedrock knowledge base that is based on an Amazon S3 bucket as the data source for emergency news video content. The system retrieves transcripts, archived reports, and related documents from the S3 bucket.
The RAG system uses state-of-the-art embedding models and a high-performing retrieval setup. However, users report slow responses and irrelevant results, which cause decreased user satisfaction. The company notices that vector searches are evaluating too many documents across too many content types and over long periods of time.
The company determ...
Let’s analyze this AWS exam-style scenario carefully:
---
✅ Correct Option
- C) Enable metadata-aware filtering within the Amazon Bedrock knowledge base by indexing S3 object metadata
- Why selected: The problem is that vector searches are evaluating too many documents across too many content types and over long periods of time, leading to slow responses and irrelevant results. Metadata-aware filtering allows you to constrain retrieval by attributes such as content type, date, or category. This provides smarter constraints without requiring architectural changes or migration.
- Scenario use: For emergency news content, metadata filters can restrict searches to transcripts from the last 30 days or only video-related documents, improving both speed and relevance.
---
❌ Incorrect Options
- A) Enhance embeddings with a domain-adapted model
- Why rejected: The company already determined that fine-tuning or changing models will not improve performance. Th...
Author: Oscar · Last updated Jul 5, 2026
An ecommerce company is using Amazon Bedrock to build a customer service AI assistant. The AI assistant needs to process over 50,000 customer inquiries every day. The AI assistant occasionally experiences traffic spikes of up to 150,000 inquiries every day during promotional events. Analysis shows that 40% of inquiries follow similar patterns that share the same context.
A GenAI developer must design a s...
To meet the requirements—low latency, consistent performance during traffic spikes, and cost efficiency—the key signals in the question are:
Highly variable traffic (50,000/day → spikes to 150,000/day)
40% repeated/similar inquiries → strong caching opportunity
Need for Bedrock-based GenAI optimization
---
✅ Correct Answer: A
A) Configure latency-optimized inference + prompt caching (Amazon Bedrock)
This is the most cost-effective and purpose-built option.
Why it works:
Latency-optimized inference reduces response time during high load by optimizing model execution paths.
Prompt caching in Amazon Bedrock directly addresses the key insight: 40% of queries are repetitive or pattern-based.
Cached responses avoid re-invoking the model → lower cost + lower latency + better scalability during spikes.
No need for external infrastructure or overprovisioning.
When to use this:
High proportion of repeated or similar prompts
Unpredictable or bursty traffic patterns
Need to minimize model invocation costs in Bedrock-native workloads
---
❌ Why other options are not optimal
B) Provisioned throughput + ElastiCache (Redis OSS)
Provisioned throughput requires sizing for peak load (150k/day spikes) → leads to overprovisioning and higher cost
Redis caching is useful, but:
It’s external to Bedrock, adding complexity
You are duplicating caching mechanisms (Redis + no native prompt optimization)
Best suited for:
Systems needing strict capac...
Author: SolarFalcon11 · Last updated Jul 5, 2026
A company has set up Amazon Q Developer Pro licenses for all developers at the company. The company maintains a list of approved resources that developers must use when developing applications. The approved resources include internal libraries, proprietary algorithmic techniques, and sample code with approved styling.
A new team of developers is using Amazon Q Developer to develop a new Java-based application. The company mu...
The correct answer is D) Create an Amazon Q Developer customization that includes the approved data sources. Ensure that the developers use the customization to develop the application.
Why Option D is correct
Amazon Q Developer customizations are specifically designed to centrally enforce organizational coding standards, internal libraries, proprietary patterns, and approved code examples without requiring any changes to individual projects.
Key factors:
No project-level changes required (meets a hard constraint in the question).
Centralized governance: approved resources are embedded into the customization.
Consistent enforcement across all developers and teams using Amazon Q.
Scales well for enterprise use cases (policies, internal SDKs, coding standards).
When this option is used:
Organization-wide coding standards enforcement
Internal framework/library usage enforcement
Avoiding duplication of resources in every repo
Controlling AI-generated suggestions consistently across teams
---
Why other options are incorrect
A) Git repository + @workspace context
Requires modifying the project workspace (violates requirement: no project-level modifications).
Relies on developers to correctly use `@works...
Author: Daniel · Last updated Jul 5, 2026
A company uses Amazon Bedrock to generate technical content for customers. The company has recently experienced a surge in hallucination outputs when the company's model generates summaries of long technical documents. The model outputs include inaccurate or fabricated details. The company's current solution uses a large foundation model (FM) with a basic one-shot prompt that includes the full document in a single input.
The company needs a solution that will reduce hallucinations and meet fact...
The requirements are: reduce hallucinations, improve factual accuracy, support >1,000 documents/hour, and keep per-document latency within ~3 seconds. The key design principle here is grounding outputs in source text while keeping inference lightweight and scalable.
---
✅ B) Use Retrieval Augmented Generation (RAG) with an Amazon Bedrock knowledge base
This is the most important and correct solution.
RAG ensures the model does not rely purely on its internal parametric memory. Instead, it:
Retrieves relevant chunks of the document using embeddings
Grounds generation strictly in retrieved text
Uses semantic chunking, which improves context alignment for long documents
Significantly reduces hallucinations because the model is forced to stay close to source material
Why it fits the requirements:
Strong factual accuracy improvement (core requirement)
Works well at scale with Bedrock Knowledge Bases
Supports high throughput with pre-indexed embeddings
Maintains low latency during inference (fast retrieval + generation)
Use case: Best for long-document summarization, Q&A over documents, enterprise knowledge assistants.
---
⚠️ A) Zero-shot chain-of-thought (CoT) with explicit fact verification
This option is partially helpful but not sufficient alone.
It attempts to:
Force step-by-step reasoning
Encourage the model to “ch...
Author: David · Last updated Jul 5, 2026
A company provides a service that helps users from around the world discover new restaurants. The service has 50 million monthly active users. The company wants to implement a semantic search solution across a database that contains 20 million restaurants and 200 million reviews. The company currently stores the data in a PostgresQL database.
The solution must support complex natural language queries and return results for at least 95% of queries within 500 ms. The solution must maintai...
The key requirements here are:
Semantic search over 20M restaurants + 200M reviews
Natural language query understanding (not just keyword matching)
≤ 500 ms latency at scale (50M MAUs, peak spikes)
Hourly freshness updates
Least development effort (strongest deciding factor)
---
Option A: OpenSearch with keyword search + custom query parsing
This approach uses Amazon OpenSearch Service with custom analyzers and an API layer (API Gateway + transformation logic).
Why it does NOT meet requirements
It is primarily keyword-based search, not true semantic understanding.
Requires manual NLP → structured query conversion, which is complex and brittle.
Significant engineering effort for:
query parsing logic
relevance tuning
maintaining analyzers across 20M+ docs
Does not natively support modern embedding-based semantic retrieval.
When it would be used
Traditional search engines (filters, facets, structured queries like cuisine, rating, location).
Systems where interpretability and exact matching matter more than semantic understanding.
---
Option B: OpenSearch + Amazon Bedrock embeddings + k-NN
This introduces vector embeddings via Amazon Bedrock and performs similarity search using OpenSearch k-NN.
Strengths
Supports true semantic search
OpenSearch handles vector indexing + low-latency k-NN search
Scales reasonably well for large datasets
Why it is NOT the best (least effort constraint)
Requires building and maintaining:
embedding generation pipeline (batch + real-time)
synchronization between Postgres → OpenSearch
query-time embedding generation logic
More operational complexity than fully managed RAG services
When it would be used
When you already use OpenSearch heavily and want custom control over retrieval + ranking
When you need hybrid search (keyword + vector fusion tuning)
---
Option C: PostgresQL + pgvector
This keeps ...
Author: Leo · Last updated Jul 5, 2026
An ecommerce company is using Amazon Bedrock to build a generative AI (GenAI) application. The application uses AWS Step Functions to orchestrate a multi-agent workflow to produce detailed product descriptions. The workflow consists of three sequential states: a description generator, a technical specifications validator, and a brand voice consistency checker. Each state produces intermediate reasoning traces and outputs that are passed to the next state. The application uses an Amazon S3 bucket for process storage and to store outputs.
During testing, the company discovers that outputs between Step Functions states frequently exceed the 256 KB quota and cause workflow failures.
A GenAI Developer needs to r...
Key constraint
AWS Step Functions has a 256 KB payload limit per state input/output. The workflow also must:
Preserve multi-agent ReAct pattern (reasoning + acting with intermediate traces)
Maintain observability
Minimize operational overhead
So the core design pattern needed is:
👉 Store large payloads externally + pass references inside Step Functions
---
Option A — DynamoDB with references + Map state retrieval
Why it works technically
DynamoDB can store structured intermediate outputs safely beyond Step Functions limits (within item size limits).
Passing only keys/ARNs keeps Step Functions payload small.
Map state + retrieval enables per-agent processing and scaling.
Pros
Good observability (data stored in queryable DB)
Works well for structured intermediate reasoning traces
Maintains ReAct flow via sequential retrieval
Cons
More moving parts (table design, read/write, consistency handling)
Requires additional IAM + partition key design
Slightly higher operational overhead than S3-based reference passing
Best used when
You need fast lookup + structured state transitions
Fine-grained querying of intermediate reasoning is required
Strong consistency tracking per step is important
---
Option B — S3-based orchestration with ResultPath + ResultSelector
Why this is correct
Amazon S3 is already used in the architecture → no new storage system introduced
Step Functions can pass S3 URIs instead of full payloads
Each agent writes large outputs to S3, and only metadata/reference flows between states
ResultPath / ResultSelector cleanly control:
what is stored
what is passed forward
Preserves sequential workflow and ReAct pattern
Minimal compute and infrastructure overhead
Pros
✅ Lowest operational overhead (already using S3)
✅ Fully avoids 256 KB limit by design
✅ Maintains observability via S3 objects (versioning, logs, trace files)
✅ Native AWS pattern for large payload orchestration
✅ No extra compute layer required
Best used when
Large outputs (LLM respon...
Author: Liam · Last updated Jul 5, 2026
A retail company is developing a customer service application that must process 10,000 daily queries about products, orders, and warranties. The application must be able to respond to queries about 50,000 product documents that are updated every day. The application must integrate with an order management API to check the status of orders and to help process returns. The application must maintain context throughout multi-turn...
The correct choice is D.
Why Option D is best (least operational overhead)
This scenario needs:
~10,000 daily queries (moderate-to-high throughput)
50,000 frequently updated product documents
Multi-turn conversational context
Integration with an order management API (returns, order status)
Full audit trails of responses
Minimized operational overhead
Option D uses:
Amazon Bedrock Agents
Action groups for API integration
Knowledge Base (RAG) for document retrieval
Built-in trace logs for auditability
This is a fully managed, end-to-end GenAI orchestration solution, which directly maps to all requirements with minimal infrastructure management.
Key advantages:
No need to train or fine-tune models manually
No need to manage vector databases or search infrastructure explicitly
Built-in multi-turn conversation handling via the agent framework
Native integration with APIs through action groups
Built-in observability and audit trails via trace events
---
Why other options are rejected
❌ A) Fine-tuned Claude per product category + Lambda + DynamoDB
Uses model fine-tuning per category → high maintenance overhead
Requires managing multiple models and deployments
Conversation history stored manually in Amazon DynamoDB
API integration via AWS Lambda adds glue code complexity
When this is used:
When you need highly specialized mo...
Author: Sophia Clark · Last updated Jul 5, 2026
A company is building an AI advisory application by using Amazon Bedrock. The application will provide recommendations to customers. The company needs the application to explain its reasoning process and cite specific sources for data. The application must retrieve information from company data sources and show step-by-step reasoning for recommendations. The application must also ...
The requirements emphasize four things: managed low-ops RAG, source-level citations, fast response (<3s latency), and some level of explainability tied to retrieved company data. The key constraint is minimizing operational overhead while still using AWS-native managed capabilities.
---
✅ Correct choice: A
Why Option A is correct
Amazon Bedrock Knowledge Bases provides a fully managed RAG (Retrieval-Augmented Generation) pipeline.
It automatically ingests company data from supported sources (S3, etc.).
Handles chunking, embedding, indexing, and retrieval with minimal setup.
Source attribution enabled directly satisfies the requirement to:
Link answers to specific source documents
Provide traceability for each claim
Anthropic Claude Messages API + RAG ensures:
High-quality grounded responses
Configurable retrieval thresholds to improve relevance and reduce hallucinations
Low operational overhead
No custom retrieval layer
No separate databases for citations or reasoning storage required for runtime
Latency requirement (<3s)
Bedrock Knowledge Bases are optimized for low-latency retrieval + inference pipelines
When Option A is typically used
Use this pattern when:
You want enterprise document Q&A systems
You need citations from internal documents
You want fully managed RAG with minimal infrastructure
You need fast deployment and low maintenance
---
❌ Why other options are incorrect
❌ B) Bedrock + extended thinking + DynamoDB traces
...
Author: Isabella1 · Last updated Jul 5, 2026
A financial services company uses an AI application to process financial documents by using Amazon Bedrock. During business hours, the application handles approximately 10,000 requests each hour, which requires consistent throughput.
The company uses the CreateProvisionedModelThroughput API to purchase provisioned throughput. Amazon CloudWatch metrics show that the provisioned capacity is unused while on-demand requests are being throttled. The company finds the following code in the application: python response = bedrock_ru...
✅ Correct approach: B) Replace the model ID parameter with the ARN of the provisioned model that the CreateProvisionedModelThroughput API returns.
---
🔍 Key idea in the scenario
The company has already purchased provisioned throughput using `CreateProvisionedModelThroughput`, but:
CloudWatch shows unused provisioned capacity
Meanwhile, requests are still being throttled
This combination is a strong signal that:
> ❗ The application is not actually using the provisioned throughput endpoint, and is still calling the on-demand model
The code confirms this:
```python
bedrock_runtime.invoke_model(
modelId="anthropic.claude-v2",
body=json.dumps(payload)
)
```
This is the on-demand model ID, not the provisioned throughput identifier.
---
✅ Why Option B is correct
When using Amazon Bedrock provisioned throughput:
You must call the model using the provisioned model ARN (or inference profile ARN) returned by the provisioning API
This routes traffic to the reserved capacity, not shared on-demand capacity
What changes with Option B:
Requests are directed to dedicated provisioned capacity
Eliminates throttling caused by on-demand limits
Ensures purchased capacity is actually utilized
Key concept:
> Provisioned throughput is not automatically used just because it exists — the application must ex...
Author: Kunal · Last updated Jul 5, 2026
A company is designing a canary deployment strategy for a payment processing API. The system must support automated gradual traffic shifting between multiple Amazon Bedrock models based on real-time inference metrics, historical traffic patterns, and service health. The solution must be able to gradually increase traffic to new model versions. The system must increase traffic if metrics remain healthy and decrease traffic if the performance degrades below acceptable thresholds.
The company needs to comprehensively monitor in...
Key requirements in this question are a fully automated canary deployment loop for Amazon Bedrock models, with:
Gradual traffic shifting (progressive delivery)
Closed-loop decision making based on real-time CloudWatch metrics (latency, errors)
Automated rollback without manual intervention
Ability to scale traffic up/down dynamically based on health signals
Orchestration of deployment workflow
The best solution must therefore include an orchestrator (Step Functions or equivalent) plus metric-based decisioning and automated traffic control.
---
✅ Correct Option: A
Why Option A is correct
Option A uses a well-architected AWS-native closed-loop canary deployment system:
Amazon Bedrock with provisioned throughput hosts model versions → correct service for hosting foundation model inference.
Amazon EventBridge triggers deployment workflow automatically when a new model version is released.
AWS Step Functions orchestrates the canary process:
Gradual traffic shifting in stages (true canary deployment pattern)
Wait periods between stages (for metric stabilization)
AWS Lambda + Amazon CloudWatch metrics:
Evaluates latency and error rates in real time
Decides whether to increase traffic or trigger rollback
Fully automated rollback path ensures no manual intervention
Why this works best
This option implements a feedback-controlled deployment loop:
> Deploy → Shift traffic → Observe metrics → Decide → Increase / Rollback
This is exactly what is needed for production-grade canary deployments on inference APIs.
---
❌ Why other options are wrong
❌ Option B (API Gateway weighted routing + external logic)
Uses API Gateway stage variables + weighted routing, which can do tra...
Author: Akash · Last updated Jul 5, 2026
A financial services company needs to build a document analysis system that uses Amazon Bedrock to process quarterly reports. The system must analyze financial data, perform sentiment analysis, and validate compliance across batches of reports. Each batch contains 5 reports. Each report requires multiple foundation model (FM) calls. The solution must finish ...
The core requirement is reducing total batch processing time from 45 seconds to ≤10 seconds, despite each batch containing 5 reports and each report requiring multiple Amazon Bedrock FM calls. This immediately points to a need for high parallelism (fan-out/fan-in pattern) rather than sequential or lightly concurrent processing.
---
✅ Correct Approach: Option B
B) Use AWS Step Functions with a Parallel state to invoke separate AWS Lambda functions for each analysis type simultaneously...
Why this works
This is the only option that explicitly enables true orchestration-level parallelism, which is essential here:
Step Functions Parallel state
Executes multiple branches at the same time.
Can process:
Each report in parallel (5-way parallelism)
Each analysis type in parallel (financial analysis, sentiment analysis, compliance checks)
Lambda per task
Each function independently calls Amazon Bedrock models.
Avoids blocking and sequential FM calls.
Fan-out/fan-in design
Fan out: split 5 reports × multiple analyses
Fan in: aggregate results at the end
Why it meets the 10-second SLA
Instead of:
5 reports × sequential FM calls = ~45 seconds
It becomes:
Parallel execution across reports + analysis types
Total time ≈ longest single execution path, not sum of all tasks
This is the standard AWS pattern for high-throughput document processing pipelines using Step Functions + Lambda + Bedrock.
---
❌ Why other options are incorrect
A) Lambda with provisioned concurrency + sequential processing
Provisioned concurrency only improves cold start latency, not execution parallelism.
Still processes:
analysis types sequentially ❌
reports sequenti...
Author: Aria · Last updated Jul 5, 2026
A 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 ...
Key requirements breakdown
The solution must:
Produce consistent structured output (summary, risks, flagged terms)
Adapt tone per business unit (legal, HR, finance, etc.)
Provide centralized prompt management across teams
Include content moderation (hate speech, sensitive info, etc.)
Allow easy future tuning of moderation rules
Minimize ongoing orchestration and maintenance overhead
The critical AWS-native signals here are:
Use of Amazon Bedrock Prompt Management → for reusable prompt templates and variants
Use of Amazon Bedrock Guardrails → for centralized, adjustable content filtering and safety controls
---
Option analysis
✅ A) Bedrock Prompt Management + Bedrock Guardrails (correct)
This option directly matches all requirements.
Why it works:
Prompt Management
Centralized reusable prompt templates
Supports business-unit-specific variants (legal, HR, finance tone differences)
Reduces duplication and maintenance overhead
Bedrock Guardrails
Built-in category filters (hate speech, harmful content, etc.)
Supports sensitive term lists (e.g., PHI/PII-like controls)
Central governance of safety rules across all applications
Can be updated centrally without changing app logic
Key advantage:
Minimal orchestration (no Lambda, Step Functions, or external filtering pipeline)
Native integration = lowest operational overhead
Best fit scenario:
Enterprise GenAI assistant requiring:
standardized outputs
multi-team prompt governance
built-in safety and compliance controls
---
❌ B) Prompt Management + system variables + “audience-based threshold tuning” + internal API
Why it’s wrong:
“Audience-based threshold tuning” is not a standard Bedrock Guardrails feature in this way
Requires custom internal admin API → increases operational burden
Still partially correct conceptually (Prompt Management is good), but:
...
Author: Madison · Last updated Jul 5, 2026
A financial services company is developing a Retrieval Augmented Generation (RAG) application to help investment analysts query complex financial relationships across multiple investment vehicles, market sectors, and regulatory environments. The dataset contains highly interconnected entities that have multi-hop relationships. The analysts must be able to examine the relationships holistically to provide accurate investment guidance. The application must deliver comprehensive answer...
The correct answer is A) Use Amazon Bedrock Knowledge Bases with Graph RAG and Amazon Neptune Analytics to store the financial data.
---
Why Option A is correct
This solution best matches all requirements:
Multi-hop relationship reasoning (core requirement):
Amazon Neptune Analytics provides a graph-based data model, which is specifically designed to represent and traverse complex, interconnected financial relationships (e.g., investment vehicles → holdings → sectors → regulatory links). This enables native multi-hop traversal instead of simulating relationships.
RAG with structured reasoning:
Amazon Bedrock Knowledge Bases integrated with Graph RAG allows retrieval not only from documents but also from relationship-aware graph queries, improving answer completeness and contextual depth.
Low operational overhead:
Both Bedrock Knowledge Bases and Neptune Analytics are managed services, eliminating the need to build custom indexing, orchestration, or embedding pipelines.
Performance requirement (<3 seconds):
Graph databases like Neptune are optimized for fast traversal queries, and Bedrock provides low-latency retrieval + generation, meeting the strict response time requirement.
When to use this pattern:
Use this when:
Data has deep entity relationships (multi-hop graphs)
You need semantic + relational retrieval
You want fully managed AWS-native RAG with minimal infrastructure management
---
Why other options are incorrect
❌ B) OpenSearch vector store + Lambda sequential querying
...
Author: Sofia2021 · Last updated Jul 5, 2026
A company is using AWS Lambda and REST APIs to build a reasoning agent to automate support workflows. The system must preserve memory across interactions, share the relevant agent state, and support event-driven invocation and synchronous invocation. The system must also enforce ac...
Key requirements in this question are: persistent memory across sessions, shared agent state, event-driven + synchronous invocation support, and built-in access control/session permissions, while also being highly scalable with minimal custom orchestration.
✅ Selected Option A — Amazon Bedrock AgentCore (managed agent runtime)
Why it fits:
Provides session-aware reasoning and built-in memory management, so the agent can maintain context across interactions without custom storage logic.
Supports identity-aware access control, which helps enforce session-based permissions.
Includes built-in observability and event handling, reducing operational overhead.
Best suited for fully managed, scalable agent deployments where you want minimal infrastructure design.
When to use:
Use this when you want a serverless, fully managed reasoning agent platform that handles memory, identity, and orchestration internally.
---
✅ Selected Option B — API Gateway + EventBridge + AgentCore actions integration
Why it fits:
Amazon API Gateway enables synchronous REST API invocation of Lambda functions.
Amazon EventBridge enables event-driven asynchronous invocation and decoupled workflows.
Registering Lambda/REST APIs as AgentCore actions allows the agent to call tools without custom orchestration code.
This creates a hybrid invocation model (sync + async) with high scalability and loose coupling.
When to use:
Use this when you need a tool-using agent architecture that integrates external systems (APIs/Lambda) in ...
Author: Noah Williams · Last updated Jul 5, 2026
A financial services company is developing a customer service AI assistant by using Amazon Bedrock. The AI assistant must not discuss investment advice with users. The AI assistant must block harmful content, mask personally identifiable information (PII), and maintain audit trails for compliance reporting. The AI assistant must apply content filtering to both user inputs and model responses based on content sensitivity.
The company requires an Amazon Bedrock guardrail configuration ...
The correct answer is C.
Amazon Bedrock Guardrails are designed to enforce safety and compliance policies within a single, unified guardrail configuration, where you can combine multiple policy types such as content filters, denied topics, and sensitive information controls. The requirement emphasizes minimal false positives, multiple handling strategies, and both input and output filtering, which aligns best with a balanced, single-guardrail approach using configurable sensitivity levels.
---
Why C is correct
Option C uses a well-balanced, single guardrail design with multiple complementary controls:
1. Content filtering at medium sensitivity
Medium reduces unnecessary blocking compared to “high” (used in A), helping achieve lower false positives while still catching harmful content.
2. Denied topics for investment advice with definitions and examples
This is the correct Bedrock mechanism for policy enforcement on specific domains like financial advice.
Including clear definitions + sample phrases improves accuracy and reduces overblocking.
3. PII handling with dual strategy
Masking PII in responses preserves usability (e.g., redacting names/account numbers instead of blocking everything).
Blocking sensitive financial info in inputs helps prevent leakage early in the pipeline.
4. Input and output evaluation enabled
Ensures compliance both when users submit prompts and when the model responds.
This is explicitly required in the question.
5. Custom blocked messages + audit support
Supports compliance reporting and traceability, which is critical in financial services environments.
Overall, C provides granular control + balanced enforcement + auditability, which matches enterprise requirements.
-...
Author: Vivaan · Last updated Jul 5, 2026
A company is using Amazon Bedrock to design an application to help researchers apply for grants. The application is based on an Amazon Nova Pro foundation model (FM). The application contains four required inputs and must provide responses in a consistent text format. The company wants to receive a notification in Amazon Bedrock if a response contains bullying language. However, the company does not want to block all flagged responses.
The company creates an Amazon Bedroc...
Key requirements in this question are:
1. Consistent response format → enforce structured/standardized output
2. Detect bullying language and send notification → must detect, not block responses
3. Do NOT block all flagged responses → so guardrail must be in detect mode, not block mode
---
Option A — ✅ Correct
Use Amazon Bedrock Prompt Management to define inputs and output format
Prompt Management allows you to:
Define the 4 required inputs as variables
Enforce a consistent prompt structure
Specify a standard output format (critical for consistent text responses)
Bind the prompt to the FM (Amazon Nova Pro)
Why it fits
Ensures standardization of inputs and outputs
Best suited for structured prompt design in Bedrock Flows
Helps maintain consistent response formatting across requests
When used
Use Prompt Management when you need:
Fixed input schema (variables like grant title, researcher name, etc.)
Controlled and repeatable output format
---
Option B — ❌ Incorrect
Uses hate content filter with BLOCK mode
Requirement explicitly says:
> “does not want to block all flagged responses”
Why it is wrong
BLOCK mode would prevent responses from being returned
This contradicts the requirement of allowing responses but notifying on bullying language
---
Option D — ✅ Correct
Create Amazon Bedrock Guardrail with insults filter in DETECT mode
Guardrails can:
Detect harm...
Author: Sophia · Last updated Jul 5, 2026
A 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 a...
Key problem breakdown
The system currently uses vector embeddings in Amazon OpenSearch Service for RAG-based medical search. Issues reported:
1. Missing exact medical terms and acronyms → weak lexical matching
2. Too many semantically similar but irrelevant results → pure vector search over-emphasizing semantics
3. Need better retrieval quality + low latency at scale (millions of docs)
4. Must have least operational overhead
So the core issue is: pure vector search is not enough for medical search, where exact terminology (e.g., “MI”, “COPD”, drug codes) matters as much as semantic similarity.
---
Option analysis
✅ A) Hybrid search (vector + keyword matching in OpenSearch) — BEST
Why it works:
Combines:
Vector search → semantic understanding
Keyword/BM25 search → exact match for acronyms & medical terms
Directly fixes both problems:
Missed acronyms → captured by keyword index
Irrelevant semantic matches → balanced by lexical scoring
Native in Amazon OpenSearch Service, so:
No architecture change
No external ML systems
Low operational overhead
Scales well to millions of documents
Key AWS exam signal:
👉 When you see OpenSearch + RAG + “missing exact terms”, the default fix is hybrid search
When used:
Search systems needing both semantic + exact matching
Medical, legal, financial search workloads
Large-scale RAG retrieval tuning
---
❌ B) Increase embedding dimensions + Lambda filtering
Why it’s wrong:
Increasing embedding dimensions (384 → 1536):
❌ Does NOT fix acronym/keyword mismatch
❌ Often increases latency + cost
❌ No guarantee of better retrieval relevance
Lambda post-processing:
❌ Adds extra latency (bad for RAG UX)
❌ Operational overhead increases significantly
❌ Filtering after retrieval is inefficient...
Author: NightmareDragon2025 · Last updated Jul 5, 2026
An 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 compl...
This is a dynamic model routing + feature flag/config-driven decisioning problem with strict requirements:
No code redeploys when switching FMs
Real-time propagation of routing rule changes (cost, compliance, A/B tests)
Complex decision logic (user tier, transaction value, region, cost thresholds)
High concurrency (thousands of requests)
Centralized, versioned, fast-changing configuration
The key AWS service designed specifically for this pattern is AWS AppConfig, which supports:
Real-time configuration updates with controlled deployments
Feature flags and dynamic rule evaluation
Low-latency client-side caching (via agent)
Safe rollout strategies (ideal for A/B testing and cost-based routing)
Separation of configuration from application code
---
Option Analysis
❌ A) Lambda environment variables + API Gateway reads
Environment variables are static at runtime unless redeployed or manually updated
Changes do not propagate instantly across thousands of concurrent executions
No native support for A/B testing, versioning, or structured rule evaluation
Not suitable for frequently changing cost thresholds or compliance rules
👉 Works only for simple, infrequently changing configuration, not dynamic enterprise routing.
---
❌ B) API Gateway templates + stage variables
Stage variables are not designed for real-time decisioning
Limited logic in API Gateway mapping templates (not suitable for complex rule engines)
Hard to manage multi-dimensional routing (cost + compliance + user tier + A/B testing)
Updates are not instantly consistent across distributed traffic
...
Author: Sofia2021 · Last updated Jul 5, 2026
A 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 ...
The correct answer is C.
Amazon SageMaker Clarify is AWS’s purpose-built service for detecting bias and explaining model predictions. It is specifically designed to compute fairness and bias metrics across demographic groups, which directly matches the requirement to evaluate fairness between two prompt approaches used in Amazon Bedrock.
---
Why C is correct
SageMaker Clarify fairness metrics: It can analyze model outputs across demographic attributes (e.g., age, gender, region) and compute bias metrics such as class imbalance and disparate impact.
Native bias evaluation capability: No need to build custom statistical logic or post-processing pipelines.
CloudWatch integration: Metrics can be published to Amazon CloudWatch for:
Real-time monitoring
Alerting via CloudWatch Alarms (e.g., >15% discrepancy threshold)
Composite monitoring: Can combine fairness metrics with operational metrics (like latency or throughput) for full observability.
Weekly reporting: CloudWatch dashboards and scheduled reports (via Amazon QuickSight or export from CloudWatch) can compare performance between prompt variants.
Why it fits best: It minimizes custom development while still providing true fairness/bias evaluation, which Bedrock-native tools alone do not fully provide.
---
Why other options are incorrect
A) CloudWatch + EventBridge + Lambda custom pipeline
Requires heavy custom development:
Manual extraction of model outputs
Custom fairness calculations in Lambda
Custom metric publishing logic
❌ Not least eff...
Author: VioletCheetah55 · Last updated Jul 5, 2026
A medical device company wants to feed reports of medical procedures that used the company's devices into an AI assistant. To protect patient privacy, the AI assistant must expose patient personally identifiable information (PII) only to surgeons. The AI assistant must redact PII for engineers. The AI assistant must reference only medical reports that are less than 3 years old.
The company stores reports in an Amazon S3 bucket as soon as each ...
The requirements have three core constraints:
1. Role-based PII handling
Surgeons must see full PII.
Engineers must see redacted PII.
→ This implies dynamic, per-user response control, not static data redaction at ingestion.
2. Data freshness constraint
Only medical reports younger than 3 years must be referenced.
→ Best enforced at storage level (S3 lifecycle) and/or ingestion sync filtering.
3. Existing architecture
Data already in S3.
Amazon Bedrock knowledge base already configured.
Users authenticate via Amazon Cognito.
→ We should prefer Bedrock-native controls rather than duplicating datasets.
---
Why Option C is correct
C fits all requirements cleanly using AWS-native patterns:
S3 Lifecycle configuration removes reports older than 3 years
→ Ensures the knowledge base never ingests stale medical reports.
Scheduled Lambda sync to the knowledge base
→ Keeps the Bedrock knowledge base updated with only valid S3 data.
Bedrock Guardrails (ApplyGuardrail tied to Cognito group)
→ This is the key mechanism:
Surgeons: full, unredacted responses
Engineers: responses filtered/redacted for PII
Key reasoning point
Instead of modifying stored data, C enforces policy at inference time, which is the correct approach for role-based PII visibility.
This avoids:
duplicating data
irreversible redaction
loss of surgeon-required clinical details
---
Why the other options are incorrect
❌ A) Macie + Lambda redaction + delete outdated docs
Amazon M...
Author: IceDragon2023 · Last updated Jul 5, 2026
A company runs a Retrieval Augmented Generation (RAG) application that uses Amazon Bedrock Knowledge Bases to perform regulatory compliance queries. The application uses the RetrieveAndGenerateStream API. The application retrieves relevant documents from a knowledge base that contains more than 50,000 regulatory documents, legal precedents, and policy updates.
The RAG application is producing suboptimal responses because the initial retrieval often returns semantically similar but contextually irrelevant documents. The poor responses are causing mode...
The key problem is poor retrieval quality from Amazon Bedrock Knowledge Bases, where semantically similar but contextually irrelevant documents are being returned. The goal is to improve relevance ranking with minimal operational overhead.
✅ Correct approach: Use built-in reranking in Amazon Bedrock Knowledge Bases (Option D)
Option D leverages the native reranking capability inside Amazon Bedrock Knowledge Bases, using the latest Amazon reranker model to reorder retrieved documents based on contextual relevance.
This directly improves:
Semantic + contextual relevance scoring
Ranking of retrieved chunks before generation
Quality of input context → reduces hallucinations
Most importantly, it is fully managed, meaning:
No custom infrastructure
No external APIs or pipelines
No model hosting or maintenance
This makes it the lowest operational overhead solution.
---
❌ Why other options are incorrect
A) SageMaker fine-tuned ranking model + API Gateway
This approach introduces a custom ML inference pipeline:
Requires training and hosting a ranking model in Amazon SageMaker
Requires API Gateway setup and routing logic
Requires ongoing monitoring, scaling, and model updates
📌 Use case:
When you need highly customized ranking logic
When Bedrock-native reranking is insufficient
❌ Why rejected:
High operational overhead
Unnecessary complexity for a managed Bedrock-native feature
---
B) Comprehend + Textract + Neptune graph scoring
This...
Author: NebulaEagle11 · Last updated Jul 5, 2026
A financial services company wants to use Amazon Bedrock foundation models (FMs) to analyze call center recordings. When calls end, the call center stores recordings as MP3 files in an Amazon S3 bucket. The company needs to generate summaries and sentiment analysis for the recordings in a structured format as soon as ...
Key requirements
New MP3 files arrive in Amazon S3
Must trigger processing immediately on upload
Convert speech → text using Amazon Transcribe
Generate summary + sentiment analysis using Amazon Bedrock
Output must be structured (JSON)
Orchestration required → AWS Step Functions
---
✅ Correct options: B and D
---
✅ Option D — S3 → Amazon EventBridge → AWS Step Functions (Correct)
Why this is correct
Amazon S3 can publish object-created events to Amazon EventBridge
EventBridge is the recommended modern event routing service
It can directly trigger AWS Step Functions workflows
Why this is the best fit
Fully event-driven architecture
No polling required → near real-time processing
Clean separation of storage and workflow orchestration
When to use this pattern
S3 event-driven pipelines
Serverless workflows triggered by file uploads
Decoupled event routing systems
---
✅ Option B — Step Functions + Transcribe + Direct Bedrock Invocation (Correct)
Why this is correct
Workflow:
1. Step Functions starts execution
2. Invoke Amazon Transcribe to convert MP3 → text
3. Wait for job completion
4. Directly call Amazon Web Services Bedrock FM via service integration
5. Generate structured JSON output (summary + sentiment)
Why this is best
Step Functions supports nati...
Author: Ella · Last updated Jul 5, 2026
A financial services company is deploying a generative AI (GenAI) application that uses Amazon Bedrock to assist customer service representatives to provide personalized investment advice to customers. The company must implement a comprehensive governance solution that follows responsible AI practices and meets regulatory requirements.
The solution must detect and prevent hallucinations in recommendations. The solution must have safety controls for customer interactions. The solution must also monitor model behavior drift in real time and maintain audit trails of all prompt-response pairs for regulatory ...
We need a solution for a GenAI system on Amazon Bedrock with strict requirements:
Key requirements breakdown
1. Detect and prevent hallucinations
2. Safety controls for customer interactions
3. Real-time model behavior drift monitoring
4. Audit trail of prompt-response pairs (regulatory compliance)
5. Integrate with existing compliance dashboard
6. < 200 ms response latency
7. Low operational overhead
8. Deploy within 60 days
---
Option analysis
✅ Option C (Best fit)
> Use Amazon Bedrock Agents + Knowledge Bases, Bedrock Guardrails, OpenSearch Service, and QuickSight
Why this is correct
1. Hallucination reduction (critical requirement)
Amazon Bedrock Knowledge Bases grounds responses using enterprise data
This is the primary AWS-native hallucination mitigation approach
Strongly preferred over “evaluation after the fact”
✔ Directly reduces hallucinations at generation time (best practice)
---
2. Safety controls
Amazon Bedrock Guardrails
Toxicity filtering
PII detection
Content policy enforcement
✔ Fully managed → low operational overhead
---
3. Audit trails + compliance
Amazon OpenSearch Service
Efficient indexing of prompt-response pairs
Supports search, filtering, and audit queries
✔ Better than raw S3 for compliance querying
---
4. Drift monitoring (real-time approximation)
OpenSearch + Amazon QuickSight
Enables analytics dashboards
Detects distribution shifts in prompts/responses
✔ While not “pure ML drift monitoring”, it is the closest managed low-ops solution
---
5. Integration with compliance dashboard
QuickSight integration
Native BI layer for compliance reporting
---
6. Low operational overhead
Fully managed AWS services:
Bedrock (agents, guardrails, KB)
OpenSearch managed
QuickSight dashboards
✔ Minimal custom code
---
7. Performance (<200 ms)
Bedrock + knowledge base retrieval + guardrails are optimized for low latency
OpenSearch logging is asynchronous (does not block inference)...
Author: Isabella1 · Last updated Jul 5, 2026
A company is designing an API for a generative AI (GenAI) application that uses a foundation model (FM) that is hosted on a managed model service. The API must stream responses to reduce latency, enforce token limits to manage compute resource usage, and implement retry logic to hand...
Key requirements
Streaming responses → reduce perceived latency (real-time token streaming)
Token limits enforcement → control cost/compute usage (must be server-side)
Retry logic for timeouts/partial responses → handle transient failures robustly
Least operational overhead → prefer managed services, avoid custom infra
---
✅ Correct Option: A
A) Integrate an Amazon API Gateway HTTP API with an AWS Lambda function to invoke Amazon Bedrock. Use Lambda response streaming to stream responses. Enforce token limits within the Lambda function. Implement retry logic for model timeouts by using Lambda and API Gateway timeout configurations.
Why A is correct
Streaming supported efficiently via Lambda response streaming, which works well with Amazon Bedrock for incremental token output.
HTTP API (not REST API) → lower latency and less operational overhead than REST APIs.
Token limits enforced in Lambda → centralized, server-side control before/while invoking the model.
Retry logic handled via Lambda + API Gateway timeouts → standard AWS-native pattern for transient failures.
Fully managed stack → no infrastructure to manage beyond Lambda and API Gateway.
Key advantage
This option uses serverless-native components only, which is exactly what “least operational overhead” implies.
---
❌ Why other options are incorrect
B) API Gateway → direct Bedrock + client polling
...
Author: IronLion88 · Last updated Jul 5, 2026
An insurance company uses existing Amazon SageMaker AI infrastructure to support a web-based application that allows customers to predict what their insurance premiums will be. The company stores customer data that is used to train the SageMaker AI model in an Amazon S3 bucket. The dataset is growing rapidly. The company wants a solution to continuously re-train the model. The solution must automat...
The requirement is to build an event-driven MLOps pipeline that automatically triggers retraining and redeployment of a SageMaker model whenever a new dataset is uploaded to S3. Key needs are:
Event detection on S3 upload
Orchestration of a retraining workflow
Automated model redeployment after training
Scalable, fully managed AWS-native services
---
✅ Correct Option: B
B) Create an AWS Lambda function and webhook handlers to generate an event when an employee uploads a new file. Configure SageMaker Pipelines to re-deploy the model after it is re-trained on the updated customer dataset. Use Amazon EventBridge to create an event bus. Set the Lambda function event as the source and SageMaker Pipelines as the target.
Why this is correct:
Amazon EventBridge is designed for event-driven architectures and can capture S3 upload events (directly or via Lambda integration).
AWS Lambda acts as a lightweight trigger/handler for incoming S3 events.
SageMaker Pipelines is the correct service for automated ML workflows (data prep → training → evaluation → deployment).
This enables a fully automated CI/CD-style ML pipeline (MLOps).
It supports continuous retraining + redeployment whenever new data arrives.
Key reasoning factors:
Native event-driven AWS design (S3 → EventBridge → Lambda → SageMaker Pipelines)
Proper use of SageMaker Pipelines for retraining + deployment automation
Decoupled, scalable architecture
When this pattern is used:
Continuous training systems (CT/CI for ML)
Frequent data updates trigg...
Author: Vikram · Last updated Jul 5, 2026
A company is developing a new AI-powered application that needs to integrate with various specialized tools. These tools currently run as Model Context Protocol (MCP) servers on the local machines of developers and do not maintain states between invocations. The company plans to deploy each MCP server as an AWS Lambda function to support the company's production application.
The solution must be accessible to both internal applications and au...
Key requirements in the question
We need to support:
MCP servers running as stateless AWS Lambda functions
Access from internal applications + authorized third-party partners
Strict authentication and authorization
Least operational overhead
Must remain accessible (ideally HTTP-based integration, not custom-heavy clients)
So we’re looking for:
Minimal infrastructure (avoid API Gateway if possible)
Native AWS auth (prefer IAM / SigV4 over custom auth systems unless required)
Low protocol translation effort (don’t force redesign of MCP communication model)
---
✅ Correct Option: C
C) Lambda Function URLs + Streamable HTTP transport + SigV4 IAM authentication
Why this is correct
This option best balances low overhead + strong security + direct access:
AWS Lambda Function URLs provide a built-in HTTPS endpoint without needing API Gateway.
Supports SigV4 (IAM-based authentication) → strong, native AWS security model.
Works well for both:
Internal AWS workloads (IAM roles)
External partners (via cross-account roles or IAM users in partner accounts)
No additional middleware (no API Gateway, no Cognito, no custom API layer)
Aligns naturally with stateless MCP server execution over HTTP transport
When this option is best used
Use Lambda Function URLs when:
You want direct HTTPS access to Lambda
You need simple architecture with minimal components
IAM-based auth is acceptable for all clients (internal + trusted partners)
You want to avoid API Gateway cost/latency/complexity
---
❌ Why the other options are incorrect
A) Direct Lambda Invoke API with IAM InvokeFunction permissions
Why it fails:
Not an HTTP-based integration → MCP clients would need custom invocation l...
Author: SilverBear · Last updated Jul 5, 2026
A company is developing a generative AI (GenAI)-powered customer support application that uses Amazon Bedrock foundation models (FMs). The application must maintain conversational context across multiple interactions with the same user. The application must run clarification workflows to handle ambiguous user queries. The company must store encrypted records of each user conversation to use for...
Requirements Breakdown
The solution must support:
1. Conversational context across multiple interactions
→ Needs fast session/state storage (low latency, structured access)
2. Clarification workflows for ambiguous queries
→ Requires orchestration with pause/wait/resume capability
3. Encrypted storage of conversation history for personalization
→ Durable, scalable, encrypted datastore
4. Thousands of concurrent users with fast response
→ Must be highly scalable, low-latency, serverless or fully managed
---
Option Analysis
---
❌ A) Step Functions Express + Lambda + Amazon RDS
Why it’s incorrect:
Amazon RDS is not ideal for high-scale conversational history
Requires schema design and scaling effort
Writes/reads at thousands of concurrent sessions become bottleneck
Express Step Functions are good for high throughput, but:
No built-in wait/callback orchestration for human-like clarification flows (limited compared to Standard workflows)
Session-based relational model is not optimal for flexible GenAI conversation logs
When A would be used:
Traditional transactional systems
Small-to-medium workloads needing relational consistency (e.g., orders, payments)
---
❌ B) Step Functions Standard + Callback + Amazon DynamoDB + SSE (Encryption)
Why it is correct (strong candidate):
Key strengths:
AWS Step Functions Standard
Supports Wait for Callback pattern
Perfect for multi-step clarification workflows
Durable execution for long-running conversational flows
Amazon DynamoDB
Fully managed, massively scalable NoSQL
Ideal for conversation history (key = user/session ID)
Sub-millisecond latency → supports thousands of concurrent users
Built-in server-side encryption (SSE)
Handle...
Author: RadiantPhoenixX · Last updated Jul 5, 2026
A legal research company has a Retrieval Augmented Generation (RAG) application that uses Amazon Bedrock and Amazon OpenSearch Service. The application stores 768-dimensional vector embeddings for 15 million legal documents, including statutes, court rulings, and case summaries.
The company's current chunking strategy segments text into fixed-length blocks of 500 tokens. The current chunking strategy often splits contextually linked information such as legal arguments, court opinions, or statute references across separate chunks. Researchers report that generated outputs frequently omit key context or cite outdated legal information.
Recent application logs show a 40% increase in...
The correct answer is C) Update the chunking strategy to use semantic boundaries such as complete legal arguments, clauses, or sections rather than fixed token limits. Regenerate vector embeddings to align with the new chunk structure.
---
Why Option C is correct
This problem is fundamentally about poor chunking strategy in a RAG pipeline using Amazon Bedrock and Amazon OpenSearch Service.
Key issues in the scenario:
Fixed 500-token chunks are splitting semantically connected legal content
This leads to:
Loss of context (legal arguments and citations broken apart)
Lower retrieval quality (irrelevant or incomplete context retrieved)
Outdated or incomplete answers from the LLM
System also shows:
Increased latency (p95 > 2s)
Scaling storage needs (90 GB → 360 GB)
Why semantic chunking solves it:
Uses natural boundaries (sections, clauses, rulings, arguments) instead of arbitrary token limits
Ensures each embedding represents a complete legal idea
Improves:
Retrieval relevance (better vector similarity matches)
Answer quality (less missing context)
Efficiency (fewer but richer chunks → fewer retrievals needed per query)
Why re-embedding is required:
Changing chunk structure changes the input text → old embeddings become invalid
Must regenerate embeddings in Amazon Bedrock to align with new chunks
When this approach is best:
Legal documents, contracts, statutes
Technical manuals
Research papers
Any domain where context continuity matters more than uniform chunk size
---
Why other options are wrong
❌ A) Inc...
Author: Nia · Last updated Jul 5, 2026
A company is building a generative AI (GenAI) application that uses Amazon Bedrock APIs to process complex customer inquiries. During peak usage periods, the application experiences intermittent API timeouts that cause issues such as broken response chunks and delayed data delivery. The application struggles to ensure that prompts remain within token limits when handling complex customer inquiries of varying lengths. Users have reported truncated inputs and incomplete responses. The company has also observed foundation model (FM) invocation failures.
The company needs a retry strategy that automatically handles...
The correct answer is B.
Why B is correct
Option B implements a resilient, production-grade retry and streaming strategy aligned with AWS best practices for high-throughput GenAI workloads on Amazon Bedrock.
Key requirements from the question:
Handle transient service errors without overwhelming Bedrock
Adapt to changing service availability
Support streaming responses reliably
Ensure token-aware request handling
Avoid timeouts, broken chunks, and incomplete responses
Option B satisfies all of these:
1. Exponential backoff with jitter
Prevents retry storms during peak load.
Jitter ensures distributed retry timing across clients, reducing contention on Bedrock.
2. Circuit breaker pattern
Stops repeated calls when error rates exceed a threshold.
Prevents cascading failures and protects downstream Bedrock services.
3. Streaming-aware failure handling
Monitors chunk delivery timeouts.
Buffers successfully received chunks.
Allows resume from last received chunk, improving reliability in long responses.
4. Adaptive and resilient design
Automatically adapts to service instability.
Combines retry control + streaming recovery + buffering.
---
Why the other options are incorrect
❌ A) Fixed retry delay + restart streams
Fixed 1-second retry delay is not adaptive → can cause retry storms under heavy load.
No jitter → synchronized retries worsen congestion.
Restarting streams loses progress → inefficient and causes repeated token consumption.
Only basic token cap → does not handle dynamic token complexity or streaming failu...
Author: Harper · Last updated Jul 5, 2026
A company is developing a customer communication platform that uses an AI assistant powered by an Amazon Bedrock foundation model (FM). The AI assistant summarizes customer messages and generates initial response drafts.
The company wants to use Amazon Comprehend to implement layered content filtering. The layered content filtering must prevent sharing of offensive content, protect customer privacy, and detect potential inappropriate advice solicitation. Inappropriate advice solicitation includes requests for unethical practices, h...
Key requirements from the question
We need a solution that:
1. Uses Amazon Comprehend layered filtering
2. Prevents:
Offensive content (toxicity / abusive language)
Privacy leakage (PII protection)
Inappropriate advice solicitation (unethical/harmful/manipulative requests)
3. Ensures filters run before the FM (Amazon Bedrock model)
4. Maintains low latency → pre-processing must complete before inference
So the core architectural constraint is:
> Deterministic, sequential pre-processing pipeline (not post-processing or partially parallel uncontrolled flows).
---
Option Analysis
❌ Option A
> Parallel async calls for toxicity, prompt safety, and PII detection (no redaction)
Why it fails:
Uses parallel asynchronous processing
This risks race conditions where FM receives input before all filters complete → violates requirement that all pre-processing must finish first
No PII redaction
Detection alone is insufficient; requirement explicitly includes protecting privacy → must mitigate, not just detect
Mixing multiple independent filters in parallel increases risk of inconsistent enforcement order
When this approach could be used:
Low-risk systems where filtering is advisory (not blocking)
Post-processing moderation pipelines (not pre-FM gating)
---
❌ Option B
> Custom FM classifier first, then PII only if message passes classifier
Why it fails:
Uses a custom FM instead of Amazon Comprehend
Requirement explicitly says to use Amazon Comprehend
Applies PII detection conditionally
PII must always be enforced, not dependent on earlier pass/fail logic
This creates a security gap:
PII could be leaked before being checked if classifier behaves incorrectly
Also introduces model dependency before filtering, which is risky for compliance pipelines
When this approach could be used:
Research prototypes or fine-tuned moderation systems
Non-regulated internal tools where Comprehend is not mandated
---
❌ Option D
> Toxicity threshold tuning + parallel ...
Author: MoonlitPantherX · Last updated Jul 5, 2026
A company is building a video analysis platform on AWS. The platform will analyze a large video archive by using Amazon Rekognition and Amazon Bedrock. The platform must comply with predefined privacy standards. The platform must also use secure model I/O, control foundation mode...
Key requirements in this scenario are:
1. Secure model I/O (prevent unsafe or unauthorized prompts/responses to FMs like Amazon Bedrock)
2. Control foundation model access patterns (who can invoke which model/guardrails and under what conditions)
3. Strong auditing (who accessed what, when, across Bedrock, Rekognition, S3, and KMS)
4. Compliance with privacy standards (requires centralized, immutable audit trails and encryption governance)
---
Evaluation of Options
A) Bedrock Guardrails + trace events + CloudWatch + S3 SSE-KMS
This option is strong on model-level safety and observability:
Amazon Bedrock Guardrails help filter unsafe or unauthorized prompts/responses → directly supports secure model I/O
VPC endpoints improve network security for Bedrock calls
Bedrock trace events provide visibility into model/agent invocations
S3 SSE-KMS ensures encrypted storage of prompts/outputs
Why it is insufficient:
Auditing is mainly via application-level trace logs (CloudWatch), not enterprise-grade API auditing
Lacks AWS CloudTrail, which is the standard for “who did what and when” across AWS services (Bedrock, Rekognition, S3, KMS)
Weaker governance for cross-service compliance auditing
Best use case:
When the priority is LLM safety controls + prompt/response observability, such as debugging or monitoring FM behavior in a controlled application.
---
B) IAM ABAC + VPC endpoints + CloudTrail Lake + S3 logs + KMS logs + alarms
This option provides the most complete enterprise governance and auditability:
IAM ABAC (attribute-based access control) → fine-grained control of who can access which models/data → controls FM access patterns
VPC endpoints → private access to Bedrock
IAM condition keys enforcing GuardrailIdentifier and ModelId constraints → restricts FM usage patterns
AWS CloudTrail (including CloudTrail Lake) → authoritative audit of:
Bedrock API calls
Rekognition usage
S3 object access
KMS key usage (critical for compliance)
S3 server access logging → file-level audit of video archive access
CloudWatc...
Author: Ming88 · Last updated Jul 5, 2026
A company has a generative AI (GenAI) application that uses Amazon Bedrock to provide real-time responses to customer queries. The company has noticed intermittent failures with API calls to foundation models (FMs) during peak traffic periods.
The company needs a solution to handle transient errors and provide detailed observability into FM performance. The solution must prevent cascading failures during throttling events and provide distributed tracing acro...
The correct answer is B.
Why B is correct
This option best satisfies all three critical requirements: resilience to transient failures, prevention of cascading failures during throttling, and end-to-end observability with correlation to FM characteristics.
Standard retry mode with exponential backoff and jitter (AWS SDK)
This is essential for handling intermittent throttling and transient failures in Amazon Bedrock API calls.
Exponential backoff reduces retry pressure during peak load.
Jitter randomizes retry intervals, preventing synchronized retry storms (cascading failures).
This is the AWS-recommended approach for throttling scenarios.
AWS X-Ray distributed tracing with annotations
X-Ray provides end-to-end tracing across service boundaries, which is explicitly required.
Helps identify where latency is introduced (client, network, Bedrock, downstream services).
Annotations allow filtering and grouping traces (e.g., by FM model ID, prompt type, region, latency bucket), enabling correlation of performance issues with specific FM characteristics.
Why other options are incorrect
A) Fixed delay retry + CloudWatch alarms
Fixed 1-second retry is not adaptive and increases risk of retry storms under peak load.
Lacks jitter → can worsen throttling.
CloudWatch alarms provide only reactive monitoring, not distributed tracing.
No...
Author: FlamePhoenix2025 · Last updated Jul 5, 2026
A company is designing a solution that uses foundation models (FMs) to support multiple AI workloads. Some FMs must be invoked on demand and in real time. Other FMs require consistent high-throughput access for batch processing.
The solution must support hybrid deployment patterns and run workloads across cloud infrastructure and on-premise...
We need to satisfy four key requirements:
1. Real-time, on-demand inference for some FMs (low latency)
2. High-throughput, consistent performance for batch workloads
3. Hybrid deployment (cloud + on-premises/edge)
4. Support multiple foundation models
Now evaluate each option.
---
A) Lambda + SageMaker asynchronous endpoints
Why it fails: Amazon SageMaker asynchronous endpoints are designed for high-latency, queued inference (batch-like workloads), not real-time low-latency responses.
AWS Lambda also introduces orchestration overhead and is not ideal for strict low-latency inference paths.
Mismatch: Real-time requirement is not met.
❌ Rejected
---
B) Provisioned throughput in Amazon Bedrock
Why it works: Amazon Bedrock Provisioned Throughput guarantees:
Stable performance
Predictable latency
High-volume, consistent throughput for production workloads
This directly supports batch/high-throughput FM workloads where consistency matters.
✔ Correct for high-throughput workloads
---
C) SageMaker endpoints + SageMaker Neo + Lambda for orchestration
Why it works:
SageMaker real-time endpoints support low-latency inference
SageMaker Neo enables model optimization for edge deployment...
Author: Zain · Last updated Jul 5, 2026
Example Corp provides a personalized video generation service that millions of enterprise customers use. Customers generate marketing videos by submitting prompts to the company's proprietary generative AI (GenAI) model. To improve output relevance and personalization, Example Corp wants to enhance the prompts by using customer-specific context such as product preferences, customer attributes, and business history.
The customers have strict data governance requirements. The customers must retain full ownership and control over their own data. The customers do not require real-time access. However, semantic accuracy must be high and retrieval latency must rem...
Requirements breakdown (key factors)
We need a solution that:
Preserves strict customer data governance (customers retain ownership/control)
Provides high semantic accuracy (good retrieval for personalization)
Maintains low retrieval latency
Does NOT require real-time access
Minimizes architectural complexity
Avoids deploying/managing infrastructure in each customer environment unless necessary
---
✅ Correct Answer: A
Why Option A is correct
A) Amazon Q Business index per customer with secure data access
This option best fits all constraints:
Strong governance model: Each customer keeps their data in their own controlled Amazon Q Business index, preserving ownership and isolation.
No real-time dependency: Q Business is designed for indexed retrieval, not streaming access.
High semantic accuracy: Uses managed semantic search over enterprise data, ideal for prompt enrichment.
Low latency retrieval: Pre-indexed content enables fast query-time augmentation.
Lower integration complexity: Example Corp interacts via a secure API, avoiding deep infrastructure management.
No need to deploy runtime services per customer beyond the managed indexing setup.
When Option A is used
Use this pattern when:
You need enterprise semantic search over customer-owned data
You want SaaS-style managed retrieval
You want cross-account or delegated access via APIs
You want RAG-like enrichment without building full retrieval infrastructure
---
❌ Why the other options are incorrect
B) Federated MCP with real-time servers per customer...
Author: Elijah · Last updated Jul 5, 2026
A company uses an AI assistant application to summarize the company's website content and provide information to customers. The company plans to use Amazon Bedrock to give the application access to a foundation model (FM).
The company needs to deploy the AI assistant application to a development environment and a production environment. The solution must integrate the environments with the FM. The company wants to test the effectiveness of various FMs...
Key requirement breakdown
The question has a few important constraints:
1. Two environments (dev + prod)
→ Need proper environment separation but ideally same codebase.
2. Use Amazon Bedrock FM integration
→ Must allow switching between foundation models easily.
3. Product owners must easily switch FMs for testing
→ This strongly suggests runtime flexibility or configuration-driven model selection, not hardcoding or separate deployments per model.
4. Test effectiveness of various FMs in each environment
→ Implies multiple models should be accessible without redeploying infrastructure each time.
---
Evaluate each option
❌ Option A
> One CDK app, multiple CodePipeline pipelines, each pipeline configured per FM, using `ProvisionedModel.fromProvisionedModelArn()`
Why it fails:
Uses ProvisionedModel → requires pre-provisioned throughput and is not flexible for quick FM switching
Mapping each FM to separate pipeline is operationally heavy and not scalable for product owners
Pipelines per model = poor agility for experimentation
Overkill CI/CD complexity for simple model switching
When it would be used:
When you need stable, high-throughput inference with guaranteed capacity
Enterprise production workloads with fixed model assignment per deployment
---
❌ Option B
> Separate CDK app per environment, uses `FoundationModel.fromFoundationModelId()`, separate pipelines per environment
Why it fails:
Good that it uses FoundationModel.fromFoundationModelId() (flexible model access)
BUT:
Separate CDK apps for dev/prod = duplicated infrastructure logic
Still does not solve easy FM switching within an environment
Pipelines per environment are fine, but lacks dynamic model selection strategy
When it would be used:
Strong environment isolation requirement
Different architecture per environment (rare in modern CI/CD best practice unless compliance-driven)
---
❌ Option C (MOST PROMISING)
> One CDK app, `Foun...
Author: Ravi Patel · Last updated Jul 5, 2026
A company is creating a workflow to review customer-facing communications before the company sends the communications. The company uses a pre-defined message template to generate the communications and stores the communications in an Amazon S3 bucket. The workflow needs to capture a specific portion from the template and send it to...
Correct Answer: A
Why Option A is correct
Amazon Bedrock Flows is specifically designed for low-code orchestration of generative AI workflows. This scenario matches it closely:
S3 integration at start and end: Flows supports built-in connectors (like Amazon S3) to retrieve and store data without custom infrastructure.
Structured parsing using expressions: The requirement to extract a specific portion of a template fits Flows’ expression-based transformation nodes.
Direct model invocation: The agent step in Flows is designed to send processed input directly to an Amazon Bedrock model.
End-to-end workflow management: Retrieval → transformation → inference → storage is exactly the kind of linear pipeline Flows is optimized for.
Key reasoning factor: This is a deterministic, repeatable document-processing pipeline, not a conversational or decision-heavy agent problem.
---
Why other options are incorrect
B) AWS Step Functions Express workflow
✔ Can technically achieve the requirement using S3 GetObject, Pass state parsing, InvokeModel, and PutObject.
❌ However, it requires more manual orchestration and custom integration logic.
❌ Parsing logic in Pass states is limited and becomes harder for complex template extraction.
❌ Less optimized for LLM-native workfl...
Author: Isabella · Last updated Jul 5, 2026
An enterprise application uses an Amazon Bedrock foundation model (FM) to process and analyze 50 to 200 pages of technical documents. Users are experiencing inconsistent responses and receiving truncated outputs when processin...
The core issue is that long technical documents (50–200 pages) exceed the foundation model’s context window, causing truncation and inconsistent outputs. The correct solution must therefore avoid forcing large prompts into the model and instead use a retrieval-based or hierarchical chunking strategy that selects only relevant portions of the document at inference time.
---
Option B — Correct Answer
B) Use hierarchical chunking with parent chunks of 8,000 tokens and child chunks of 2,000 tokens. Use Amazon Bedrock Knowledge Bases built-in retrieval to automatically select relevant parent chunks based on query context. Configure overlap tokens to maintain semantic continuity.
Why this is correct
This is the most robust enterprise-grade pattern for handling large documents in Amazon Bedrock Knowledge Bases:
Hierarchical chunking (parent-child structure) ensures:
Small chunks (2,000 tokens) capture fine-grained semantics
Larger parent chunks (8,000 tokens) preserve broader context
Retrieval-based selection ensures only relevant chunks are sent to the model
Prevents context window overflow entirely (no truncation risk)
Maintains semantic continuity via overlap tokens
Key reasoning factors
Eliminates need to fit full documents into context window
Improves retrieval precision and reduces hallucination
Scales well for 50–200 page documents
Native integration with Amazon Web Services Bedrock Knowledge Bases
When this is used
Enterprise RAG systems with large PDFs, manuals, or technical documentation
Multi-document question answering
Systems requiring high accuracy and grounded responses
---
Why other options are incorrect
A) Fixed-size chunking + sequential linking
Assume...
Author: William · Last updated Jul 5, 2026
A media company is launching a platform that allows thousands of users every hour to upload images and text content. The platform uses Amazon Bedrock to process the uploaded content to generate creative compositions.
The company needs a solution to ensure that the platform does not process or produce inappropriate content. The platform must not expose personally identifiable information (PII) in the compositions....
The requirements emphasize three things: (1) automated content safety (text + image), (2) PII detection, and (3) minimal operational overhead while integrating smoothly with an Amazon S3-based ingestion workflow and Amazon Bedrock processing.
Key evaluation factors
Level of managed services vs custom infrastructure
Ability to enforce blocking (not just monitoring)
Native integration with Bedrock and content safety controls
Ease of S3-based event/workflow integration
Correct use of AWS services for moderation and PII detection
---
Option A
Uses CloudWatch alarms, “Enhanced Monitoring,” Amazon Comprehend PII detection, Step Functions, and Amazon Rekognition.
Why it is not suitable:
CloudWatch alarms are reactive monitoring tools, not enforcement mechanisms. They cannot reliably block inappropriate content processing.
“Enhanced Monitoring tool” is not a relevant or sufficient control for content moderation.
The design mixes multiple services without a clear enforcement pipeline before Bedrock processing.
Overall, it relies on monitoring instead of prevention, which violates the requirement to prevent processing inappropriate content.
When it would be used:
CloudWatch + Comprehend is useful for auditing and alerting on PII detection trends, not for real-time content gating.
---
Option B
Uses API Gateway request validation templates + Amazon SageMaker custom models + S3.
Why it is not suitable:
API Gateway validation templates can only do basic schema/format validation, not semantic content moderation.
Building SageMaker custom models introduces high operational overhead, training, deployment, scaling, and maintenance.
Over-engineered for a requirement that already has managed AWS services (like Rekognition and Bedrock Guardrails).
Weak integration for image moderation and PII detection compared to native services.
...
Author: Sophia · Last updated Jul 5, 2026
A financial services company is developing a real-time generative AI (GenAI) assistant to support human call center agents. The GenAI assistant must transcribe live customer speech, analyze context, and provide incremental suggestions to call center agents while a customer is still speaking. To preserve responsiveness, the GenAI assistant must maintain end-to-end latency under 1 second from speech to initial response display. The architec...
The correct answer is B.
Why B is correct
This option best satisfies all key requirements:
Real-time transcription (<1 second latency):
Amazon Transcribe streaming with partial results enabled allows incremental transcription output while the customer is still speaking, minimizing delay.
Low-latency generative responses:
Amazon Bedrock using InvokeModelWithResponseStream supports token-level streaming responses, enabling near real-time suggestion generation.
Bidirectional streaming to agents:
Amazon API Gateway WebSocket API provides persistent, two-way communication so agents receive continuous updates while also potentially sending context back.
End-to-end managed services:
All components are fully managed AWS services, meeting the constraint.
Incremental suggestions during customer speech:
Streaming transcription + streaming LLM responses enables continuous updates instead of waiting for full completion.
---
Why other options are incorrect
A) Transcribe + Comprehend + InvokeModel + DynamoDB + WebSocket
❌ Amazon Comprehend adds unnecessary processing latency (sentiment analysis not required for real-time suggestions).
❌ Uses InvokeModel (non-streaming) for Bedrock → increases response delay beyond 1 second ...
Author: Lucas · Last updated Jul 5, 2026
A healthcare company is using Amazon Bedrock to build a system to help practitioners make clinical decisions. The system must provide treatment recommendations to physicians based only on approved medical documentation and must cite specific sources. The system must not hallucinate or...
We need a solution that:
Uses only approved medical documentation
Cites sources explicitly
Minimizes hallucination risk
Has least operational overhead
Fits AWS-native managed approach (exam keyword: “managed + integrated = preferred”)
---
Key AWS design principle here
For Bedrock-based RAG (Retrieval Augmented Generation), AWS’s lowest overhead, most integrated solution is:
> Amazon Bedrock Knowledge Bases + RetrieveAndGenerate API
This is specifically designed to:
Ground responses in provided documents
Automatically handle retrieval + generation
Provide built-in citations
Reduce need for custom orchestration or validation logic
---
Option Analysis
✅ B) Amazon Bedrock Knowledge Base + RetrieveAndGenerate API (Correct)
Why this is best:
Uses Amazon Bedrock Knowledge Bases, which is a fully managed RAG system
Uses RetrieveAndGenerate API, which:
Retrieves relevant documents
Passes them to the model
Generates grounded responses
Automatically includes citations
Minimizes hallucinations via:
Retrieval grounding
Source-constrained generation
Key factors:
Lowest operational overhead → fully managed service
Built-in citation support → no custom logic needed
No custom verification layer required
Designed exactly for “enterprise RAG use cases” like healthcare
When this option is used:
Document-based Q&A systems
Compliance-heavy domains (healthcare, legal, finance)
Systems requiring citations and grounded answers
---
❌ A) Bedrock + Amazon Kendra + custom post-processing
Why it’s worse:
Uses Amazon Kendra (powerful search engine, but separate integration layer)
Requires custom post-processing logic to:
Match response to sources
Add citations manually
Increases operational overhead significantly
Problems:
Custom verification logic = maintenance burden
Higher chance of mismatch between answer and citations
More moving parts than Bedrock Knowledge Bases
When ...
