Amazon Practice Questions, Discussions & Exam Topics by our Authors
A company is using Amazon Bedrock to build a customer-facing AI assistant to handle sensitive customer inquiries. The company must use defense-in-depth safety controls to block sophisticated prompt injection attacks. The company must keep audit logs of all safety interv...
✅ Correct Answer: A
Why Option A is correct
This scenario requires three key capabilities:
1. Defense-in-depth against prompt injection (including sophisticated attacks)
2. Audit logging of safety interventions (not just API calls)
3. Cross-Region failover for the AI assistant
Option A aligns best with AWS-native Bedrock security architecture:
Amazon Bedrock Guardrails are purpose-built to enforce safety policies such as content filtering and prompt safety controls.
Setting content filters to HIGH strengthens detection of harmful or manipulated inputs, which is critical for mitigating prompt injection attempts.
Using a guardrail profile with cross-Region inference enables resiliency and failover, allowing requests to be routed to another Region if one becomes unavailable.
Amazon CloudWatch Logs with custom metrics allows capturing detailed guardrail intervention events, which satisfies the requirement for auditing safety actions (e.g., blocked prompts, filtered responses).
👉 This combination provides:
Native prompt safety enforcement (Guardrails)
Operational observability (CloudWatch Logs)
Multi-Region resilience (cross-Region inference)
---
❌ Why other options are incorrect
B
Uses AWS WAF, which is designed for web-layer protection (e.g., SQL injection, XSS), not AI-specific prompt injection attacks.
AWS CloudTrail logs API calls only, not internal Bedrock guardrail interventions.
Missing explicit cross-Region failover mechanism for Bedrock inference.
👉 Best used when: ...
Author: Ava · Last updated Jul 5, 2026
A company is developing a customer support application that uses Amazon Bedrock foundation models (FMs) to provide real-time AI assistance to the company's employees. The application must display AI-generated responses character by character as the responses are generated. The application needs to support thousands of co...
This question is testing real-time streaming, scalability, and correct AWS integration patterns for Amazon Bedrock streaming responses.
Key requirements breakdown
Character-by-character / streaming output → requires token streaming, not batch response
Thousands of concurrent users → needs scalable managed connection handling
15–45 seconds response time → long-running inference, must avoid blocking or polling
Minimal latency → push-based streaming, not client polling
Amazon Bedrock streaming capability → specifically `InvokeModelWithResponseStream`
---
✅ Correct Option: A
Why A is correct
A) API Gateway WebSocket API + Lambda + InvokeModelWithResponseStream
This is the only architecture that correctly supports real-time streaming to browsers at scale.
Key strengths:
WebSocket API (API Gateway) enables persistent, bidirectional connections
Supports server push, which is required for:
character-by-character streaming
token-by-token updates from Bedrock
Lambda integration cleanly invokes `InvokeModelWithResponseStream`
Works well with thousands of concurrent connections (managed scaling by API Gateway)
Low latency: responses are forwarded immediately as chunks arrive
When to use this pattern:
Live AI chat applications
Streaming LLM responses (token-by-token)
Real-time dashboards, gaming events, notifications
---
❌ Why other options are incorrect
B) REST API + polling every 100 ms
Polling introduces huge unne...
Author: Max · Last updated Jul 5, 2026
A media company must use Amazon Bedrock to implement a robust governance process for AI-generated content. The company needs to manage hundreds of prompt templates. Multiple teams use the templates across multiple AWS Regions to generate content. The solution must provide version control with approval workflows that include notifications for pending reviews. The solution must also provide ...
The correct answer is:
Selected Option: B
---
Why Option B is correct
Option B uses native Amazon Bedrock Prompt Management, which is specifically designed for managing prompts at scale. It directly satisfies all the requirements:
1. Version control for hundreds of prompt templates
Amazon Bedrock Prompt Management provides built-in versioning of prompts.
This is critical for managing iterative prompt improvements across teams.
2. Multi-team, multi-Region usage
Bedrock prompt templates are centrally managed and can be reused across applications and teams.
IAM controls ensure consistent access across Regions.
3. Approval workflows with controlled access
IAM policies can enforce who can edit vs approve prompts.
This ensures governance without building custom workflow systems.
4. Audit trails for compliance
AWS CloudTrail automatically logs all Bedrock API activity.
This provides a detailed, immutable audit history of prompt creation, modification, and usage.
5. Consistent parameterization
Prompt templates in Bedrock support variables (parameterization).
This enforces standardization and improves output quality across teams.
---
Why the other options are incorrect
Option A – Bedrock Studio + CloudWatch + DynamoDB + Lambda
❌ No true version control system for prompts (DynamoDB status tracking is manual and err...
Author: Aarav · Last updated Jul 5, 2026
A company runs a generative AI (GenAI)-powered summarization application in an application AWS account that uses Amazon Bedrock. The application architecture includes an Amazon API Gateway REST API that forwards requests to AWS Lambda functions that are attached to private VPC subnets. The application summarizes sensitive customer records that the company stores in a governed data lake in a centralized data storage account. The company has enabled Amazon S3, Amazon Athena, and AWS Glue in the data storage account.
The company must ensure that calls that the application makes to A...
Correct Answer: A
Why Option A is correct
This option correctly satisfies both critical requirements:
---
1. Private connectivity to Amazon Bedrock
Key requirement: “calls that the application makes to Amazon Bedrock use only private connectivity”
Option A uses VPC interface endpoints for Amazon Bedrock runtime
These are powered by AWS PrivateLink
Traffic between the Lambda functions (in private subnets) and Amazon Bedrock stays entirely on the AWS private network
No internet gateway or NAT is used for Bedrock access
Lambda in private subnets ensures controlled egress
Why this is important:
Interface VPC endpoints are the only correct AWS-native way to enforce private access to Bedrock APIs
---
2. Fine-grained column-level access in the data lake
Key requirement: “fine-grained column-level access across AWS accounts”
Option A uses AWS Lake Formation LF-Tag-based access control
Enables cross-account sharing
Supports column-level and row-level permissions
Works over:
Amazon S3
AWS Glue
Amazon Athena
This is the correct modern governance approach for data lakes.
---
Why the other options are incorrect
---
❌ Option B — NAT Gateway + S3 ACLs
NAT Gateway routes traffic over the internet → NOT private connectivity to Bedrock
S3 ACLs are legacy and not fine-grained
No Lake Formation...
Author: Isabella · Last updated Jul 5, 2026
A financial services company is building a customer support application that retrieves relevant financial regulation documents from a database based on semantic similarities to user queries. The application must integrate with Amazon Bedrock to generate responses. The application must be able to search documents that are in English, Spanish, and Portuguese. The application must filter documents by metadata such as publication date, regulatory agency, and document type.
The database stores approximately 10 million document embeddings. To minimi...
Requirements breakdown (key exam signals)
We need a solution that supports:
Vector search at ~10 million embeddings scale
Low latency for real-time customer support
Multilingual semantic retrieval (English, Spanish, Portuguese) → handled via embeddings (not DB-specific, but needs strong vector engine)
Metadata filtering (date, agency, document type)
Minimal operational overhead (managed/serverless preferred)
Integration with Amazon Bedrock for RAG (Knowledge Bases preferred)
---
Option A — ✅ Amazon OpenSearch Serverless + Bedrock Knowledge Bases (BEST)
Why this is correct
Amazon OpenSearch Serverless provides:
Native vector search (k-NN / semantic search)
Built-in metadata filtering (filter clauses on fields like date, agency, type)
Serverless → minimal operational overhead (key requirement)
Scales to very large datasets (10M+ embeddings is a standard use case)
Supports low-latency retrieval
Works seamlessly with Amazon Bedrock Knowledge Bases, which is purpose-built for RAG pipelines
Why Bedrock Knowledge Bases matters here
Handles ingestion, chunking, embedding, retrieval orchestration
Reduces custom retrieval logic
Direct integration with models like Claude for generation
Why multilingual works
Embeddings are language-agnostic (e.g., Titan/Claude embeddings)
OpenSearch stores vectors regardless of language
---
Option B — Aurora PostgreSQL + pgvector ❌ (not ideal at this scale)
What it offers
Amazon Aurora PostgreSQL with pgvector:
Vector similarity search using SQL
Metadata filtering via WHERE clauses
Fully controlled relational design
Why it fails requirements
❌ Operational overhead is higher (DB tuning, indexing, scaling)
❌ 10M embeddings + low latency at scale is challengin...
Author: Alexander · Last updated Jul 5, 2026
A finance company is developing an AI assistant to help clients plan investments and manage their portfolios. The company identifies several high-risk conversation patterns such as requests for specific stock recommendations or guaranteed returns. High-risk conversation patterns could lead to regulatory violations if the company cannot implement appropriate controls.
The company must ensure that the AI assistant does not provide inappropriate financial advice, generate content about competitors, or make claims tha...
To meet the requirements, we need to address three distinct control areas in Amazon Bedrock Guardrails:
1. High-risk financial advice patterns (intent-based control)
2. Competitor mention control (keyword-based filtering)
3. Preventing ungrounded or hallucinated financial claims (grounding control)
✅ Correct Options
A) Add the high-risk conversation patterns to a denied topics guardrail
This is correct because Denied Topics in Amazon Bedrock Guardrails is designed for intent-level blocking.
It is suitable for patterns like:
Stock recommendations (“Should I buy XYZ stock?”)
Guaranteed returns (“Which investment guarantees profit?”)
It blocks or reframes responses when user intent matches restricted financial advisory topics.
👉 This directly addresses regulatory risk around prohibited financial advice.
---
D) Add the names of competitors as custom word filters. Set the input and output actions to block.
This is correct because Word Filters are meant for explicit keyword-based blocking.
Competitor names are best handled via:
Custom word lists (e.g., rival financial institutions or platforms)
Blocking both input and output ensures:
Users cannot ask about competitors
The model cannot generate competitor references
👉 This satisfies the requirement to avoid competitor-related content.
---
F) Set a high grounding score threshold
This is correct because the company must ensure responses are factually grounded in approved financial guidance....
Author: William · Last updated Jul 5, 2026
A healthcare company is developing an application to process medical queries. The application must answer complex queries with high accuracy by reducing semantic dilution. The application must refer to domain-specific terminology in medical documents to reduce ambiguity in medical terminology. The application must be able to respond to 1,0...
Key requirements breakdown
The solution must:
1. High accuracy + reduced semantic dilution → needs strong RAG (retrieval augmented generation) + query understanding (decomposition/expansion or reasoning).
2. Domain-specific medical terminology handling → requires a knowledge base (RAG over documents) with good retrieval and possibly structured query processing.
3. High throughput (1,000 queries/min ≈ ~17 QPS) with < 2 seconds latency
4. Least operational overhead → prefer fully managed AWS services, minimal custom infrastructure, minimal orchestration components.
---
Option A
API Gateway → Bedrock Agent (Claude for decomposition + Titan for expansion) + Knowledge Base
Why it works
Uses Amazon Bedrock Agent (managed orchestration layer → low ops overhead)
Uses Anthropic Claude → strong reasoning & query decomposition
Uses Amazon Titan → embedding/expansion support
Uses Bedrock Knowledge Base → RAG for medical documents
Strengths
Strong query understanding (decomposition + expansion) reduces semantic dilution
Fully managed AWS services → low operational burden
Designed for multi-step reasoning + retrieval workflows
Scales well for ~17 QPS when properly provisioned
Weakness
Slightly more moving parts than a simple KB+flow, but still managed
When used
Complex enterprise RAG systems requiring reasoning + retrieval + orchestration
---
Option B
Knowledge Base + “query decomposition enabled” + Bedrock Flow + FM
Why it is less suitable
Bedrock Knowledge Base does NOT natively perform advanced query decomposition as a core capability
“Flows + FM + KB” is more of a simple pipeline, not strong multi-step reasoning
Likely weaker at reducing semantic dilution compared to Agent-based reasoning
No explicit multi-model orchestration (no Claude/Titan separation)
Key issue
Simpler architecture → lower accuracy for complex medical queries
When used
Simple RAG chat applications where:
queries are short
no heavy reasoning or expansion need...
Author: Lina Zhang · Last updated Jul 5, 2026
A GenAI developer is evaluating Amazon Bedrock foundation models (FMs) to enhance a Europe-based company's internal business application. The company has a multi-account landing zone in AWS Control Tower. The company uses SCPs to allow its accounts to use only the eu-north-1 Region and the eu-west-1 Region. All customer data must remain in private networks within the approved AWS Regions.
The GenAI developer selects an FM based on analysis and testing and hosts the model in the eu-central-1 Region and the eu-west-3 Region. The Ge...
Key requirements in the question
The company uses Amazon Bedrock foundation models (FMs).
The selected FM is available in eu-central-1 and eu-west-3.
Users are in a multi-account AWS Control Tower landing zone.
SCPs restrict usage to eu-north-1 and eu-west-1 only (important constraint).
All data must remain private and within approved AWS Regions (Europe-only, private networking).
Employees must securely access the FM.
Requests must stay private (no public internet exposure) and remain within allowed Regions and FM Regions.
---
Correct solution: C) Cross-Region inference with Bedrock inference profiles + VPC endpoint
Why Option C is correct
This option correctly aligns with Amazon Bedrock’s native architecture for multi-Region model access:
1. Uses supported Bedrock pattern: cross-Region inference
Amazon Bedrock supports cross-Region inference using inference profiles (eu.amazon. endpoints).
This allows requests to automatically route across approved European Regions where the FM is deployed (eu-central-1, eu-west-3).
This directly satisfies:
“FM is hosted in multiple EU Regions”
“Requests remain within Europe”
2. Ensures private connectivity
Using an Amazon Bedrock VPC endpoint (AWS PrivateLink) ensures:
Traffic does not traverse the public internet
Requests stay within AWS private networking
3. Complies with SCP restrictions indirectly
Although SCP allows only eu-north-1 and eu-west-1 for general account usage, inference profiles are designed to abstract model hosting across supported Regions while still enforcing regional compliance boundaries for Bedrock-managed routing.
This is the only option that respects both:
Organizational control constraints
Bedrock-native multi-region inference
4. Proper integration model
Bedrock inference profiles are the standard enterprise mechanism for:
centralized access
secure routing
governance over multi-region FM usage
...
Author: Layla · Last updated Jul 5, 2026
A company is developing a generative AI (GenAI) application that analyzes customer service calls in real-time and generates suggested responses for human customer service agents. The application must process 500,000 concurrent calls during peak hours with less than 200 ms end-to-end latency for each suggestion. The company uses existing architecture to transcribe customer call audio s...
The requirements are very strict across four dimensions:
Extremely high concurrency: 500,000 concurrent calls
Very low latency: < 200 ms end-to-end
Cost control: must stay within a fixed monthly compute budget
Operational requirement: auto scaling without heavy infrastructure management
The key architectural idea here is: real-time inference at massive scale with predictable cost → this strongly favors Amazon Bedrock with provisioned throughput and real-time optimized models.
---
✅ Correct Option: B
B) Deploy a low-latency, real-time optimized model on Amazon Bedrock. Purchase provisioned throughput and set up automatic scaling policies.
Why this is correct:
Low-latency optimized model → designed specifically for interactive workloads like live agent assistance.
Amazon Bedrock abstracts infrastructure and provides managed scaling.
Provisioned throughput:
Guarantees capacity during peak load (critical for 500K concurrency).
Provides predictable cost control, which aligns with the fixed monthly budget requirement.
Auto scaling policies:
Allows dynamic adjustment of throughput units based on call volume spikes.
Best fit for real-time GenAI inference at scale without managing GPU infrastructure.
When to use this pattern:
Real-time chat/agent assist systems
High concurrency inference (chatbots, call centers, live recommendation systems)
Strict latency SLAs (<200–300 ms)
Cost predictability requirements
---
❌ Why other options are wrong
A) Large complex reasoning model + Bedrock + provisioned throughput + batch processing...
Author: Kai99 · Last updated Jul 5, 2026
A large ecommerce company has deployed a foundation model (FM) to generate product descriptions. The company's engineering team monitors technical metrics such as token usage, latency, and error rates by using Amazon CloudWatch. The company's marketing team tracks business metrics such as conversion rates and revenue impact in its own systems.
The company needs a unified observability solution that correlates technical performance with business outcomes. The solution must provide automati...
The requirement is to unify observability across technical (CloudWatch) and business metrics, and also correlate them to trigger automated alerts when degradation occurs. The key AWS-native capability needed here is:
Centralized monitoring (CloudWatch)
Cross-metric correlation (composite + anomaly detection)
Native alerting (SNS)
Ability to ingest business metrics into CloudWatch (custom metrics)
---
Key evaluation factors
1. Single observability plane
Prefer solutions that keep both technical and business metrics in one monitoring system.
2. Correlation capability
Must correlate multiple signals (not just visualize them separately).
CloudWatch composite alarms + anomaly detection support this.
3. Alerting mechanism
Must notify stakeholders → SNS is the standard AWS-native approach.
4. Operational simplicity
Prefer native AWS services over multi-tool pipelines unless necessary.
---
Option analysis
❌ A) CloudWatch dashboards + composite alarms combining technical and business data + SNS
CloudWatch dashboards do provide unified visualization, and custom metrics can represent business KPIs.
However, composite alarms are not designed to directly correlate raw metrics—they combine alarm states, not perform deep cross-metric correlation.
Missing anomaly detection reduces ability to detect subtle degradation patterns.
👉 When A is used:
Simple monitoring setups where teams already create individual alarms and only need logical grouping.
✔ Good for: basic unified dashboards
❌ Weak for: true metric correlation and intelligent detection
---
❌ B) Amazon Managed Grafana + Lambda remediation
Grafana is strong for multi-source visualization (CloudWatch + external systems).
However:
Alerts triggering Lambda remediation shifts focus to automation, not sta...
Author: Alexander · Last updated Jul 5, 2026
A university recently digitized a collection of archival documents, academic journals, and manuscripts. The university stores the digital files in an AWS Lake Formation data lake.
The university hires a GenAI developer to build a solution to allow users to search the digital files by using text queries. The solution must return journal abstracts that are semantically similar to a user's query. Users must be able to search the digitized collection based on text and metadata that is associated with the journal abstracts. The metadata of the digitized files does not c...
Key requirement is semantic search over <1M documents with minimal operational overhead, including support for text + metadata filtering and vector similarity.
✅ Correct Option: A
Use Amazon Titan Embeddings in Amazon Bedrock to create vector representations of the digitized files. Store embeddings in the OpenSearch Neural Plugin for Amazon OpenSearch Service.
---
Why A is correct
1. Lowest operational overhead (core requirement)
Amazon Bedrock (Titan Embeddings) is fully managed → no model hosting or scaling.
Amazon OpenSearch Service (Neural / vector search) is fully managed search infrastructure.
No need to manage database indexing, vector extensions, or compute scaling.
2. Best fit for semantic + metadata search
OpenSearch supports:
Vector similarity search (k-NN)
Hybrid search (text + vector + filters)
Fast retrieval over large document sets (<1M is well within its capability)
3. Purpose-built for search workloads
Designed specifically for:
Document retrieval
Ranking
Filtering + semantic search combined
---
Why other options are incorrect
❌ B) Amazon Comprehend + Aurora PostgreSQL
Comprehend extracts topics, not semantic similarity
Topics ≠ embeddings
Cannot capture fine-grained meaning between abstracts
Requires manual schema design + query logic
Aurora relational queries are not optimized for semantic search
➡️ Only useful for classification, entity extrac...
Author: Emma · Last updated Jul 5, 2026
A company is using Amazon Bedrock to develop a customer support AI assistant. The AI assistant must respond to customer questions about their accounts. The AI assistant must not expose personal information in responses. The company must comply with data residency policies by ensuring that all processing occurs within the same AWS Region where each customer is located.
The company wants to evaluate how effective the...
Key requirements from the question
1. Prevent exposure of personal information (PII) in AI responses
2. Evaluate effectiveness before production
3. Ensure data residency compliance → processing must stay within the same AWS Region as each customer
4. Solution uses Amazon Bedrock Guardrails
---
Correct Option: B
Why Option B is correct
Uses an Amazon Bedrock guardrail with sensitive information filters, which is the correct mechanism to detect and prevent PII leakage.
Deploys a copy of the guardrail in each AWS Region, which directly satisfies the data residency requirement (no cross-region processing).
Uses:
Mask mode in development/testing → helps simulate real behavior while hiding sensitive values.
Block mode in production → ensures PII is never exposed to end users, which is required.
Why this works best overall
Meets all three constraints simultaneously:
Data residency (regional deployment)
PII protection (sensitive information filters + block mode)
Pre-production evaluation (testing phase included)
---
Why other options are incorrect
❌ A) Cross-Region guardrail + detect mode → block mode
Fails data residency requirement
Cross-region processing is explicitly not allowed.
Detect mode is useful for evaluation, but:
The architecture is invalid for compliance, making it unusable in this scenario.
👉 When this option would be used:
When the...
Author: Zara · Last updated Jul 5, 2026
A software as a service (SaaS) company is building a recommendation model that uses Amazon SageMaker AI to support an application that recommends airline cabin upgrades to customers. The company will host SageMaker AI models on Amazon Bedrock by using Amazon Bedrock Custom Model Import. Airline companies will use the application to send customized offers to customers.
The model must examine the travel history of customers to help make more relevant recommendations. The company stores customer travel history data...
Key requirements breakdown
We need to design an AWS solution for a SaaS airline upgrade recommendation system with:
1. Data source: Customer travel history in Amazon RDS
2. Model hosting: Amazon SageMaker models imported into Amazon Bedrock (Custom Model Import)
3. Core capability: Use travel history to generate personalized recommendations
4. Cross-airline consistency: Results must be consistent, relevant, accurate
5. Must reduce hallucinations
6. Must scale across populations and airlines
So the key architectural challenge is:
> How do we reliably retrieve structured transactional customer data in RDS and use it safely for LLM-based recommendation generation?
---
Option analysis
---
❌ Option A — Bedrock Knowledge Bases (RAG on RDS data)
What it proposes:
Use Amazon Bedrock Knowledge Bases for RAG over RDS travel history
Use semantic search to retrieve booking patterns/preferences
Add guardrails + Step Functions validation
Why it is NOT ideal
Knowledge Bases are designed for unstructured / semi-structured documents, not highly structured transactional RDS data.
RDS data like bookings, loyalty tiers, cabin history is:
relational
structured
requires precise filtering (dates, routes, fare classes)
Key issue:
RAG introduces semantic approximation, which can:
miss exact eligibility rules (e.g., loyalty tier thresholds)
introduce inconsistency across airlines
reduce determinism (bad for “accurate and consistent results” requirement)
When Option A is suitable:
Customer emails, support tickets, travel notes
Policy documents or unstructured loyalty program descriptions
---
❌ Option C — OpenSearch vector search over embeddings
What it proposes:
Convert travel history into embeddings
Store in Amazon OpenSearch Service
Use similarity search for recommendations
Why it is NOT ideal
Same issue as A: semantic similarity ≠ deterministic accuracy
Airline upgrades often depend on:
loyalty tier rules
exact flight history
booking class history
Vector similarity can:
overgeneralize customer behavior
mix unrelated passengers with similar embeddings
Key issue:
OpenSearch vector search is great for:
“similar customers”
content recommendation
fuzzy matching
But NOT ideal for:
precise eligibility-based business logic
When Option C is suitable:
“Customers similar to you also bought…”
content/media recommendation engines
fuzzy behavioral clustering
---
❌ Option D — Text-to-SQL + confidence scoring
What it propo...
Author: Abigail · Last updated Jul 5, 2026
A company uses AWS Lake Formation to set up a data lake that contains databases and tables for multiple business units across multiple AWS Regions. The company wants to use a foundation model (FM) through Amazon Bedrock to perform fraud detection. The FM must ingest sensitive financial data from the data lake. The data includes some customer personally identifiable information (PM).
The company must design an access control solution that prevents PI I from appearing in a production envi...
The correct solution is Option B.
Why Option B is correct
Option B uses AWS Lake Formation LF-Tags (Lake Formation Tag-Based Access Control) combined with IAM roles and AWS CloudTrail, which directly aligns with all requirements:
Fine-grained access control (required)
LF-Tags allow you to define policies like business unit = Finance, region = APAC and apply them to databases/tables/columns.
This enables attribute-based access control (ABAC) across multiple Regions and business units.
PII protection / redaction requirement
Lake Formation supports column-level permissions, so sensitive PII columns can be excluded from access policies.
This ensures the FM only receives approved, non-PII subsets of data.
Cross-region, multi-business-unit scalability
LF-Tags scale better than managing individual S3 buckets or IAM policies per dataset.
Audit requirement
CloudTrail integrates with Lake Formation to provide comprehensive audit logs of data access, including who accessed which table/column and when.
Bedrock FM integration
The FM (via IAM role) can access governed data through Lake Formation permissions without directly bypassing controls.
---
Why the other options are incorrect
❌ Option A (S3 buckets per BU/region)
Uses separate S3 buckets + bucket policies, which is:
Operationally heavy and not scalable
Not true Lake Formation governance
No built-in column-level PII redaction
Relies on S3 access logs...
Author: MoonlitPantherX · Last updated Jul 5, 2026
A specialty coffee company has a mobile app that generates personalized coffee roast profiles by using Amazon Bedrock with a three-stage prompt chain. The prompt chain converts user inputs into structured metadata, retrieves relevant logs for coffee roasts, and generates a personalized roast recommendation for each customer.
Users in multiple AWS Regions report inconsistent roast recommendations for identical inputs, slow inference during the retrieval step, and unsafe recommendations such as brewing at excessively high temperatures. The company must improve the stability of outputs for repeated inputs. The company must also improve app performance and the safety of the app...
Key requirements in the question
We need a solution that achieves all of the following simultaneously:
1. 99.5% output consistency for identical inputs (deterministic/stable outputs)
2. < 1 second inference latency (especially during retrieval step)
3. Improved safety controls (block unsafe or hallucinated coffee recommendations)
4. Works across multiple AWS Regions
5. Fix issues in a three-stage prompt chain (metadata → retrieval → generation)
So we evaluate each option against consistency, latency, safety, and control over prompt behavior.
---
✅ Correct Answer: A
Why A is correct
1. Consistency (99.5% identical outputs)
Amazon Bedrock Provisioned Throughput
Provides dedicated capacity
Reduces variability from shared model infrastructure
Improves predictable latency + stable inference behavior
2. Safety (blocking unsafe outputs)
Amazon Bedrock Guardrails (semantic denial rules)
Specifically designed to:
Block unsafe content (e.g., dangerous brewing instructions)
Prevent hallucinated or disallowed outputs
This directly addresses “unsafe recommendations such as excessively high temperatures”
3. Prompt stability and governance
Amazon Bedrock Prompt Management
Enables:
Versioning prompts
Approval workflows
Controlled rollout of prompt changes
This is critical for:
Multi-region consistency
Preventing drift between prompt versions (a likely cause of inconsistent outputs)
Why this matches the scenario best
The problem is not just retrieval or caching
It is:
prompt inconsistency
inference variability
lack of safety enforcement
👉 Option A directly addresses all three root causes:
Stability → provisioned throughput + prompt version control
Safety → guardrails
Governance → prompt management workflows
---
❌ Why other options are wrong
---
❌ B) Bedrock Agents + CloudWatch Logs + A/B testing
Why it fails:
Agents do NOT guarantee consistency
They introduce additional orchestration variability
Not deterministic enough for 99.5% identical outputs
CloudWatch logs:
Observability tool only
Cannot fix latency or consistency
A/B testing:
Useful for experimentation
NOT ...
Author: Matthew · Last updated Jul 5, 2026
A company uses an organization in AWS Organizations with all features enabled to manage multiple AWS accounts. Employees use Amazon Bedrock across multiple accounts. The company must prevent specific topics and proprietary information from being included in prompts to Amazon Bedrock models. The company must ensure that employees can use only approved A...
We need to satisfy two distinct requirements:
1. Block sensitive topics and proprietary information in prompts → requires Amazon Bedrock Guardrails with a blocking policy, deployed centrally.
2. Restrict which foundation models employees can use → requires AWS Organizations SCPs to enforce allowed model access across accounts.
---
✅ Correct Options
B) SCP restricts models + requires guardrail identifier
This option uses an AWS Organizations SCP, which is the correct control plane mechanism to:
Restrict access to only approved Amazon Bedrock models (strong, org-wide enforcement).
Enforce that requests include a guardrail identifier, ensuring guardrails are applied at invocation time.
Why it works:
SCPs are evaluated at the organization level and are non-bypassable.
Ideal for centrally enforcing model allow-lists.
Can enforce API-level conditions (like requiring a guardrail ID).
When this is used:
When you need org-wide restrictions on AI model usage and request parameters.
---
D) CloudFormation deployment of Bedrock guardrails with block filtering
This uses Amazon Bedrock Guardrails with a block filtering policy, which is exactly designed to:
Prevent sensitive topics (e.g., proprietary data leakage, unsafe content).
Enforce prompt-level safety controls before model inference.
Why it works:
Guardrails are the native Bedrock feature for content filtering and policy enforcement.
Block filtering policy actively prevent...
Author: Zain · Last updated Jul 5, 2026
A wildlife conservation agency operates zoos globally. The agency uses various sensors, trackers, and audiovisual recorders to monitor animal behavior. The agency wants to launch a generative AI (GenAI) assistant that can ingest multimodal data to study animal behavior.
The GenAI assistant must support natural language queries, a...
The correct answer is Option B.
Why Option B is the best fit
This scenario requires four key capabilities:
1. Multimodal ingestion (video, audio, sensor data)
2. Natural language Q&A over curated research data
3. Avoidance of speculative outputs (hallucination control)
4. Strong auditability for ethical research compliance
Option B aligns with all of these requirements in a clean, AWS-native architecture:
Amazon SageMaker Processing + Amazon Transcribe
These services handle multimodal preprocessing:
SageMaker Processing can transform raw sensor/video-derived metadata into structured features or summaries.
Transcribe converts animal audio recordings into searchable text.
Amazon Bedrock Retrieval Augmented Generation (RAG) Knowledge Base
This is critical because RAG ensures the model answers using grounded, retrieved research data instead of speculation, directly addressing the requirement to avoid speculative behavioral interpretation.
Amazon Bedrock Guardrails
Provides policy-based output constraints, ensuring the assistant does not generate unsafe or scientifically unsupported behavioral claims.
AWS AppConfig for prompt management
Allows controlled, versioned prompt templates—important for research reproducibility and controlled experimentation.
AWS CloudTrail for audit logs
Ensures full traceability of user queries, model interactions, and system actions, which is essential for ethical research audits.
---
Why the other options are not ideal
Option A
Uses Amazon Rekognition and streaming ingestion, ...
Author: Aarav · Last updated Jul 5, 2026
A company uses Amazon Bedrock to implement a Retrieval Augmented Generation (RAG)-based system to serve medical information to users. The company needs to compare multiple chunking strategies, evaluate the generation quality of two foundation models (FMs), and enfor...
Correct Answer: B
Why Option B is correct
This scenario requires end-to-end RAG evaluation, which means the company must assess:
1. Retrieval quality (how well chunks are retrieved)
2. Generation quality (how well the FM answers using retrieved context)
3. Comparison across multiple chunking strategies
4. Comparison of two foundation models (FMs)
5. Automated, scalable evaluation suitable for deployment decisions
Option B satisfies all of these requirements using the correct Amazon Bedrock evaluation pattern: retrieve-and-generate evaluation jobs.
Key reasons:
Retrieve-and-generate evaluation job
This is essential for RAG systems because it evaluates the full pipeline (retrieval + response generation), not just retrieval alone.
Supports chunking strategy comparison
By including each chunking strategy in the evaluation dataset, the system can directly compare how chunking impacts downstream answers.
Evaluates multiple FMs properly
The same dataset can be run across both foundation models, enabling side-by-side comparison.
LLM-as-a-judge (Claude Sonnet, 1–5 scale)
Using a supported judge model like Anthropic Claude Sonnet allows scalable, consistent scoring for qualitative metrics such as relevance, correctness, and helpfulness.
Custom metrics (e.g., precision@k)
Adds retrieval-specific rigor alongside generative quality evaluation.
This aligns with real-world Bedro...
Author: Ethan Smith · Last updated Jul 5, 2026
A company is building a serverless application that uses AWS Lambda functions to help students around the world summarize notes. The application uses Anthropic Claude through Amazon Bedrock. The company observed that most of the traffic occurs during evenings in each time zone. Users report experiencing throttling errors during peak usage times in their times zones.
The company needs to resolve the throttling issues by ensuring continuous operation of the application. ...
Key requirement breakdown
We need to solve:
Throttling during peak evening usage (per time zone)
Global traffic pattern (peak shifts across regions)
Serverless architecture using AWS Lambda + Amazon Bedrock (Anthropic Claude)
Maintain performance quality
Avoid fixed hourly cost during low traffic periods
So the solution must:
Smooth/absorb burst traffic across regions
Avoid over-provisioned capacity (fixed cost inefficiency)
Use Bedrock-native scaling options
Focus on model invocation distribution rather than static provisioning
---
Option analysis
❌ A) Provisioned throughput higher than peak traffic
This is not cost-efficient because:
Provisioned throughput (for Bedrock/LLMs) is pre-allocated capacity
You pay for it even when traffic is low → violates requirement: no fixed hourly cost during low traffic periods
Also does not address time-zone shifting demand
It is essentially overprovisioning
👉 When to use:
Predictable, constant high traffic workloads
When latency must be strictly controlled and cost is secondary
❌ Rejected due to unnecessary fixed cost and poor elasticity
---
❌ B) CloudWatch metrics + failover to backup Region
Failover is reactive, not scalable load balancing
Only triggers when errors exceed threshold → users already experience throttling first
Adds complexity and does not smooth traffic
Still doesn't distribute load efficiently during normal peak windows
👉 When to use:
Disaster recovery scenarios (regional outage)
Not for performance scaling across predictable global demand
❌ Rejected because it is...
Author: Mia · Last updated Jul 5, 2026
A company is building a generative AI (GenAI) application that processes financial reports and provides summaries for analysts. The application must run two compute environments. In one environment, AWS Lambda function must use the Python SDK to analyze reports on demand. In the second environment, Amazon EKS containers must use the JavaScript SDK to batch process multiple reports on a schedule. The application must maintain conversat...
Requirements breakdown
The solution must:
Run in two environments: AWS Lambda (Python SDK, on-demand) and Amazon EKS (JavaScript SDK, batch scheduled)
Use the same foundation model (FM) across both environments
Maintain conversational context across multi-turn interactions
Ensure consistent authentication
Support both real-time and batch processing
Key design implication: we need a standardized GenAI interface (Bedrock Converse API), IAM-based auth consistency, and a stateless request pattern with explicit context passing.
---
✅ Correct option: D
Why D is correct
D states:
Use Amazon Bedrock Converse API in both environments
Use IAM roles for authentication
Pass previous messages in the messages array to maintain context
Use language-specific SDKs (Python in Lambda, JavaScript in EKS)
Why this works
Converse API standardization: Ensures both Lambda and EKS call the same interface, so FM usage is consistent.
Stateless + explicit context: Passing prior messages directly is the correct pattern for multi-turn conversational context (no external dependency required).
IAM roles: Provides consistent, secure, and scalable authentication across services (Lambda execution role + EKS IRSA).
Multi-language support: Python and JavaScript SDKs both map cleanly to Bedrock APIs without divergence.
Same FM usage: Both environments call the same underlying Bedrock model endpoint.
When D is used
Chatbots or analyst assistants needing multi-turn reasoning
Multi-service architectures (Lambda + containers)
Systems requiring consistent LLM behavior across runtimes
---
❌ Why other options are wrong
❌ A) InvokeModel + separate auth + DynamoDB context
Uses InvokeModel instead of Converse API, requiring manual prompt engineering
Separate ...
Author: Ethan Smith · Last updated Jul 5, 2026
A company is developing a generative AI (GenAI) application that uses Amazon Bedrock foundation models (FMs). The application has several custom tool integrations. The application has experienced unexpected token consumption surges despite consistent user traffic.
The company needs a solution that uses Amazon Bedrock model invocation logging to monitor InputTokenCount metrics and OutputTokenCount metrics. The solution must detect unusual patterns in tool usage and i...
The requirements focus on four key capabilities:
1. Capturing Amazon Bedrock invocation logs with token metrics (InputTokenCount, OutputTokenCount)
2. Identifying tool-specific usage patterns (to isolate which integrations cause spikes)
3. Detecting unusual or anomalous token consumption automatically
4. Dynamically adjusting to changing traffic patterns (adaptive thresholds, not static rules)
Correct Option: C
C) Use Amazon CloudWatch Logs to capture model invocation logs. Create CloudWatch metric filters to extract tool-specific invocation patterns. Apply CloudWatch anomaly detection alarms that adjust baselines for each tool's metrics.
Why Option C is correct
CloudWatch Logs integration is appropriate for ingesting Bedrock invocation logs containing token metrics.
Metric filters allow extraction of structured data such as:
InputTokenCount per tool
OutputTokenCount per tool
Tool-specific identifiers
This enables granular per-tool observability, which is explicitly required.
CloudWatch Anomaly Detection Alarms automatically learn normal behavior and adjust baselines over time.
This directly satisfies the requirement for dynamic threshold adjustment as traffic patterns change.
Supports near real-time detection, which is important for unexpected token surges.
Why other options are incorrect
A) Static CloudWatch alarms with fixed thresholds
Works for basic monitoring of token metrics.
Fails key...
Author: Charlotte · Last updated Jul 5, 2026
A company upgraded its Amazon Bedrock powered foundation model (FM) that supports a multilingual customer service assistant. After the upgrade, the assistant exhibited inconsistent behavior across languages. The assistant began generating different responses in some languages when presented with identical questions.
The company needs a solution to detect and address similar problems for future updates. The evaluation must be completed within 45 minutes for all supported languages. The evaluation must process at least 15,000 test...
Key requirement breakdown
The question describes a foundation model regression problem after an upgrade, specifically:
Inconsistent outputs across languages for identical questions (multilingual consistency issue)
Need to detect future regressions automatically
Must run 15,000+ test conversations in parallel
Must complete evaluation within 45 minutes
Must be fully automated and CI/CD integrated
Must block deployment if quality thresholds fail
So this is fundamentally about:
> Automated, scalable, multilingual model evaluation with gating in CI/CD
---
Option analysis
❌ A) Distributed traffic simulation + CloudWatch metrics
Focus: infrastructure performance testing, not model quality
CloudWatch metrics (latency, throughput) help with system load, not:
multilingual response consistency
semantic correctness
hallucination detection
No mention of:
standardized test datasets
semantic evaluation
CI/CD gating logic
👉 Why rejected:
This is load testing / observability, not LLM evaluation or regression detection
👉 When it would be used:
validating scalability of Bedrock deployment
stress testing concurrency or throughput limits
---
❌ B) Multi-region deployment + Route 53 + post-deployment audits
Focus: global availability and latency optimization
Post-deployment audits are:
manual/weekly
not CI/CD integrated
No automated evaluation pipeline
No model quality thresholds or gating mechanism
👉 Why rejected:
This is deployment architecture + operational monitoring, not pre-release model validation
👉 When it would be used:
improving global latency for end users
production traffic routing optimization
---
❌ C) Pre-processing normalization + rule-based hallucination checks
Normalization helps consistency, but:
It does not test mode...
Author: Ryan · Last updated Jul 5, 2026
A bank is building a generative AI (GenAI) application that uses Amazon Bedrock to assess loan applications by using scanned financial documents. The application must extract structured data from the documents. The application must redact personally identifiable information (PII) before inference. The application must use foundation models (FMs) to generate approvals. The application must route low-confidence document extraction results to human reviewers who are within the same AWS Region as the loan applicant.
The company must ensure that the application complies with ...
The solution must satisfy five core requirements:
1. Structured extraction from scanned documents
2. PII redaction before model inference
3. Use of Bedrock FMs for loan decisions
4. Human review for low-confidence extractions in the same Region
5. Strict data residency + auditability + high scalability (25K/day, 99.9% availability)
---
✅ Selected options: A, B, E
---
✅ A) Amazon Textract + Amazon A2I (Correct)
Why it is selected:
Amazon Textract is purpose-built for extracting structured data from scanned financial documents (forms, tables, key-value pairs).
Amazon Augmented AI (Amazon A2I) enables human review workflows for low-confidence extractions.
A2I supports Region-specific workforce routing, ensuring reviewers are within the same AWS Region as the applicant (meets residency requirement).
Scales automatically and integrates well with serverless architectures.
When this is used:
OCR + structured extraction from PDFs/images
Human review of uncertain ML predictions
Why others are wrong:
Not applicable
---
✅ B) Lambda + Bedrock Guardrails + IAM (Correct)
Why it is selected:
AWS Lambda performs PII detection and redaction before inference, ensuring sensitive data never reaches the FM.
Amazon Bedrock Guardrails enforces:
content filtering
policy constraints
safer outputs
IAM roles scoped per Region enforce data residency and access control compliance, critical for regulated banking workloads.
When this is used:
Pre-processing pipelines (PII masking, validation)
Safety enforcement for generative AI outputs
Compliance and governance controls
Why others are wrong:
Not applicable
---
❌ C) Kendra + OpenSearch (Rejected)
Amazon Kendra and OpenSearch are search/indexing tools, not document extraction engines.
They do not reliably extract structured fields from scanned financial documents.
They are unsuitable for OCR-like structured parsing.
Why wrong:
Does not meet “scanned document structured extraction” requirement
---...
Author: Ethan · Last updated Jul 5, 2026
A company is planning to deploy multiple generative AI (GenAI) applications to five independent business units that operate in multiple countries in Europe and the Americas. Each application uses Amazon Bedrock Retrieval Augmented Generation (RAG) patterns with business unit-specific knowledge bases that store terabytes of unstructured data.
The company must establish well-architected, standardized components for security controls, observab...
Correct Answer: C
Why C is the best choice
AWS Service Catalog is specifically designed for standardizing, governing, and distributing reusable infrastructure components across multiple business units.
Key reasons this option fits the requirements:
Standardization across business units: Service Catalog enables centrally defined portfolios and products that enforce consistent architecture patterns (security, observability, RAG design for Amazon Bedrock).
Versioning and governance: Products in Service Catalog are version-controlled, ensuring controlled evolution of GenAI deployment patterns.
Well-architected reuse: It aligns well with AWS Well-Architected Framework and allows enforcing consistent GenAI/RAG patterns across all applications.
Multi-account / multi-BU scalability: Ideal for organizations operating across multiple countries and business units needing controlled self-service provisioning.
Reduced drift: Prevents ad-hoc infrastructure creation by restricting deployments to approved products.
Even though the option mentions “console usage,” in real AWS usage Service Catalog supports APIs and automation as well, but its core value is governed self-service provisioning.
---
Why other options are rejected
A
Uses API Gateway, which is irrelevant to enforcing standardized infrastructure governance.
CloudF...
Author: Krishna · Last updated Jul 5, 2026
A healthcare company is developing a document management system that stores medical research papers in an Amazon S3 bucket. The company needs to build a comprehensive metadata framework that will improve search precision for a generative AI (GenAI) application that analyzes the research papers. The metadata framework must include document timestamps, author information, and research domain classifications.
The solution must maintain a consistent metadata structure ...
Key requirement breakdown
The solution must:
Store document timestamps, author info, and domain classification
Maintain a consistent metadata structure across all S3 objects
Enable GenAI/FMs to understand document context without reading full content
Support search precision and metadata-driven retrieval
This strongly points to using S3-native metadata mechanisms (system metadata, user-defined metadata, and object tags) rather than reporting, security, or access-control features.
---
✅ Correct Option: A
Why Option A is correct
A) Store document timestamps in Amazon S3 system metadata. Use S3 object tags to implement domain classification. Implement custom user-defined metadata to store author information.
This is the only option that correctly uses S3 metadata primitives for their intended purpose:
System metadata (timestamps)
S3 automatically maintains timestamps like `LastModified`
Suitable for audit and temporal context for GenAI indexing
User-defined metadata (author information)
Supports structured key-value pairs like `x-amz-meta-author`
Ideal for consistent per-object descriptive attributes
S3 object tags (domain classification)
Designed for categorization, filtering, and cost allocation
Works well for domain labels like cardiology, oncology, AI research, etc.
Easily queryable via S3 inventory / Athena / indexing pipelines
Why this works for GenAI
Metadata is attached to each object
Enables context-aware retrieval without reading full document
Supports structured ingestion pipelines for vector indexing / RAG systems
Maintains ...
Author: Elizabeth · Last updated Jul 5, 2026
A financial services company is developing a customer service AI assistant application that uses a foundation model (FM) in Amazon Bedrock. The application must provide transparent responses by documenting reasoning and by citing sources that are used for Retrieval Augmented Generation (RAG). The application must capture comprehensive audit trails for all responses to users. The application must be able to ...
We need a solution for an Amazon Bedrock-based FM application that must:
Provide RAG with source citations
Provide transparent reasoning / traceability
Maintain comprehensive audit trails
Support 10,000 concurrent users
Ensure < 2 seconds latency
Have least operational overhead
---
Key evaluation factors
1. RAG implementation approach
Managed (Amazon Bedrock Knowledge Bases) → lowest ops overhead
Custom RAG (OpenSearch, pipelines) → higher ops burden
2. Auditability / tracing
Native tracing (Bedrock Agents tracing, CloudTrail) → preferred
Custom logging pipelines → more maintenance
3. Scalability & latency
API Gateway + Lambda + CloudFront → serverless scaling, low ops
Data-heavy batch systems (Glue/Athena) → not real-time
4. Operational overhead
Managed AWS services > custom-built systems
---
Option analysis
✅ Option A (BEST FIT)
Key components:
Amazon Bedrock Agents tracing enabled
Amazon Bedrock Knowledge Bases for RAG
Structured prompts for citations and reasoning
API Gateway + Lambda for scaling
CloudFront for low latency
Multi-AZ architecture
Why it is correct:
Uses Amazon Bedrock Knowledge Bases → fully managed RAG (no OpenSearch management)
Uses built-in tracing in Bedrock Agents → native auditability and reasoning logs
Serverless scaling via API Gateway + Lambda → handles 10,000+ concurrent users
CloudFront reduces latency globally
Multi-AZ ensures high availability
Minimal custom infrastructure → lowest operational overhead
When Option A is used:
Enterprise AI assistants using Bedrock
RAG with citations required
High concurrency + low laten...
Author: StarryEagle42 · Last updated Jul 5, 2026
A bank is developing a generative AI (GenAI)-powered AI assistant that uses Amazon Bedrock to assist the bank's website users with account inquiries and financial guidance. The bank must ensure that the AI assistant does not reveal any personally identifiable information (PII) in customer interactions.
The AI assistant must not send PII in prompts to the GenAI model. The AI assistant must not respond to customer requests to provide investment advice. The bank must collect ...
The correct answer is C.
Amazon Bedrock Guardrails is the native, fully managed solution designed specifically for enforcing safety, privacy, and policy controls on generative AI applications with minimal operational overhead, which directly aligns with the “least effort” requirement.
Why Option C is correct
Key requirements:
No PII sent to the model
No PII in responses
Block investment advice
Full audit logging (including images/documents)
Least operational effort
Option C satisfies all of these using AWS-native, purpose-built features:
Sensitive information policy (Guardrails for Bedrock)
Automatically detects and filters PII before prompts reach the model and in model outputs, ensuring PII never enters or leaves the LLM context.
Topic policy (Guardrails)
Explicitly blocks or restricts topics like investment advice, removing the need for custom ML or prompt engineering.
Converse API logging + S3 delivery logging
Provides centralized audit logs of interactions, including prompts and responses.
Image and document logging to Amazon S3
Directly satisfies the requirement to capture all customer-transmitted content (images/documents) for auditing.
👉 This is a fully managed, integrated solution, meaning no custom pipelines or ML models are required.
---
Why the other options are incorrect
A) Amazon Macie + prompt engineering + CloudTrail
❌ Amazon Macie is designed for scanning PII in S3 data at rest, not real-time conversational...
Author: Carlos Garcia · Last updated Jul 5, 2026
A retail company is using Amazon Bedrock to develop a customer service AI assistant. Analysis shows that 70% of customer inquiries are simple product questions that a smaller model can effectively handle. However, 30% of inquiries are complex return policy questions that require advanced reasoning. The company wants to implement a cost-effective model selection framework to automatically route customer inquiries to appropriate models based ...
The key requirements in this question are:
Cost-effective model selection
Automatically route requests based on complexity
Maintain high customer satisfaction
Minimize response latency
LEAST implementation effort ← This is the deciding factor
Let's evaluate each option like an AWS Solutions Architect/ML Engineer exam.
---
Option A
Create a small FM classifier → Lambda routing → Small FM / Large FM
How it works
1. A small FM first determines whether the query is simple or complex.
2. Lambda receives the classification.
3. Lambda sends the request to either:
Small FM
Large FM
Advantages
Good accuracy
Flexible
Cost optimized
Why it is rejected
Although technically sound, this requires building an entire routing pipeline:
Extra classifier model
Prompt engineering for classification
Lambda functions
Routing logic
Maintenance
Monitoring
AWS exam keyword:
> When AWS provides a managed feature, prefer it over building custom logic.
This violates the least implementation effort requirement.
Key factors
✅ Cost optimized
✅ Accurate
❌ Custom architecture
❌ More operational overhead
---
Option B ✅ (Correct)
Use Amazon Bedrock Intelligent Prompt Routing
How it works
Amazon Bedrock Intelligent Prompt Routing automatically:
Analyzes incoming prompts
Determines which model is most appropriate
Routes requests automatically
No custom classifier.
No Lambda.
No routing code.
No keyword logic.
Why it matches every requirement
| Requirement | How Option B satisfies it |
| --------------------------- | --------------------------------------------- |
| Cost-effective | Uses smaller models whenever possible |
| Automatic routing | Built-in capability |
| High customer satisfaction | Complex requests go to stronger models |
| Low latency | Managed routing without extra custom pipeline |
| Least implementation effort | AWS fully managed feature |
This is exactly why Intelligent Prompt Routing exists.
AWS loves asking questions where the answer is:
> Use the managed service instead of building it yourself.
Key factors
✅ Fully managed
✅ Automatic routing
✅ Lowest operational effort
✅ Cost optimized
✅ Recommended AWS-native solution
---
Option C
Use one mid-sized model for everything
Advantages
Very easy
Single endpoint
No routing logic
Why it is rejected
The requirement specifically says:
> 70% of requests can be handled by a smaller model.
Using one medium model means:
Paying more than necessary for simple requests
No model selection
Doesn't opt...
Author: Isabella · Last updated Jul 5, 2026
A hotel company wants to enhance a legacy Java-based property management system (PMS) by adding AI capabilities. The company wants to use Amazon Bedrock Knowledge Bases to provide staff with room availability information and hotel-specific details. The solution must maintain separate access controls for each hotel that the company manages. The solution must provide ro...
The correct answer is C) Implement one Amazon Bedrock knowledge base for each hotel in a multi-account structure. Use direct data ingestion to provide real-time room availability information. Schedule regular synchronization for less critical information.
---
Why Option C is correct
This scenario has two dominant requirements:
1. Strict, separate access control per hotel
2. Near real-time room availability updates
3. Consistent performance at peak load
Option C best satisfies these because:
Strong tenant isolation (key factor)
Each hotel has its own Amazon Bedrock Knowledge Base, ideally in a multi-account architecture.
This ensures:
Hard security boundary between hotels
No risk of cross-hotel data leakage
Simplified compliance and auditing per hotel
Scalability and performance isolation
Workloads are distributed across multiple knowledge bases/accounts
Prevents noisy-neighbor problems during peak traffic
Improves predictable latency
Supports near real-time updates (practically via ingestion pipelines)
“Direct ingestion” and frequent synchronization from PMS systems enables near real-time freshness for critical data like room availability
Less critical data can be batch-synced to reduce cost
When to use this pattern:
SaaS-like multi-tenant systems (each customer/hotel isolated)
Strong regulatory or data separation requirements
High concurrency systems needing predictable performance per tenant
---
Why other options are incorrect
❌ Option A: Single knowledge base for all hotels
Major issue: no true data isolation...
Author: BlazingPhoenix22 · Last updated Jul 5, 2026
A company wants to create an annual rewards program for its customers. The rewards that customers earn vary based on different parameters such as the categories of the items ordered and the customers' purchase history.
The company needs a generative AI (GenAI) solution that uses three Amazon Bedrock agents to help customers during online catalog browsing. The agents must use knowledge bases and action groups to handle the search, recommendation, and order modules. The modules must operate sequentially. An AWS Lambda f...
The correct answer is B.
Why B is correct (best operational efficiency)
The requirement describes a multi-step, sequential workflow:
1. Search agent (uses knowledge base + action groups)
2. Recommendation agent
3. Order agent
4. Lambda function to compute estimated rewards per item
This is a classic orchestration problem where each step depends on the previous one, and the system must support:
Sequential execution
Built-in retries and error handling
Graceful degradation during failures
Low operational overhead
AWS Step Functions is the most suitable service because it is purpose-built for orchestrating distributed workflows like this with minimal custom code.
Why B is the best choice
B uses a Step Functions state machine with separate tasks for:
Each Bedrock agent invocation
The rewards calculation Lambda
Key advantages:
Native orchestration: No need to manually coordinate Lambda chaining
Built-in retry/catch mechanisms per step: Enables graceful degradation at each stage
Clear state visibility: Easier debugging and monitoring of each agent step
Loose coupling: Each agent and Lambda remains independent
Scales operationally better than custom orchestration logic
This directly matches the requirement for sequential agent execution + resilience + efficiency.
---
Why other options are incor...
Author: Elizabeth · Last updated Jul 5, 2026
A company uses Amazon Bedrock to develop an AI assistant to provide customer support. Analysis shows that 40% of customer queries use varied phrasing or wording to ask the same questions.
The company wants a solution to reduce redundant model calls. The solution must ensure that semantically equi...
The key requirement here is semantic caching: reducing redundant model calls by recognizing that differently worded queries can have the same meaning, while also maintaining low latency.
To meet this, the solution must:
Understand semantic similarity (not just exact or normalized text match)
Support fast similarity search
Store and retrieve prior Q&A pairs efficiently
Scale for high-throughput customer support workloads
---
Option A: Amazon DynamoDB Accelerator (Amazon DynamoDB Accelerator (DAX)) with LIKE filtering
This option tries to use DAX as a cache with query text as a key.
Why it fails:
DAX is strictly a key-value cache for exact DynamoDB lookups, not semantic search.
Using `LIKE` is not supported in DAX/DynamoDB at scale and is inefficient.
It only works for exact or near-exact string matches, not varied phrasing.
Cannot detect semantic equivalence like “How do I reset password?” vs “I forgot my login password”.
Use case: caching repeated identical queries for low-latency retrieval.
---
Option B: Embeddings + Amazon MemoryDB for Valkey (Amazon MemoryDB for Valkey)
This uses embeddings and stores them in a Redis-compatible system.
Why it is partially correct but not best:
Embeddings correctly enable semantic similarity.
However, MemoryDB is not primarily optimized for large-scale vector similarity search.
“RANGE query on hash sets of embeddings” is not a standard or efficient semantic search pattern.
Lacks native, purpose-built ANN (approximate nearest neighbor) indexing compared to OpenSearch.
Use case: lightweight semantic caching for smaller-scale workloads or simple similarity matching with cu...
Author: Isabella · Last updated Jul 5, 2026
A company is using Amazon Bedrock and Anthropic Claude 3 Haiku to develop an AI assistant. The AI assistant normally processes 10,000 requests each hour but experiences surges of up 30,000 requests each hour during peak usage periods. The AI assistant must respond within 2 seconds while operating across multiple AWS Regions.
The company observes that during peak usage periods, the AI assistant experiences ...
Key requirements from the question
Baseline load: 10,000 requests/hour
Peak load: 30,000 requests/hour (3× spike)
Constraint: response within 2 seconds (real-time inference)
Environment: multi-Region on Amazon Bedrock (Anthropic Claude 3 Haiku)
Problem: throughput bottlenecks → latency spikes + timeouts
So the solution must:
Handle bursty traffic scaling
Maintain low-latency synchronous inference
Avoid regional capacity saturation
Improve request distribution + throughput availability
---
Correct Answer Analysis
✅ B) Implement token batching to reduce API overhead. Use cross-Region inference profiles to automatically distribute traffic across available Regions.
Why this is correct
This option directly addresses the root cause: regional throughput bottlenecks under burst traffic.
1. Cross-Region inference profiles (KEY FIX)
Bedrock cross-Region inference profiles automatically route requests across multiple AWS Regions.
This provides:
Load distribution
Higher effective throughput capacity
Reduced chance of regional throttling
Perfect for spiky workloads (10K → 30K/hour)
2. Token batching
Reduces API overhead per request
Improves throughput efficiency at the model invocation layer
Helps mitigate bottlenecks during high concurrency
3. Meets latency requirement
Still supports real-time synchronous inference (<2 seconds) unlike async batch solutions.
---
Why other options are incorrect
---
❌ A) Provisioned throughput in a single Region + retries
Problems:
Only scales within one Region → single bottleneck remains
Does NOT solve multi-Region requirement
Provisioned throughp...
Author: Vikram · Last updated Jul 5, 2026
A financial services company is developing a generative AI (GenAI) application that serves both premium customers and standard customers. The application uses AWS Lambda functions behind an Amazon API Gateway REST API to process requests. The company needs to dynamically switch between AI models based on which customer tier each user belongs to. The company also wants to perform A/B testing for new features without redeploying code. The c...
Key requirements breakdown
The question has four strong requirements:
1. Dynamic model switching by customer tier (premium vs standard)
2. A/B testing without redeploying code
3. Validation of parameters (temperature, max tokens, etc.) before applying
4. Lowest operational overhead (important keyword)
This is a classic configuration + feature flag + validation + runtime delivery problem.
---
✅ Correct approach: AWS AppConfig
Why Option C is correct
C) Use AWS AppConfig to manage model configurations. Use feature flags for A/B testing. Define JSON schema validation rules. Use AWS AppConfig Agent.
This is the best fit because:
1. Built for dynamic configuration management
AWS AppConfig is specifically designed for runtime configuration updates without redeploying code
Lambda can fetch config dynamically or via agent
Supports gradual rollouts and environment-based configs
👉 Perfect for:
switching AI models by customer tier
updating parameters without redeploy
---
2. Native A/B testing support
AppConfig supports feature flags
Enables:
percentage-based rollouts
user-segment targeting (premium vs standard)
safe experimentation without code changes
👉 Perfect for:
A/B testing new GenAI prompts or models
---
3. Built-in validation
Supports JSON schema validators
Ensures:
temperature is within valid range (e.g., 0–1)
max tokens are within safe limits
👉 Prevents invalid model configs from being deployed
---
4. Low operational overhead
Managed service
No polling loops, no custom cache invalidation logic
No infrastructure scaling concerns
No need for external compute coordination
---
❌ Why other options are wrong
---
❌ A) Systems Manager Parameter Store + polling + EventBridge redeploy
Problems:
Polling Lambda functions = inefficient and add...
Author: Sofia · Last updated Jul 5, 2026
A GenAI developer is building a Retrieval Augmented Generation (RAG)-based customer support application that uses Amazon Bedrock foundation models (FMs). The application needs to process 50 GB of historical customer conversations that are stored in an Amazon S3 bucket as JSON files. The application must use the processed data as its retrieval corpus. The application's data processing workflow must extract relevant data from customer support documents, remove customer personally identifiable informa...
We evaluate this as a large-scale batch RAG ingestion pipeline (50 GB JSON in S3) with requirements:
Extract relevant support conversation data
Remove PII
Generate embeddings via Amazon Bedrock
Store in vector database
Finish within 4 hours
Must be cost-effective + low operational overhead
Key evaluation dimensions:
Operational overhead (managed vs cluster-based)
Scalability for 50 GB batch processing
Native AWS integration fit for PII + embeddings + vector storage
Throughput control for 4-hour SLA
Architectural complexity
---
Option A — Lambda + Comprehend + Bedrock APIs
Why it looks good
Fully serverless
Amazon Comprehend handles PII detection (managed)
AWS Lambda parallelism helps scale ingestion
Bedrock API for embeddings is correct choice
Why it is NOT best
50 GB JSON is too large for Lambda orchestration
Lambda has:
15 min max runtime limit
Risk of throttling and retry complexity
Heavy concurrency tuning required for 4-hour SLA
No built-in batch ETL coordination → high operational tuning effort
File splitting + retry + orchestration becomes complex
When it is used
Small-to-medium datasets (MBs to a few GB)
Event-driven or streaming ingestion pipelines
Lightweight preprocessing tasks
❌ Rejected due to operational overhead at scale + orchestration complexity
---
Option B — AWS Glue + SageMaker Processing + OpenSearch
Why it looks strong
AWS Glue is designed for large-scale ETL (S3-native)
Handles structured JSON parsing at scale
Distributed processing → good for 50 GB workload
SageMaker Processing with HuggingFaceProcessor:
Good for embedding generation
Flexible model control
Why it is NOT best
SageMaker Processing adds operational overhead
You manage job definitions, container images, scaling
Two separate compute systems:
Glue (ETL + PII)
SageMaker (embeddings)
More moving parts → higher orchestration complexity than needed
OpenSearch is fine, but adds tuning overhead for indexing pipelines
When it is used
Complex ML preprocessing pipelines
Custom embedding models or fine-tuning workflows
Enterprises already using SageMaker heavily
❌ Rejected due to higher operational overhead (Glue + SageMaker dual system)
---
Option C — Amazon EMR (Spark) + Comprehend + Bedrock + Aurora pgvector
...
Author: Kai · Last updated Jul 5, 2026
Company configures a landing zone in AWS Control Tower. The company handles sensitive data that must remain within the European Union. The company must use only the eu-central-1 Region. The company uses SCPs to enforce data residency policies. GenAI developers at the company are assigned IAM roles that have full permissions for Amazon Bedrock.
The company must ensure that GenAI developers can use the Amazon Nova Pro model through Amazon Bedrock only by using cross-Region inference (CRI) and only in eu-central-1. The company enables model access for the GenAI developer IAM roles in Amazon Bedrock. However, when a GenAI developer attempts to invoke the model through the Amazon Bedrock Chat/Text playground, the GenAI developer receives the following error.
User: arn:aws:sts::123456789012:assumed-role/AssumedDevRole/DevUserName
Action: bedrock:InvokeModelWithResponseStream
On resource(s): arn:aws:bedrock:eu-west-3::foundation-m...
Key idea in this question
This is a Bedrock Cross-Region Inference (CRI) + SCP governance conflict problem.
The failure is caused by this key detail in the error:
> `Context: a service control policy explicitly denies the action`
> Resource: `arn:aws:bedrock:eu-west-3::foundation-model/amazon.nova-pro-v1:0`
So even though developers have IAM permissions, the SCP is blocking the foundation model invocation in the CRI serving region.
At the same time, the company requires:
Data residency restricted to EU only
Developers must use only eu-central-1 as the access region
But inference is allowed via cross-Region inference (CRI)
So the fix must:
1. Allow CRI inference profile usage in SCP
2. Ensure the model is enabled in its serving region(s) used by CRI
---
Option analysis
❌ A) Add an AdministratorAccess policy to the GenAI developer IAM role
This does not help because the error is caused by an SCP explicit deny
SCP overrides IAM, even AdministratorAccess
Also violates least privilege and governance controls
➡️ Rejected
---
❌ D) Validate IAM roles have permissions across all EU regions for inference profile
This is only a verification step, not a fix
IAM permissions are already stated as full
Also does not address SCP explicit deny
➡️ Rejected
---
❌ E) Extend SCP to enable CRI for `eu.` inference profile
Too broad (`eu.`)
Violates requirement for precise access control
Weak governance control (over-permiss...
Author: VenomousSerpent42 · Last updated Jul 5, 2026
A company is using Amazon Bedrock to develop an AI-powered application that uses a foundation model (FM) that supports cross-Region inference and provisioned throughput. The application must serve users in Europe and North America with consistently low latency. The application must comply with data residency regulations that require European user data to remain within Europe-based AWS Regions.
During testing, the application experiences service degradation wh...
Key requirements breakdown
We need a solution that:
1. Meets data residency → EU user data must stay in Europe Regions only
2. Low latency across Europe + North America
3. Handles traffic spikes / avoids throttling
4. Minimizes operational complexity
5. Uses Amazon Bedrock cross-Region inference + provisioned throughput support
---
Option A
> Separate Bedrock deployments per Region + custom routing + CloudWatch + SNS alerts
Why it seems plausible
Ensures EU/NA separation → supports data residency
Custom routing can enforce geo-based traffic control
Why it is NOT best
Uses manual routing layer (high operational overhead)
No use of Bedrock cross-Region inference (built-in capability)
CloudWatch + SNS only provide alerting, not mitigation
Does not directly solve throttling resilience
When this fits
Organizations needing tight custom control over traffic routing and governance
Simple alerting-based monitoring setups (not auto-resilient systems)
---
Option B (Correct answer)
> Use Amazon Bedrock cross-Region inference profiles + API Gateway per geography
Why this is correct
Uses Bedrock cross-Region inference profiles → AWS-managed routing across allowed Regions
Ensures EU users stay in EU Regions (via inference profile configuration + region mapping)
Supports low latency by automatically routing to optimal Region within allowed geography
Reduces throttling impact by distributing traffic across Regions in a managed way
API Gateway separation ensures:
Europe traffic → EU endpoints only (compliance)
North America traffic → NA endpoints only
Key advantages
✅ Lowest operational complexity among options using native AWS feature
✅ Built-in regional isolation + compliance support
✅ Uses AWS-native traffic distribution instead of custom failover logic
✅ Handles spikes better via cross-Region inference capacity sharing
...
Author: Siddharth · Last updated Jul 5, 2026
A company uses AWS Lambda functions to build an AI agent solution. A GenAI developer must set up a Model Context Protocol (MCP) server that accesses user information. The GenAI developer must also configure the AI agent to use the new MCP server. The GenAI develop...
The correct answer is C.
In this scenario, the requirements are:
Host an MCP (Model Context Protocol) server using AWS Lambda
Allow an AI agent to securely access user information
Ensure only authorized users can access the MCP server
Why option C is correct
Option C uses a Lambda function behind Amazon API Gateway HTTP API, with the AI agent communicating via Streamable HTTP transport and authentication enforced using Amazon Cognito (OAuth 2.1).
Key reasons this is the correct architecture:
Correct MCP transport type (HTTP-based):
MCP servers deployed in cloud environments (like Lambda) are typically exposed via HTTP-based transports, not STDIO. Streamable HTTP is designed for remote, scalable MCP communication.
Proper Lambda integration:
API Gateway is the standard way to expose Lambda functions as HTTP endpoints. This aligns with serverless best practices.
Secure user authorization (Cognito + OAuth 2.1):
Amazon Cognito provides identity management and OAuth 2.1 authorization, ensuring only authenticated and authorized users can access the MCP server.
Scalable and production-ready:
API Gateway + Lambda + Cognito is a well-architected, secure pattern for external client access.
---
Why the other options are incorrect
A) Async Lambda invocation of MCP server
Incorrect because MCP servers are not typically invoked via direct asynchronous Lam...
Author: Maya · Last updated Jul 5, 2026
A financial services company needs to pre-process unstructured data such as customer transcripts, financial reports, and documentation. The company stores the unstructured data in Amazon S3 to support an Amazon Bedrock application.
The company must validate data quality, create auditable metadata, monitor data metrics, and customi...
The requirements are:
Process unstructured data in Amazon S3 for an Amazon Bedrock application
Perform data quality validation and monitoring
Maintain auditable metadata (catalog/lineage)
Support custom text chunking for FM optimization
Achieve least development effort (prefer managed, serverless services)
---
✅ Correct Answer: B
Why Option B is correct
Option B uses a fully managed AWS data engineering stack:
AWS Glue Crawler automatically discovers and catalogs data in S3 → provides auditable metadata in the Glue Data Catalog.
AWS Glue ETL jobs allow transformation logic including custom text chunking with minimal infrastructure management.
AWS Glue Data Quality provides built-in data quality rules, validation, and monitoring metrics, reducing custom code.
Fully serverless → minimal operational overhead and least development effort.
Works natively with data stored in Amazon S3 and supports downstream consumption by Amazon Bedrock.
👉 This combination directly satisfies all requirements with the least custom engineering.
---
❌ Why other options are incorrect
A) SageMaker Data Wrangler + Lambda + CloudWatch
Amazon SageMaker Data Wrangler is useful for interactive data preparation, not scalable production pipelines.
AWS Lambda requires custom code for chunking and orchestration, increasing development effort.
Amazon CloudWatch provides metrics/al...
Author: Sofia2021 · Last updated Jul 5, 2026
A company is building a generative AI (GenAI) application that produces content based on a variety of internal and external data sources. The company wants to ensure that the generated output is fully traceable. The application must support data source registration and enable metadata tagging to attribute content to its original sourc...
The key requirements in this scenario are:
1. Data source registration (central catalog of datasets used by GenAI)
2. Metadata tagging for lineage/attribution (traceability of generated content back to sources)
3. Audit logging of data access and usage across the pipeline (who accessed what and when)
We evaluate each option against these.
---
Option A: Lake Formation + S3 tagging + CloudTrail
Strengths:
AWS Lake Formation provides centralized data lake governance and fine-grained access control.
CloudTrail is excellent for auditing API activity.
Weaknesses:
Metadata tagging directly in Amazon S3 is not ideal for structured lineage tracking in analytics/GenAI pipelines.
Tags are object-level and not well integrated with dataset-level cataloging and lineage attribution.
When it fits best:
Strong choice for governed data lakes with strict access control requirements, especially when using Lake Formation permissions heavily.
---
Option B: Glue Data Catalog + CloudWatch Logs
Strengths:
AWS Glue Data Catalog is appropriate for dataset registration and schema management.
CloudWatch Logs captures application behavior.
Weaknesses:
CloudWatch Logs is not sufficient for audit-grade data access tracking (it is operational monitoring, not governance auditing).
Lacks a true cross-service audit trail like CloudTrail.
When it fits best:
Best for application debugging and operational monitoring, not compliance-grade traceability.
---
Option C:...
Author: Alexander · Last updated Jul 5, 2026
A healthcare company uses Amazon Bedrock to deploy an application that generates summaries of clinical documents. The application experiences inconsistent response quality with occasional factual hallucinations. Monthly costs exceed the company's projections by 40%. A GenAI developer must implement a near real-time monitoring solution to detect hallucinations, identify abnormal token consumption, an...
Key requirements from the question
We need a solution that:
1. Detects hallucinations (near real-time or automated monitoring)
2. Identifies abnormal token consumption (cost anomaly detection)
3. Provides early warnings
4. Requires minimal custom development and low operational overhead
5. Uses Amazon Bedrock-native or managed capabilities where possible
---
Option Analysis
❌ A) CloudWatch + S3 logs + Glue + Athena
What it does:
CloudWatch monitors token metrics (good)
Logs stored in S3 (fine)
Glue + Athena used to detect hallucinations
Why it is incorrect:
❌ Hallucination detection via Glue + Athena is not real-time
Athena is batch/query-based, not near real-time
Requires custom SQL logic + data pipelines
❌ High operational overhead (Glue ETL + schema management + Athena queries)
❌ No native hallucination detection mechanism (fully custom solution)
When this would be used:
Offline analytics, post-hoc evaluation, research dashboards
Cost analysis over historical usage
---
❌ B) Bedrock evaluation jobs + CloudWatch + Lambda
What it does:
Uses Bedrock evaluation jobs with LLM-as-judge (good for hallucinations)
CloudWatch tracks token usage
Lambda processes metrics and sends alerts
Why it is incorrect:
❌ Bedrock evaluation jobs are not near real-time
They are batch evaluation workflows
❌ Lambda introduces custom orchestration overhead
❌ Still partially reactive, not continuous monitoring
❌ More moving parts than necessary for a managed solution
When this would be used:
Model benchmarking before deployment
Periodic quality evaluation of prompts or models
---
❌ C) Bedrock logs + Guardrails + CloudWatch anomaly detection
What it does:
Stores Bedrock invocation logs in S3
Enables Bedrock Guardrails contextual grounding chec...
Author: Madison · Last updated Jul 5, 2026
An ecommerce company is developing a generative AI (GenAI) solution that uses Amazon Bedrock with Anthropic Claude to recommend products to customers. Customers report that some of the recommended products are not available for sale on the website or are not relevant to the customer. Customers also report that the solutions takes a long time to generate some recommendations.
The company investigates the issues and finds that most interactions between customers and the product recommendati...
Key problem breakdown
The company faces three distinct issues:
1. Hallucinated / invalid products
→ Claude is recommending items not in the catalog.
2. Irrelevant recommendations
→ responses not grounded in actual product data.
3. High latency for mostly unique requests
→ caching is ineffective because interactions are unique.
So the core requirement is:
Ground model responses in real product catalog data
Reduce hallucinations
Improve latency in a scalable GenAI pattern
---
Option analysis
---
❌ A) Increase grounding within Amazon Bedrock Guardrails. Enable Automated Reasoning checks. Set up provisioned throughput.
Why it’s incorrect:
Guardrails improve safety/compliance, not factual grounding in a product catalog.
Automated reasoning checks are for logical constraint validation, not real-time product retrieval.
Provisioned throughput improves capacity and consistency, but not hallucination or relevance issues.
Where this fits:
Use Guardrails when you need:
Toxicity filtering
PII redaction
Content policy enforcement
Not suitable for ensuring product existence or catalog accuracy.
---
❌ B) Use prompt engineering to restrict responses. Use streaming (InvokeModelWithResponseStream) to reduce perceived latency.
Why it’s incorrect:
Prompt engineering alone cannot guarantee:
factual correctness
product catalog grounding
It only nudges behavior, does not enforce retrieval from real data.
Streaming improves user experience latency perception, not actual backend latency.
Still risks hallucination (model can still invent products).
Where this fits:
Good for:
improving tone/format
UX responsiveness (streaming tokens)
Not sufficient for:
preventing invalid product recommendations
---
❌ D) Store product catalog in Amazon OpenSearch Service. Validate ...
Author: John · Last updated Jul 5, 2026
A healthcare company is using Amazon Bedrock to develop a real-time patient care AI assistant to respond to queries for separate departments that handle clinical inquiries, insurance verification, appointment scheduling, and insurance claims. The company wants to use a multi-agent architecture.
The company must ensure that the AI assistant is scalable and can onboard new features for patients. The AI assistant must be able to handl...
The correct answer is A.
Why Option A is correct
This solution aligns best with AWS Bedrock’s recommended multi-agent architecture pattern for scalable, domain-specialized AI systems.
Key factors:
1. True multi-agent separation (scalability + modularity)
A uses a supervisor agent to perform intent classification and route requests.
It delegates to specialized collaborator agents per department (clinical, insurance, scheduling, claims).
This structure allows horizontal scaling (thousands of parallel users) because each agent can scale independently.
2. Domain-specific accuracy using RAG
Each collaborator agent uses Retrieval Augmented Generation (RAG) with its own department-specific knowledge base.
This ensures highly accurate, contextual responses (e.g., clinical vs insurance queries are not mixed).
3. Secure and isolated data access
Separate knowledge bases per department + IAM filtering ensures:
Strong data isolation
Compliance (critical in healthcare)
Reduced risk of cross-domain leakage
4. Extensibility (important requirement)
New departments or features can be added by:
Creating a new knowledge base
Adding a new collaborator agent
Updating supervisor routing logic
No need to redesign the entire system.
---
Why other options are incorrect
B) Multiple supervisors per department + manual handoffs
❌ Not scalable ...
Author: Arjun · Last updated Jul 5, 2026
A financial technology company is using Amazon Bedrock to build an assessment system for the company's customer service AI assistant. The AI assistant must provide financial recommendations that are factually accurate, compliant with financial regulations, and conversationally appropriate. The company needs to combine...
The question asks for a solution that balances scalable automated evaluation + compliance enforcement + targeted human review of critical cases for a financial (likely “financial”) customer service AI assistant built on Amazon Bedrock.
Correct Answer: B
Option B is the only choice that correctly combines all required capabilities:
Automated quality evaluation at scale
Uses Bedrock Evaluations with Anthropic Claude Sonnet as a judge model
This enables LLM-based assessment of:
factual accuracy
conversational quality
appropriateness
Key benefit: scalable, consistent evaluation without full human dependency
Compliance enforcement
Uses Amazon Bedrock Guardrails
Ensures outputs follow financial regulatory and policy constraints (e.g., disallowed content, PII handling, tone rules)
This is critical for regulated financial environments
Targeted human review (human-in-the-loop)
Uses Amazon Augmented AI (A2I)
Only flagged or critical interactions are routed to humans
Ensures efficient use of expert reviewers instead of reviewing everything
Why other options are wrong
A) Fully manual expert scoring + SageMaker analysis
❌ Not scalable: all responses review...
Author: Leah Davis · Last updated Jul 5, 2026
An ecommerce company is building an internal platform to develop generative AI applications by using Amazon Bedrock foundation models (FMs). Developers need to select models based on evaluations that are aligned to ecommerce use cases. The platform must display accuracy metrics for text generation and summarization in dashboards. The company has custom ecommerce d...
The requirements are:
Use Amazon Bedrock FMs for evaluation (managed service preferred)
Use custom ecommerce datasets from S3
Measure accuracy for text generation and summarization
Build dashboards with minimal operational overhead
We evaluate each option:
---
Option A (Rejected)
Import datasets to S3 + IAM + CORS
CORS is a browser-based mechanism for cross-origin web requests. It is irrelevant for AWS services like Amazon Bedrock evaluation jobs accessing S3. Bedrock jobs do not use browser-based access patterns.
Why it fails:
Misapplies CORS (not used for service-to-service access)
Adds unnecessary/incorrect configuration
Not required for Bedrock evaluation pipelines
---
Option B (Selected for data access layer)
Import datasets to S3 + IAM + VPC endpoint
This ensures secure and private access to S3 from AWS services running inside a VPC.
Why it works:
IAM provides correct access control
VPC endpoint enables private S3 access without internet exposure
Common enterprise pattern for secure ML workloads
Key factor: Correct secure access pattern for S3 in production AI workloads
---
Option C (Selected for evaluation orchestration)
Use AWS Lambda + Amazon Bedrock evaluation jobs + S3 dataset input + CloudWatch dashboards
This is the most aligned with a managed, low-ops approach.
Why ...
Author: Zara · Last updated Jul 5, 2026
A healthcare company is using Amazon Bedrock to build a Retrieval Augmented Generation (RAG) application that helps practitioners make clinical decisions. The application must achieve high accuracy for patient information retrievals, identify halluc...
The requirements are:
High accuracy retrieval for clinical decision support (RAG correctness)
Hallucination detection in generated responses (patient safety critical)
Reduced human review cost (automation where safe, humans only for edge cases)
In healthcare RAG systems, the best approach is usually layered evaluation: automated scoring for most outputs + selective human review for high-risk or uncertain cases.
---
✅ Correct approach: Option D
D) Deploy a hybrid evaluation system that uses an automated LLM-as-a-judge evaluation to initially screen responses and targeted human reviews for edge cases. Use Amazon SageMaker Feature Store to maintain evaluation datasets. Use a built-in Amazon Bedrock evaluation to track retrieval precision and hallucination rates.
Why this is correct
LLM-as-a-judge evaluation is well-suited for detecting:
Hallucinations
Factual inconsistency
Relevance to retrieved clinical documents
Hybrid model (automation + human review) is critical in healthcare:
Automates majority of checks → reduces cost
Escalates only uncertain/high-risk outputs → ensures safety
Bedrock evaluation capabilities (e.g., retrieval quality and hallucination metrics) align directly with RAG assessment needs.
SageMaker Feature Store supports maintaining structured evaluation datasets for continuous improvement and auditability.
When this option is used
Clinical or regulated environments (healthcare, finance)
High-risk AI outputs requiring audit trails
RAG systems where factual correctness is critical
---
❌ Why other options are incorrect
A) Amazon Comprehend + CloudWatch entity confidence
Comprehend is NLP extraction (entit...
Author: Siddharth · Last updated Jul 5, 2026
An elevator service company has developed an AI assistant application by using Amazon Bedrock. The application generates elevator maintenance recommendations to support the company's elevator technicians. The company uses Amazon Kinesis Data Streams to collect the elevator sensor data.
New regulatory rules require that a human technician must review all AI-generated recommendations. The company needs to establish human over...
Key requirement breakdown
The solution must:
1. Generate AI recommendations (already done via Amazon Bedrock)
2. Introduce mandatory human-in-the-loop approval
3. Ensure workflow pauses until a technician reviews
4. Persist all review decisions for audit
5. Integrate cleanly with AWS-native orchestration
The critical design pattern here is human approval workflow with controlled execution pause and resume.
---
✅ Correct Option: B
Why Option B is correct
Option B uses AWS Step Functions with `waitForTaskToken`, which is the standard AWS pattern for human approval workflows.
Key strengths:
Step Functions + waitForTaskToken
Pauses workflow execution until human input is received
Ideal for human-in-the-loop approval systems
Maintains state reliably and durably
Lambda + SendTaskSuccess
Human technician decision is captured externally (UI, app, portal)
Lambda resumes workflow with approval/rejection decision
DynamoDB for audit
Fully managed, scalable, and commonly used for audit logs and decision tracking
Suitable for immutable review history storage
Why this is the best fit
This pattern is specifically designed for:
Regulatory approval workflows
Human review of ML/AI outputs
Long-running business processes requiring pause/resume
---
❌ Why other options are incorrect
❌ Option A — Lambd...
Author: RadiantJaguar56 · Last updated Jul 5, 2026
A company has a recommendation system. The system's applications run on Amazon EC2 instances. The applications make API calls to Amazon Bedrock foundation models (FMs) to analyze customer behavior and generate personalized product recommendations.
The system is experiencing intermittent issues. Some recommendations do not match customer preferences. The company needs an observability solution to monitor operational metrics and detect patterns of operational performance degradation ...
The requirements emphasize three key capabilities:
1. Baseline-based detection of performance degradation (not just static thresholds)
2. Near real-time alerting within 10 minutes with correlation context
3. End-to-end observability across application + Amazon Bedrock FM behavior (latency, token usage, recommendation quality)
So we evaluate each option against these.
---
Option A
Uses Amazon CloudWatch Container Insights, alarms, EMF metrics, and dashboards.
Where it fits well:
Monitoring containerized workloads (EKS/ECS)
Basic infrastructure metrics (CPU, memory, latency)
Simple threshold-based alarms
Why it is insufficient here:
Container Insights is not the best fit for general EC2 + application + FM behavior observability
Only threshold alarms → no true anomaly detection or baseline deviation modeling
Lacks structured application-level correlation (requests → model → response quality)
Does not explicitly support FM behavior drift detection
👉 Good for infrastructure monitoring, not intelligent FM performance monitoring.
---
Option B
Combines:
AWS X-Ray (tracing)
AWS CloudTrail (API auditing)
Logs Insights + Amazon QuickSight
Where it fits well:
Debugging distributed tracing issues (X-Ray)
Security/audit of API calls (CloudTrail)
Historical BI reporting (QuickSight)
Why it is insufficient:
CloudTrail is not real-time observability (delayed logs, audit-focused)
QuickSight is not designed for 10-minute operational alerting
No native anomaly detection or baseline comparison for metrics
Correlation exists (via tracing), but no automated degradation detection system
👉 Good for debugging and auditing, not proactive anomaly detection.
---
Option C (Correct)
Uses:
Amazon CloudWatch Application Insights
EMF custom metrics (tok...
Author: Emily · Last updated Jul 5, 2026
A medical company uses Amazon Bedrock to power a clinical documentation summarization system. The system produces inconsistent summaries when handling complex clinical documents. The system performed well on simple clinical documents.
The company needs a solution that diagnoses inconsistencies, compares prompt per...
The requirements are essentially about prompt engineering governance at scale:
1. detecting and diagnosing inconsistencies in outputs,
2. comparing prompt variants using quantifiable evaluation metrics, and
3. maintaining historical tracking of prompt versions for auditability and iteration.
The key phrase here is “maintains historical records of prompt versions” combined with “compare prompt performance against established metrics”. That strongly points toward a software-engineering style evaluation pipeline, not just console experimentation or runtime routing.
---
✅ Correct option: B
B) Implement version control for prompts in a code repository with a test suite that contains complex clinical documents and quantifiable evaluation metrics. Use an automated testing framework to compare prompt versions and document performance patterns.
Why B is correct
This option aligns with all three requirements:
Diagnosis of inconsistencies → achieved through systematic test suites using complex clinical documents (exactly the failure condition mentioned).
Performance comparison using metrics → explicit use of quantifiable evaluation metrics allows objective comparison of prompt versions.
Historical record of prompt versions → version control in a repository naturally maintains full history and auditability.
Automation → automated testing frameworks enable repeatable evaluation across prompt iterations.
When this approach is used
Use this pattern when:
You need CI/CD-style prompt engineering
You require reproducible evaluation pipelines
You must maintain audit trails of prompt evolution
You are handling regulated domains (like healthcare) where traceability matters
---
❌ Why the other options are incorrect
A) Prompt management in Amazon Bedrock + manual testing
Uses manual testing, which does not scale or provi...
Author: Madison · Last updated Jul 5, 2026
A financial services company uses multiple foundation models (FMs) through Amazon Bedrock for its generative AI (GenAI) applications. To comply with a new regulation for GenAI use with sensitive financial data, the company needs a token management solution.
The token management solution must proactively alert when applications approach model-specific token limits. The solution must al...
The key requirements in this question are:
Proactive alerting before model token limits are exceeded
Accurate token usage tracking per request for cost allocation across business units
High throughput (>5,000 requests per minute)
Works across multiple Amazon Bedrock foundation models
Regulatory compliance for sensitive financial data usage monitoring
✅ Correct Option: A
A) Develop model-specific tokenizers in an AWS Lambda function... use CloudWatch metrics, alarms, and DynamoDB for tracking
Why Option A is correct
This option directly implements a custom token management layer, which is necessary because:
Amazon Bedrock does not natively expose fine-grained per-request token quota enforcement
A custom tokenizer in Lambda allows pre-request estimation of token usage per model (critical because different FMs tokenize differently)
Proactive control is achieved by estimating tokens before sending requests
Amazon CloudWatch metrics + alarms provide real-time alerting when usage approaches thresholds
Amazon DynamoDB enables durable, queryable storage for:
Cost allocation by business unit
Audit compliance
Historical usage tracking
Lambda can scale horizontally to handle 5,000+ requests/minute with proper concurrency configuration
📌 When this pattern is used:
Multi-model token tracking (Bedrock, OpenAI, etc.)
Custom governance or compliance requirements
Fine-grained cost attribution per department/app
Pre-request validation logic (tokens, safety, size limits)
---
❌ Why other options are incorrect
B) Bedrock Guardrails...
Author: CrystalWolfX · Last updated Jul 5, 2026
A company is developing a generative AI (GenAI) application by using Amazon Bedrock. The application will analyze patterns and relationships in the company's data. The application will process millions of new data points daily across AWS Regions in Europe, North America, and Asia before storing the data in Amazon S3.
The application must comply with local data protection and storage regulations. Data residency and processing must occur within the same ...
Key requirements in this question are: (1) strict data residency per continent, (2) cross-Region high-scale processing, (3) auditability of GenAI decision-making, and (4) data classification capability.
The correct solution must therefore enforce regional boundaries, prevent cross-continent data movement, provide compliance-grade immutable logs, and include a native AWS data classification service.
---
✅ Why Option C is correct
C) Use Amazon S3 Object Lock with Region-specific S3 bucket policies. Pre-process the data points within the Region based on geographic origin before sending the data points to Amazon Bedrock. Use Amazon Macie to classify the data. Use AWS CloudTrail immutable logs to audit the decision-making processes.
Key factors supporting C:
Data residency compliance (critical requirement)
Pre-processing data within the same Region ensures data does not cross continental boundaries.
Region-specific S3 bucket policies enforce locality.
Regulatory-grade immutability
Amazon S3 Object Lock ensures WORM (Write Once Read Many) storage, which is commonly required for compliance audits (financial, healthcare, government).
Data classification capability
Amazon Macie automatically discovers and classifies sensitive data (PII/PHI), directly satisfying the requirement.
Audit trails for GenAI decisions
AWS CloudTrail provides immutable logs of API activity, which is standard for auditability in regulated environments.
When C is used in real architectures:
Use this pattern when you need:
GDPR / data sovereignty compliance
Sensitive data detection and classification
Immutable audit trails for ML/AI systems
Region-locked ETL + ML pipelines
---
❌ Why other options are incorre...
