AIP-C01 AWS Certified Generative AI Developer - Professional Questions and Answers

Option B is the correct solution because it aligns with AWS guidance for building high-throughput, ultra-low-latency GenAI applications while maintaining predictable costs and automatic scaling. Amazon Bedrock provides access to foundation models that are specifically optimized for real-time inference use cases, including conversational and recommendation-style workloads that require responses within milliseconds.

Low-latency models in Amazon Bedrock are designed to handle very high request rates with minimal per-request overhead. Purchasing provisioned throughput ensures that sufficient model capacity is reserved to handle peak loads, eliminating cold starts and reducing request queuing during traffic surges. This is critical when supporting up to 500,000 concurrent calls with strict latency requirements.

Automatic scaling policies allow the application to dynamically adjust capacity based on demand, ensuring cost efficiency during off-peak hours while maintaining performance during peak usage. This directly supports the requirement to stay within a predefined monthly compute budget.

Option A fails because batch processing and complex reasoning models introduce higher latency and are not suitable for real-time suggestions. Option C introduces significantly higher operational and cost overhead due to dedicated GPU instances and manual scaling responsibilities. Option D is optimized for batch workloads and cannot meet the sub-200 ms latency requirement.

Therefore, Option B provides the best balance of performance, scalability, cost control, and operational simplicity using AWS-native GenAI services.

Option D is the correct solution because it directly evaluates multilingual output consistency and quality in an automated, scalable, and deployment-gating workflow. Amazon Bedrock model evaluation jobs are designed to run large-scale, repeatable evaluations against defined datasets and to produce quantitative metrics that can be used as objective release criteria.

The core issue is semantic inconsistency across languages for equivalent inputs. The most reliable way to detect this is to create standardized test conversations where each language version expresses the same intent and constraints. Running those tests through the updated model and comparing results with similarity metrics (for example, semantic similarity between expected and actual answers, or between language variants) surfaces regressions that infrastructure testing cannot detect.

Bedrock evaluation jobs support running evaluations at scale and are well suited for processing large datasets quickly. By parallelizing evaluation runs across languages and conversations, the company can meet the 45-minute requirement while executing at least 15,000 conversations. Because the process is standardized, it also allows consistent baseline comparisons across releases.

Applying hallucination thresholds ensures that answers remain grounded and do not introduce fabricated details, which is particularly important when language-specific behavior shifts after a model upgrade. Integrating evaluation jobs into the CI/CD pipeline enables fully automated execution on every model or configuration update. The pipeline can enforce a hard quality gate that blocks deployment if thresholds are not met, preventing regressions from reaching production.

Option A focuses on performance and infrastructure bottlenecks, not multilingual response quality. Option B is post-deployment and too slow to prevent regressions. Option C normalizes inputs but does not measure multilingual output equivalence or provide robust, quantitative gating.

Therefore, Option D best meets the automation, scale, timing, and deployment-blocking requirements.

Option B best meets the requirement for reusable, versioned, and consistently governed components across multiple business units because it implements “platform-level standardization” through infrastructure as code plus automated compliance enforcement before deployment. Standardized CloudFormation templates provide reusable building blocks for security controls (identity, networking boundaries, encryption), observability practices (metrics, logs, traces), and RAG deployment patterns (knowledge base integration, ingestion pipelines, retrieval controls). This aligns with AWS guidance to operationalize well-architected patterns through repeatable templates rather than ad hoc implementations.

A centralized repository enables version control, change review, and governance of templates across all five business units. This satisfies the “versioned” and “reusable” requirements and provides a single source of truth for approved architectures. Integrating a CI/CD pipeline ensures that deployments are consistent and automated, reducing drift between business units and Regions.

CloudFormation Guard is most effective when used as a preventive control in the pipeline, not only after deployment. By running Guard rules during build or pre-deploy stages, the organization can enforce mandatory security and observability configurations and block noncompliant changes before they reach production. This supports consistent governance while still enabling business units to deploy quickly.

Option A performs compliance validation after deployment, which allows policy violations to be deployed first and remediated later. Option C provides governed provisioning but requiring console-based deployment reduces automation and can slow standardized CI/CD adoption; it also adds an additional governance layer that is not required to meet the stated needs. Option D is not enforceable and does not provide reusable, versioned, governed components.

Therefore, Option B provides the strongest, most scalable, and most consistently governed approach for standardized GenAI deployments across business units.

Option B is the correct solution because it directly addresses both throughput bottlenecks and latency requirements using native Amazon Bedrock performance optimization features that are designed for real-time, high-volume generative AI workloads.

Amazon Bedrock supports cross-Region inference profiles, which allow applications to transparently route inference requests across multiple AWS Regions. During peak usage periods, traffic is automatically distributed to Regions with available capacity, reducing throttling, request queuing, and timeout risks. This approach aligns with AWS guidance for building highly available, low-latency GenAI applications that must scale elastically across geographic boundaries.

Token batching further improves efficiency by combining multiple inference requests into a single model invocation where applicable. AWS Generative AI documentation highlights batching as a key optimization technique to reduce per-request overhead, improve throughput, and better utilize model capacity. This is especially effective for lightweight, low-latency models such as Claude 3 Haiku, which are designed for fast responses and high request volumes.

Option A does not meet the requirement because purchasing provisioned throughput in a single Region creates a regional bottleneck and does not address multi-Region availability or traffic spikes beyond reserved capacity. Retries increase load and latency rather than resolving the root cause.

Option C improves application-layer scaling but does not solve model-side throughput limits. Client-side round-robin routing lacks awareness of real-time model capacity and can still send traffic to saturated Regions.

Option D is unsuitable because batch inference with asynchronous retrieval is designed for offline or non-interactive workloads. It cannot meet a strict 2-second response time requirement for an interactive AI assistant.

Therefore, Option B provides the most effective and AWS-aligned solution to achieve low latency, global scalability, and high throughput during peak usage periods.

Options A and E are correct because the failure pattern is caused by exceeding the model’s usable context window and by sending too much raw customer data directly to the FM. Amazon Bedrock Knowledge Bases follows the RAG pattern by splitting source content into manageable chunks, converting chunks into embeddings, storing them in a vector index, and using semantic similarity to retrieve relevant content for a user query. This supports option E because the application can index customer purchases, profiles, and review-related information, then retrieve only the most relevant records for the current recommendation request instead of stuffing all raw data into one prompt.

Option A is also correct because chunking and staged synthesis are standard ways to handle inputs that exceed an FM’s context capacity. Processing smaller segments avoids context-length-exceeded errors, and a final synthesis call can combine intermediate findings into a complete recommendation. This is especially useful when the company says it wants the system to consider all customer data, not merely truncate older or less important data. Amazon Bedrock Knowledge Bases also lets teams configure how content is chunked for storage and retrieval, which supports a structured approach rather than an oversized one-shot prompt.

Option B is not sufficient because truncating “less important” data conflicts with the requirement to consider all customer data. Option C violates the implied design direction because the company wants to use Knowledge Bases, and simply choosing a larger context model does not solve long-term growth of customer histories. Option D is technically incorrect: model parameters such as max_tokens control output generation limits, not the model’s maximum context window, and different Claude models have model-specific maximum values. You cannot use additionalModelRequestFields to bypass the FM’s context limit.

==========

This error occurs because SCPs override IAM permissions, and the SCP currently blocks Bedrock inference calls that resolve to eu-west-3, even though the company intends to use cross-Region inference (CRI) from eu-central-1.

Amazon Nova Pro is not hosted in eu-central-1, so when invoked, Amazon Bedrock transparently routes the request to a supporting Region (such as eu-west-3) through CRI inference profiles. However, SCPs that restrict Regions or specific Bedrock resources will block this routing unless explicitly allowed.

Option B is required because the SCP must explicitly allow the eu.amazon.nova-pro-v1:0 inference profile, which is the Bedrock abstraction that enables CRI while preserving data residency guarantees. Without this, Bedrock cannot legally route the request.

Option E is also required to allow EU-scoped inference profiles rather than individual Regions. This preserves precise governance while allowing Bedrock-managed CRI routing within the EU boundary, ensuring no data leaves Europe.

Option A violates least-privilege and does not override SCPs. Option C breaks data residency by enabling direct eu-west-3 access. Option D does not resolve the SCP denial.

Therefore, Options B and E are the only combination that resolves the error while preserving governance and EU-only data residency.

When a foundation model fails to include specific required content or fails to integrate it coherently, prompt engineering techniques like output indicators or " wrappers " are highly effective. By explicitly defining where the promotional message should appear (e.g., " The response must end with the following message: [PROMO TEXT] " ) or providing an example output structure, the developer reinforces the constraint within the model ' s generation path. This is more direct and less computationally expensive than generating multiple variants and reranking them (Option B) or adding complex post-processing layers (Option C). Guardrails (Option A) are intended for filtering harmful content rather than enforcing specific promotional copy insertion.

Option B is the correct solution because AWS AppConfig is specifically designed to support dynamic configuration management with safe rollout, validation, and rollback, which are explicit requirements in the scenario.

By storing the active model provider configuration in AWS AppConfig, the company can switch between Amazon Bedrock model providers in real time without redeploying Lambda code. AppConfig supports deployment strategies such as canary releases, linear rollouts, and immediate deployments, allowing safe and controlled changes. If a configuration causes issues, AppConfig supports automatic rollback, reducing operational risk.

AWS AppConfig also supports schema validation, ensuring that configuration values such as model identifiers, provider names, or inference parameters are valid before being applied. This prevents misconfiguration from impacting production workloads.

Option A uses Parameter Store, which lacks native rollout strategies, validation, and automated rollback, making it unsuitable for safe real-time switching. Option C requires manual routing changes and code coupling, increasing operational overhead and deployment risk. Option D introduces unnecessary complexity by hosting configuration files in Amazon S3 when AppConfig already supports native hosted configurations.

Therefore, Option B provides the most robust, scalable, and low-maintenance solution for dynamic model switching in a serverless Amazon Bedrock inference architecture.

Option B is correct because it uses the managed evaluation capability in Amazon Bedrock that is intended specifically for comparing foundation models using a consistent prompt set and producing structured results with minimal custom tooling. In a Bedrock evaluation workflow, you provide an input dataset of prompts, typically in JSON Lines format so each line represents one evaluation record. Storing the JSONL file in Amazon S3 allows Bedrock to read the dataset at scale and write standardized evaluation outputs back to S3 for downstream analysis, sharing, and retention.

The key requirement is to assess both quality and safety across multiple models. A Bedrock evaluation job can use a judge model to score the generated outputs against defined criteria. This approach supports repeatable, apples-to-apples comparisons because the same judge model and scoring rubric can be applied to every candidate foundation model. The candidate models are configured as generators, meaning each evaluation job run uses one selected FM to produce answers for the same prompt set, and the judge model evaluates those answers. That matches the requirement to generate evaluation reports that help a data scientist select the best FM.

Option A does not use Bedrock evaluation jobs, and a knowledge base plus RetrieveAndGenerate is a RAG pattern, not an evaluation framework. It would produce responses but not standardized scoring and reporting suitable for model selection. Option C is incorrect because Bedrock evaluation outputs are delivered to S3, not directly to a BI destination, and selecting the candidate FM as the evaluator conflicts with the intended pattern of using a stable judge model. Option D misuses knowledge bases and retrieval evaluation types when the requirement is prompt-based model assessment rather than evaluating retrieval quality.

Option A is the correct solution because it satisfies authentication, private connectivity, fine-grained authorization, and auditing using AWS-recommended patterns.

SAML federation between Microsoft Entra ID and IAM is a mature, well-supported integration that enables centralized enterprise authentication. Department-specific IAM roles allow precise control over which Bedrock ModelId values each department can invoke, enforcing access by model family.

Using AWS PrivateLink interface VPC endpoints for Amazon Bedrock runtime services ensures that all inference traffic stays on private AWS network paths, with no public internet exposure. NAT gateways and public endpoints, as used in other options, violate this requirement.

AWS CloudTrail provides authoritative audit logs of all Bedrock API calls, which is required for compliance. Amazon Bedrock model invocation logging complements CloudTrail by capturing detailed prompt and response metadata for deeper auditing and investigation.

Option B uses public endpoints via NAT. Option C incorrectly claims public endpoints can be private. Option D relies on IdP-side logs, which do not capture Bedrock API activity.

Therefore, Option A is the only solution that fully meets security, compliance, and observability requirements.

Amazon Bedrock Prompt Management is the purpose-built service for prompt lifecycle management. it provides native version control , allowing developers to test and compare variants side-by-side. Use of parameterized variables ensures that a single prompt structure can be consistently reused across different sub-applications (assistants vs. graders) while still being tailored to the specific context. To " integrate into the main application " with minimal overhead, Amazon Bedrock Flows provide a managed orchestration layer. Flows allow developers to link managed prompts with AWS services (like knowledge bases or Lambda functions) without writing complex state-machine logic in Step Functions (Option B). This combination ensures consistent, auditable, and easily deployable prompt assets across the university ' s diverse use cases.

The first option labeled B is the correct solution because it fully satisfies both private connectivity and fine-grained cross-account data governance requirements using AWS-native services.

Creating interface VPC endpoints for Amazon Bedrock runtimes ensures that all inference calls remain on the AWS private network and never traverse the public internet. Running AWS Lambda functions in private subnets enforces network isolation, and using IAM conditions that restrict access to specific VPC endpoints and roles prevents unauthorized inference calls.

For the governed data lake, AWS Lake Formation LF-tag–based access control is the recommended AWS mechanism for enforcing cross-account, column-level permissions. LF-tags allow the company to define data access policies once and apply them consistently across accounts, databases, tables, and even individual columns. This is required for sensitive customer records and is not achievable with S3 bucket policies or IAM alone.

The second option labeled B uses a NAT gateway, which violates the private connectivity requirement. Option C uses public Bedrock endpoints and only database-level grants, which are insufficient. Option D relies on IAM path-based policies, which cannot enforce column-level access and introduces public fallback paths.

Therefore, the first option labeled B is the only solution that meets all networking, security, and data governance requirements.

Option C directly addresses the root cause of truncated and inconsistent responses by using AWS-recommended semantic chunking and dynamic retrieval rather than static or sequential chunk processing. Amazon Bedrock documentation emphasizes that foundation models have fixed context windows and that sending oversized or poorly structured input can lead to truncation, loss of context, and degraded output quality.

Semantic chunking breaks documents based on meaning instead of fixed token counts. By using a breakpoint percentile threshold and sentence buffers, the content remains coherent and semantically complete. This approach reduces the likelihood that important concepts are split across chunks, which is a common cause of inconsistent summarization results.

The RetrieveAndGenerate API is designed specifically to handle large documents that exceed a model’s context window. Instead of forcing all content into a single inference call, the API generates embeddings for chunks and dynamically selects only the most relevant chunks based on similarity to the user query. This ensures that the FM receives only high-value context while staying within its context window limits.

Option A is ineffective because chaining chunks sequentially does not align with how FMs process context and risks exceeding context limits or introducing irrelevant information. Option B improves structure but still relies on larger parent chunks, which can lead to inefficiencies when processing very large documents. Option D processes segments independently, which often causes loss of global context and inconsistent summaries.

Therefore, Option C is the most robust, AWS-aligned solution for resolving truncation and consistency issues when processing large technical documents with Amazon Bedrock.

Option B is the optimal solution because it maximizes similarity search accuracy and performance for a small, proprietary dataset while maintaining low operational complexity. Amazon MemoryDB is a fully managed, in-memory database that provides microsecond-level latency, making it ideal for real-time RAG workloads that require fast vector similarity searches.

For small datasets with low index counts, the Hierarchical Navigable Small World (HNSW) algorithm is recommended by AWS for its high recall and accuracy. Unlike approximate methods optimized for massive datasets, HNSW excels at returning the most semantically relevant vectors with minimal loss of precision, which directly improves the quality of responses generated by the Amazon Bedrock foundation model.

Vertical scaling in MemoryDB is sufficient for this use case because the dataset size is limited. Scaling up instance size provides increased memory and compute capacity without the complexity of managing distributed indexes or sharding strategies. This simplifies operations while maintaining predictable performance.

Option A’s Flat algorithm is computationally expensive and inefficient at scale, even for moderate query volumes. Option C introduces higher latency and operational overhead by using a relational database not optimized for in-memory vector search. Option D is unsuitable because Amazon DocumentDB is not designed for high-performance vector similarity workloads and introduces unnecessary replica management complexity.

Therefore, Option B best meets the requirements for accuracy, performance, and efficient integration with an Amazon Bedrock–based RAG application.

Option A is the correct solution because it uses native Amazon Bedrock governance and evaluation capabilities to meet regulatory, performance, and deployment timeline requirements with the least operational overhead.

Amazon Bedrock guardrails provide built-in safety controls that enforce responsible AI policies directly during inference. Custom content filters and toxicity detection protect customer interactions and prevent disallowed investment guidance patterns without requiring custom application logic. Guardrails operate inline and are optimized for low latency, which helps meet the strict 200 ms response-time requirement.

Hallucination detection is addressed through Amazon Bedrock Model Evaluation, which supports automated evaluation at scale using LLM-as-a-judge techniques. This enables the company to detect factual inaccuracies and policy violations systematically, without building custom evaluation pipelines or requiring extensive human review. Evaluation outputs can be surfaced as metrics.

Storing all prompt-response pairs in Amazon DynamoDB provides a low-latency, highly scalable audit store that aligns with financial regulatory requirements. Using TTL enforces data retention policies automatically, reducing compliance risk and storage overhead.

Amazon CloudWatch custom metrics integrate seamlessly with existing compliance dashboards, allowing near–real-time monitoring of safety interventions, hallucination rates, and drift indicators. CloudWatch anomaly detection can be applied to these metrics to surface behavior changes quickly.

Option B relies on custom Lambda logic and S3-based auditing, increasing latency and operational complexity. Option C introduces additional services that increase setup time and may exceed the 60-day deployment window. Option D uses non–Bedrock-native monitoring and adds unnecessary infrastructure layers.

Therefore, Option A provides the most complete, compliant, and low-overhead governance solution for a regulated GenAI financial services application.

Option B best meets all stated requirements by correctly combining PII protection , evaluation before launch , and data residency compliance using Amazon Bedrock Guardrails. Amazon Bedrock guardrails provide native sensitive information filtering that operates inline during model invocation, making them well suited for preventing personal data exposure in customer-facing AI assistants.

The requirement to evaluate how effective the AI assistant is at preventing exposure before release is best addressed by using mask mode during development and testing . Mask mode allows responses to be generated while automatically redacting detected personal information, making it easy for developers and reviewers to see where and how PII would have appeared. This provides concrete validation that the guardrail rules are correctly configured without fully blocking responses, which is ideal for quality assurance and pre-production evaluation.

For production , switching the guardrail to block mode ensures that responses containing personal information are fully prevented from being returned to users. This offers the strongest protection and aligns with compliance expectations for customer account data. Block mode is appropriate once confidence in the guardrail configuration has been established during testing.

The data residency requirement is addressed by deploying a copy of the guardrail in each AWS Region where the application operates. Amazon Bedrock guardrails are Region-specific resources, and using Region-local guardrails ensures that inference, filtering, and enforcement all occur within the same Region as the customer data. This avoids cross-Region processing and helps the company comply with regulatory and contractual data residency policies.

Option A and D incorrectly rely on cross-Region guardrails, which can violate data residency constraints. Option C focuses on topic filtering rather than sensitive information filtering and keeps detect mode enabled in production, which does not actively prevent PII exposure. Therefore, B is the only option that fully satisfies safety, compliance, and evaluation requirements.

Option B is the most appropriate solution because it directly uses Amazon Bedrock cross-Region inference profiles, which are designed to provide resilience and load distribution while respecting data residency boundaries. Cross-Region inference profiles allow applications to distribute inference requests across multiple Regions within a defined geographic boundary, such as Europe or North America, without requiring custom failover logic.

By specifying geographical codes in the inference profile ID, the application ensures that European user data is processed only within Europe-based Regions, satisfying regulatory requirements. At the same time, Bedrock automatically routes requests to healthy Regions within that geography when traffic spikes or service quotas are reached, improving availability and maintaining low latency.

Using separate Amazon API Gateway HTTP APIs for Europe and North America provides a clean, simple routing layer that directs users to the appropriate regional inference profile. This avoids complex custom routing or retry logic in application code and minimizes operational overhead.

Option A relies on custom routing and manual monitoring, which increases complexity and does not provide automatic resilience. Option C introduces custom retry and fallback logic that risks violating data residency requirements if misconfigured. Option D requires significant application-level failover logic and adds operational burden with Global Accelerator configuration.

Therefore, Option B best meets the requirements for low latency, data residency compliance, resilience during traffic spikes, and minimal operational complexity.

Option B is the correct solution because Amazon Bedrock provisioned throughput is only used when the application explicitly invokes the provisioned model ARN, not the base foundation model ID. In the provided code, the application is calling the standard model identifier (anthropic.claude-v2), which routes requests to on-demand capacity instead of the purchased provisioned throughput.

When the CreateProvisionedModelThroughput API is used, Amazon Bedrock returns a provisioned model ARN that represents the reserved capacity. Applications must reference this ARN in the modelId parameter when invoking the model. If the base model ID is used instead, Bedrock treats the request as on-demand traffic, which explains why CloudWatch metrics show unused provisioned capacity alongside throttled on-demand requests.

Option A would increase capacity but would not fix the root cause because the application is not using the provisioned resource at all. Option C adds resiliency but does not ensure usage of provisioned throughput and would still incur throttling. Option D changes the response delivery mechanism but does not affect capacity routing.

Therefore, Option B directly resolves the throttling issue by correctly routing traffic to the reserved capacity and ensures that the company benefits from the provisioned throughput it has purchased.

Option B is correct because it is the only option that satisfies all requirements: centralized cataloging, automatic data-source discovery, citation metadata, model input/output logging, and tamper-evident immutable audit retention. AWS Glue Data Catalog is designed as a central metadata repository, and AWS Glue crawlers can automatically discover and catalog new or updated data sources. AWS documentation states that crawlers can infer metadata and keep the Data Catalog up to date across sources such as Amazon S3, Amazon RDS, Amazon Redshift, and other supported stores. This directly addresses the requirement to catalog all data sources centrally and update them automatically.

Storing generated summaries in Amazon S3 and writing object tags that include source IDs is appropriate because S3 object tags are queryable metadata that can be used for organization, lifecycle policies, access controls, cost allocation, and downstream indexing. For GenAI traceability, the source ID tag can represent the citation or provenance link from the generated summary back to the original technical document.

Amazon Bedrock model invocation logging is also required here because the company must retain input/output records for every model invocation. AWS documentation states that model invocation logging can collect invocation logs, model input data, and model output data for Amazon Bedrock invocations, with Amazon S3 as a supported delivery destination.

For immutable retention, S3 Object Lock provides write-once-read-many protection and helps prevent objects from being deleted or overwritten for a fixed period or indefinitely. CloudTrail log file integrity validation adds tamper evidence by using hashing and digital signing to detect whether log files were changed, deleted, or forged after delivery.

Option A explicitly omits logs for each invocation, so it fails the audit requirement. Option C lacks automatic source discovery and immutable audit retention. Option D uses configuration tooling, not a cataloging and audit architecture. Therefore, option B is the complete AWS-aligned solution.

==========

Option C directly addresses both retrieval relevance and performance scalability. Fixed token chunking breaks semantic continuity in legal texts, causing incomplete context retrieval and degraded response quality. By switching to semantic chunking—based on legal arguments, clauses, or sections—the application preserves contextual integrity, improving retrieval accuracy and reducing hallucinations.

Regenerating embeddings aligned with the new chunk structure also improves vector search efficiency, reducing unnecessary comparisons and helping control latency as the dataset scales.

Option A increases cost and latency without fixing the core issue. Option B removes dynamic reasoning, which defeats the purpose of a legal RAG system. Option D discards vector semantics entirely and is unsuitable for nuanced legal research. Therefore, Option C is the correct and scalable solution.

Option A is the only choice that simultaneously addresses all three requirements: (1) higher output consistency for identical inputs, (2) sub-1-second performance, and (3) validated safety controls that block unsafe or hallucinated recommendations.

Provisioned throughput in Amazon Bedrock reserves capacity for the chosen model, which helps stabilize latency and reduces the chance of throttling or variable response times across Regions. This is important for a mobile app with strict latency goals and users distributed across multiple Regions. While provisioned throughput primarily improves performance predictability, it also reduces variability caused by contention during peak demand.

Amazon Bedrock guardrails provide validated safety controls to filter or block unsafe content. Semantic denial rules are appropriate for preventing dangerous brewing guidance (for example, excessively high temperatures) and for reducing hallucinated instructions that violate safety policies. Guardrails can be enforced consistently regardless of prompt-chain complexity, providing a uniform safety layer around the model outputs.

Amazon Bedrock Prompt Management supports controlled prompt versioning and approval workflows. By standardizing prompts, controlling changes, and ensuring the same prompt version is used for identical inputs, the company improves output stability and reduces drift caused by unmanaged prompt edits. Combined with strict configuration control (including fixed inference parameters such as temperature where appropriate), this improves repeatability and increases the likelihood of achieving the 99.5% consistency target.

Option B improves observability and experimentation but does not provide strong safety enforcement or latency stabilization. Option C improves performance through caching and tracing but does not provide validated safety controls and does not directly address cross-Region output consistency. Option D may improve retrieval but does not enforce safety controls or ensure repeatable outputs.

Therefore, Option A best meets the stability, performance, and safety requirements using AWS-native controls.

Amazon Q Developer Pro provides a built-in administrator dashboard designed specifically for organizational observability. This dashboard provides native visibility into user-level metrics across the entire AWS Organization, allowing administrators to identify active vs. underused subscriptions and recognize power users. Crucially, it tracks high-level usage patterns, including code acceptance metrics (such as lines of code generated and accepted), which is a key requirement for measuring ROI and identifying training needs. Using the built-in dashboard provides the necessary insights with the least operational overhead, as it does not require building custom data pipelines (Option C) or complex log processing architectures (Option D).

Option D is the correct solution because it directly satisfies all three core requirements: data source registration, metadata-based attribution, and end-to-end audit logging, while remaining service-agnostic and scalable across internal and external data sources.

The AWS Glue Data Catalog is the AWS-native service for registering datasets and managing metadata centrally. It supports structured registration of diverse data sources and enables consistent tagging that can be used to attribute generated content back to its original source. This is essential for GenAI applications that combine multiple datasets and must provide traceability for outputs.

Metadata tags applied within the Glue Data Catalog ensure a consistent attribution framework that downstream systems—such as Retrieval Augmented Generation (RAG) pipelines or evaluation systems—can reference without embedding attribution logic directly in application code. This improves maintainability and governance.

AWS CloudTrail provides immutable audit logs of API activity across AWS services, including data access, metadata changes, and pipeline interactions. CloudTrail logs are critical for compliance and regulatory review because they capture who accessed which data, when, and through which service. This satisfies the requirement to maintain audit logs “throughout the pipeline,” not just at storage or application layers.

Option A introduces Lake Formation, which is primarily intended for fine-grained data lake permissions and is not required solely for traceability. Option B relies on CloudWatch Logs, which does not provide authoritative audit logging across services. Option C limits audit scope to S3 access and does not register or govern all data sources comprehensively.

Therefore, Option D provides the most complete and least intrusive solution for traceable, auditable GenAI data pipelines.

Option C best satisfies the requirement to change routing decisions without redeploying code while supporting complex, frequently changing business logic at scale. AWS AppConfig is designed for centrally managing dynamic configuration (feature flags, rules, thresholds, and policy parameters) and deploying changes safely. It supports controlled deployments, validation, and rapid propagation of updated configuration values, which aligns with “real-time cost metrics that change hourly” and the need for “immediate propagation across thousands of concurrent requests.”

In this design, the Lambda function becomes the policy decision point. For each request, it evaluates user attributes (tier, transaction value), context (regulatory zone, Region), and live cost/performance thresholds stored in AppConfig to determine which Amazon Bedrock FM to invoke. Because the routing rules and FM identifiers are delivered as configuration, the company can switch models, adjust A/B testing weights, or update compliance routing rules by deploying new AppConfig configuration versions rather than pushing new application code. This reduces operational risk and accelerates iteration.

Exposing a single API Gateway endpoint also minimizes client complexity and keeps routing logic server-side, which is important when rules change frequently. Lambda can cache configuration between invocations (within the execution environment) to reduce repeated fetch overhead while still picking up changes quickly, enabling both low latency and rapid rule rollout under high concurrency.

Option A relies on Lambda environment variables, which are not intended for frequent real-time updates and typically require function configuration updates that are slower and operationally brittle. Option B uses mapping templates and stage variables, which are limited for complex rule evaluation and safe rollout patterns. Option D misuses authorizers for business routing, adds extra latency and complexity, and complicates observability and error handling by splitting decisioning from execution.

Option A is the correct solution because hybrid search directly addresses the core retrieval failure modes while maintaining low latency and minimal operational overhead. In medical and scientific domains, exact terminology, abbreviations, and acronyms (for example, drug names, procedures, or conditions) are critical. Pure vector similarity search often underweights these exact matches, leading to missed results and excessive semantically related but irrelevant documents.

Amazon OpenSearch Service natively supports hybrid search, which combines keyword-based retrieval (such as BM25) with vector similarity search. Keyword search ensures precise matching for exact terms and acronyms, while vector search captures semantic meaning and contextual similarity. By blending these approaches, the retrieval system improves both precision and recall without introducing additional infrastructure.

Hybrid search operates within the same OpenSearch index and query path, which preserves low end-user latency even at large scale. This is especially important as the document collection grows to millions of documents. Because OpenSearch handles scoring and ranking internally, no additional orchestration layers or post-processing steps are required.

Option B increases computational cost and latency while failing to address exact-term recall. Option C introduces a new service and ingestion pipeline, increasing operational overhead and latency. Option D adds model hosting, re-ranking infrastructure, and complexity that is unnecessary when OpenSearch provides native hybrid retrieval.

Therefore, Option A delivers the best balance of retrieval quality, scalability, latency, and operational simplicity for medical RAG workloads.

Option B is the correct solution because Amazon Q Business natively supports access control lists (ACLs) for S3 data sources using a single, centralized JSON file that maps S3 prefixes to IAM Identity Center groups. This approach directly aligns with the company’s data organization model, where each department’s data is stored under a distinct S3 prefix and each employee belongs to exactly one department group.

Using a single acl.json file at the bucket root minimizes operational overhead by centralizing access control logic in one location. Administrators can update department mappings without touching individual folders or changing IAM permissions, which simplifies governance and reduces the risk of configuration drift. Amazon Q Business automatically evaluates the user’s IAM Identity Center group membership at query time and filters accessible documents accordingly.

Option A increases operational complexity by requiring a separate ACL file in every department folder, which becomes difficult to maintain as departments or prefixes change. Option C attempts to enforce access using IAM permissions sets, but Amazon Q Business access control for S3 data sources is not designed to be managed through IAM condition logic and would significantly increase complexity. Option D introduces a custom metadata structure that is not the supported mechanism for Amazon Q Business access enforcement.

Therefore, Option B provides the cleanest, most scalable, and AWS-recommended solution for enforcing department-based access control with the least operational effort.

Option A is the correct answer because Amazon Bedrock Flows is purpose-built to orchestrate generative AI workflows that combine data access, deterministic transformations, and model invocation with minimal operational overhead. The requirements explicitly state that the workflow must retrieve content from Amazon S3, extract a specific portion of a predefined template, send that portion to an Amazon Bedrock model, and store the model’s response back into the same S3 bucket. Amazon Bedrock Flows natively supports all of these steps.

By configuring S3 action nodes at the beginning and end of the flow, the workflow can retrieve the original communications and persist the reviewed output without custom code. The expression step allows deterministic parsing of a specific portion of the template, which is essential when only part of the message should be reviewed. This avoids relying on generative logic for parsing, which would be less predictable and harder to audit. The agent step is then used specifically for the review task, where the foundation model evaluates or modifies the extracted content.

Option B uses AWS Step Functions, which can achieve similar outcomes but requires more explicit orchestration logic and does not provide GenAI-native constructs such as expressions and agent steps in a single managed experience. Options C and D rely on Amazon Bedrock agents and AWS Lambda functions to handle parsing and data movement, which increases complexity, operational overhead, and maintenance burden.

Because Amazon Bedrock Flows directly integrates S3 actions, parsing expressions, and model review steps in a single managed workflow, Option A best meets the requirements with the least development and operational effort.

Option B is the most appropriate solution because it directly aligns with AWS-recommended architectural patterns for building scalable, observable, and resilient generative AI applications on Amazon Bedrock. The requirements clearly distinguish between simple and complex routing decisions, and this option addresses both in an optimal way.

Simple routing based on file extension is latency sensitive. Handling this logic directly in the application code avoids unnecessary orchestration, state transitions, and service calls. This approach ensures that straightforward requests, such as routing images to vision-capable foundation models or text files to language models, are processed with minimal overhead and maximum performance.

For complex routing based on content semantics, AWS Step Functions is specifically designed for multi-step workflows that require analysis, branching logic, and error handling. Semantic routing often requires inspecting meaning, intent, or structure before selecting the appropriate foundation model. Step Functions enables this by orchestrating analysis steps and applying conditional logic to determine the correct model to invoke using the Amazon Bedrock InvokeModel API.

A key requirement is detailed execution history. Step Functions provides built-in execution tracing, including state inputs, outputs, and error details, which is essential for auditing, debugging, and compliance. Additionally, Step Functions supports native retry and catch mechanisms, allowing the workflow to automatically fall back to alternate foundation models if a primary model invocation fails. This directly satisfies the fallback requirement without introducing excessive custom code.

The other options lack one or more critical capabilities. Lambda-only logic lacks deep observability and structured fallback handling, SQS introduces additional latency and limited workflow visibility, and multiple coordinated workflows increase architectural complexity without added benefit.

Option D requires the least development effort because it uses a managed retrieval workflow that bundles the most time-consuming parts of semantic search: embedding generation, vector indexing, and natural language retrieval. With an Amazon Bedrock knowledge base, the application does not need to implement and operate separate services to (1) generate embeddings for hundreds of millions of records, (2) store and manage vectors, (3) build query-time embedding conversion logic, and (4) implement k-NN search orchestration. Instead, the knowledge base is configured to automatically create embeddings during ingestion, and the application queries it using the Amazon Bedrock Retrieve API , which accepts natural language input and performs the vector search as a managed capability.

The performance requirement (95% of queries within 500 ms) is best served by a purpose-built vector search backend rather than running similarity search directly inside a transactional PostgreSQL system at this scale. A knowledge base is designed for retrieval patterns and can be backed by scalable vector stores, which helps meet latency goals under heavy concurrency. The hourly freshness requirement maps naturally to ingestion updates: the pipeline can re-ingest updated restaurant details on a schedule so the knowledge base remains current without building custom re-embedding workflows in application code.

Cost-effective scaling during peak periods is also easier with a managed retrieval layer because scaling the retrieval workload is separated from the operational database. This avoids overprovisioning PostgreSQL for peak semantic-search traffic and reduces the engineering effort to tune performance, sharding, indexing, and retry logic.

Options B and C can work, but they require the team to build and maintain embedding pipelines, query embedding generation, vector index management, and operational scaling strategies. Option A does not provide semantic search because it relies on keyword-based matching rather than embeddings.

Option A is the best solution because it directly addresses both observed problems: user-perceived latency and resolver timeouts that occur more frequently for complex prompts. In the current design, an AWS AppSync Lambda resolver is configured with synchronous RequestResponse behavior. That means the client receives nothing until the entire retrieval and generation workflow completes. For longer-running knowledge base queries, this increases the likelihood of hitting request time limits in the synchronous path and creates a poor user experience because the UI appears stalled.

Using AWS Amplify AI Kit to implement streaming responses allows the application to return partial output incrementally as the model produces tokens. This improves perceived responsiveness because users can see the answer forming immediately, even when the full response takes longer. Streaming also reduces the impact of variable model latency and retrieval time because the client no longer waits for a single final payload before rendering content. From a troubleshooting perspective, streaming makes it easier to distinguish “slow generation” from “no response,” and it provides faster feedback during testing of complex questions.

Option B is not sufficient because increasing timeouts and adding retries can worsen load and cost while still producing a stalled UI experience. Retries also risk duplicating requests to the knowledge base and can amplify token usage. Option C introduces an awkward polling model for GraphQL interactions and adds significant operational complexity, while not inherently improving interactivity. Option D adds major architectural changes by replacing the knowledge base RetrieveAndGenerate call path with a different streaming invocation API and introducing a WebSocket layer, which is unnecessary when the goal is primarily to fix timeouts and improve UX within the existing AppSync and Amplify design.

Therefore, streaming through Amplify AI Kit is the most effective and lowest-friction improvement.

Thought for 24s

Option B is correct because the application is currently invoking the base foundation model identifier, which routes traffic to the on-demand capacity pool rather than the company’s purchased provisioned throughput. In Amazon Bedrock, provisioned throughput is attached to a specific provisioned resource created through the provisioned throughput APIs. To consume that reserved capacity, inference requests must target the provisioned resource identifier that represents the purchased throughput, not the generic model identifier used for on-demand inference.

The code snippet uses modelId= " anthropic.claude-v2 " . This value selects the on-demand endpoint for that model. As a result, requests are subject to on-demand quotas and throttling behavior, while the provisioned throughput remains idle. This directly explains the CloudWatch observation: provisioned capacity metrics show unused capacity because no traffic is being directed to the provisioned resource, and the on-demand path is throttling because it is exceeding the applicable on-demand limits during peak volume.

Replacing the modelId value with the provisioned throughput ARN returned by the CreateProvisionedModelThroughput workflow ensures the runtime invocation is routed to the reserved capacity. Once traffic is directed correctly, the purchased model units provide the consistent throughput required for predictable performance during business hours, which is exactly why provisioned throughput is used.

Option A could increase capacity, but it does not fix the core issue that the application is not using the provisioned resource at all. Option C can reduce the impact of throttling temporarily, but it adds latency and does not guarantee consistent throughput; it also still wastes the provisioned capacity. Option D changes the response delivery mechanism, but throttling is a capacity routing and quota issue, not a streaming API issue.

The errors described indicate missing permissions at both the application orchestration and data access levels. The 400 Bad Authorization from BedrockAgentRuntime indicates the Lambda execution role lacks the identity permission to invoke the agent; adding bedrock:InvokeAgent and aoss:APIAccessAll (which allows the principal to interact with OpenSearch Serverless APIs) is necessary. The 403 Forbidden error from OpenSearch Serverless specifically relates to data-plane permissions. Unlike traditional OpenSearch, Serverless uses data access policies . To " manage collections at scale " automatically, a policy must be created that uses pattern-based resource rules (e.g., matching a prefix), ensuring that as new collections or indexes are created, the required principals (the Lambda role and the Bedrock service role) are granted the necessary access without manual policy updates for every new resource.

This scenario requires strict data residency, regional processing, classification, and auditable decision trails, which Option C addresses using AWS-native governance services.

Region-specific Amazon S3 buckets enforce geographic data boundaries. Amazon S3 Object Lock ensures immutability of stored data and logs, supporting regulatory retention and non-repudiation requirements. Pre-processing data within the same Region before invoking Amazon Bedrock ensures that inference and data handling do not cross continental boundaries.

Amazon Macie provides managed, automated data classification for sensitive data types such as PII and financial records, fulfilling the classification requirement without custom tooling.

AWS CloudTrail immutable logs provide comprehensive audit trails of all API calls, model invocations, and data access events, ensuring traceability of AI decision-making processes.

Option A violates residency rules through cross-Region inference. Option B does not provide data classification. Option D introduces high operational overhead and relies on manual compliance reporting.

Therefore, Option C is the most compliant, scalable, and operationally efficient solution for regionally governed GenAI workloads.

Option B is the correct evaluation configuration because it enables end-to-end assessment of both retrieval and generation quality while supporting direct comparison of chunking strategies and foundation models. Amazon Bedrock evaluation jobs are designed to support RAG workflows by evaluating how well retrieved context supports accurate and high-quality model outputs.

A retrieve-and-generate evaluation job evaluates the complete RAG pipeline, not just retrieval. This is essential for medical information use cases, where both the relevance of retrieved content and the correctness of generated responses directly impact user safety and trust. Including multiple chunking strategies in the evaluation dataset allows side-by-side comparison under identical prompts and conditions.

Custom precision-at-k metrics measure how effectively the retrieval component surfaces relevant chunks, while an LLM-as-a-judge metric provides qualitative scoring of generated responses. Using a numeric scale enables consistent, repeatable evaluation and supports automated quality gates. Amazon Bedrock supports LLM-based evaluators to score dimensions such as accuracy, completeness, and relevance.

Using the same evaluator model to assess outputs from both FMs ensures consistent scoring and eliminates evaluator bias. This configuration allows the company to define quantitative thresholds that must be met before deployment, enabling automated promotion through CI/CD pipelines.

Option A evaluates retrieval only and cannot assess generation quality. Option C introduces manual review, which does not scale and delays deployment. Option D separates retrieval and generation evaluation, making it harder to correlate chunking strategies with final output quality.

Therefore, Option B best meets the requirements for systematic evaluation, comparison, and quality enforcement in an Amazon Bedrock–based RAG system.

Option D best satisfies all functional, performance, and governance requirements while minimizing architectural complexity. The requirement explicitly states that all filtering must complete before content reaches the foundation model, which rules out asynchronous or streaming-based approaches that could delay enforcement.

Amazon Comprehend supports toxicity detection, prompt safety classification, and PII detection with entity redaction as managed capabilities. Running these filters in parallel ensures low end-to-end latency, which is essential for customer-facing communication platforms. Parallel execution avoids the cumulative latency that would be introduced by sequential pipelines.

Toxicity detection identifies offensive or abusive content early. Prompt safety classification detects requests for unethical, harmful, or manipulative advice, which directly addresses inappropriate advice solicitation requirements. PII detection with entity redaction ensures that customer privacy is preserved before data is sent to the FM, preventing sensitive information from being processed or echoed in generated responses.

Configuring thresholds allows fine-grained control over sensitivity while maintaining acceptable false-positive rates. Using CloudWatch metrics and alarms enables continuous monitoring of filtering behavior and intervention rates without adding custom routing or human review pipelines that would slow responses.

Option A lacks PII redaction. Option B introduces unnecessary model-building complexity and delayed PII checks. Option C adds sequential latency and introduces human review routing, which violates the response-time requirement.

Therefore, Option D provides the most robust, performant, and AWS-aligned layered content filtering solution.