Amazon Web Services AIP-C01 AWS Certified Generative AI Developer - Professional Exam Practice Test

Option B best satisfies the requirements because it directly applies Retrieval Augmented Generation principles using managed Amazon Bedrock Knowledge Bases, which are designed to handle large, complex documents while preserving contextual relationships. Financial reports often interleave tables with explanatory narrative, and accurate analysis depends on keeping those elements logically connected. By segmenting documents based on their structural layout —for example, sections, subsections, tables, and surrounding commentary—the knowledge base can retrieve semantically relevant chunks that maintain this relationship during inference.

Amazon Bedrock Knowledge Bases support contextual chunking strategies that go beyond simple fixed-size segmentation. This is critical for financial documents, where a metric in a table may be explained in adjacent paragraphs or footnotes. Context-aware chunking ensures that retrieved content includes both the numeric data and its interpretation, enabling the foundation model to generate accurate, grounded responses. Including citations further improves analyst trust and auditability by allowing users to trace answers back to specific source sections, which is a common requirement in financial environments.

Scalability is another key requirement. Knowledge Bases manage embedding generation, indexing, and retrieval orchestration as a managed service, which allows the solution to scale across large document collections without requiring custom infrastructure or model hosting. This approach also supports efficient updates as new quarterly reports are added, ensuring the retrieval layer remains current.

Option A does not scale well because processing entire 5–100 page documents in a single prompt increases token usage, latency, and cost while risking context truncation. Option C relies on fixed-size chunking triggered at query time, which often breaks semantic relationships in structured financial content. Option D introduces unnecessary architectural complexity by splitting structured and unstructured data into separate applications, increasing operational overhead without providing better contextual retrieval than a unified RAG approach.

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 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.

Option A is the most comprehensive and architecturally aligned solution for meeting end-to-end data lineage, real-time PII filtering, and automated compliance reporting requirements in a medical GenAI system built on Amazon Bedrock. Each requirement maps directly to a managed AWS service that is purpose-built for governance, security, and compliance.

AWS Glue Data Catalog is designed to register datasets across multiple sources and maintain metadata that supports lineage tracking. By cataloging all inputs that flow into the Bedrock-based system, the organization can trace how data moves from ingestion through processing and storage, which is essential for regulatory audits in healthcare environments.

For real-time PII filtering , Amazon Bedrock Guardrails provide native PII detection and filtering during model inference. Guardrails operate inline with model invocation, ensuring sensitive information is blocked or redacted before responses are returned to users. This satisfies the requirement for real-time protection rather than post-processing analysis.

AWS CloudTrail delivers a complete audit trail of all Amazon Bedrock API calls, including InvokeModel requests and configuration changes. Storing these logs in Amazon S3 enables long-term retention and supports compliance audits. CloudTrail ensures traceability of who accessed the system, when, and how it was used.

To strengthen compliance monitoring, Amazon Macie continuously scans stored data for sensitive information and automatically classifies findings. Publishing Macie findings to Amazon CloudWatch Logs and visualizing them through dashboards enables near-real-time visibility into compliance posture and supports automated reporting workflows.

The other options fall short. Option B performs PII filtering at the application edge rather than at inference time and relies on scheduled analysis instead of real-time enforcement. Option C focuses on replication and document processing rather than inline GenAI governance. Option D uses services that are not designed for PII detection in text-based GenAI workflows and lacks native lineage tracking.

Therefore, A best fulfills all stated requirements using AWS-recommended governance and security capabilities.

Option B is the correct solution because Amazon Bedrock Knowledge Bases with the RetrieveAndGenerate API provide a fully managed Retrieval Augmented Generation (RAG) capability that directly addresses grounding, citation, and hallucination prevention with the least operational overhead.

Amazon Bedrock Knowledge Bases automatically manage document ingestion, chunking, embedding, retrieval, and ranking from approved data sources. When used with the RetrieveAndGenerate API, the model is constrained to generate responses only from retrieved, approved clinical documentation, significantly reducing the risk of hallucinations or unsupported claims. The API also returns explicit source citations, which satisfies regulatory and clinical transparency requirements without requiring custom comparison or validation logic.

This approach aligns with AWS best practices for healthcare GenAI workloads, where correctness and traceability are critical. Because retrieval and generation are tightly integrated, the system avoids multi-step orchestration, custom verification pipelines, or additional compute layers that would increase latency and maintenance burden.

Option A introduces Amazon Kendra and custom post-processing logic, increasing operational complexity. Option C focuses on entity extraction rather than controlled knowledge grounding and does not guarantee citation or hallucination prevention. Option D requires manual orchestration between retrieval and generation and custom verification logic, which increases development and maintenance effort.

Therefore, Option B delivers accurate, grounded, and cited clinical recommendations with minimal infrastructure and operational overhead.

The correct combination is A, B, and D because these three options collectively satisfy the mandatory requirements for structured extraction, PII redaction before inference, regional human review, data residency, auditability, and high-scale availability with managed AWS services.

Option A is essential because Amazon Textract is the AWS-managed service designed to extract structured data from scanned documents such as forms, tables, and financial statements. Textract provides confidence scores, and Amazon Augmented AI (A2I) is purpose-built to route low-confidence extractions to human reviewers. Deploying Textract and A2I within the same Region ensures that the human review loop remains regionally constrained, meeting strict data residency requirements for applicants.

Option B satisfies the requirement to redact PII before inference by using AWS Lambda preprocessing. It also adds Amazon Bedrock guardrails to enforce safety controls on model outputs. Region-specific IAM roles ensure that only authorized principals in the correct Region can access the extracted data and invoke downstream services, strengthening residency enforcement and auditability.

Option D ensures that source documents are stored in Amazon S3 in the same Region as the applicant. Object metadata and tagging provide an auditable trail, supporting compliance reporting and traceability. S3 also provides the durability and availability needed to support 99.9% application availability as part of a well-architected pipeline.

Option C is not the correct approach for structured extraction from scans. Option E adds useful quality validation but is not strictly required to meet the stated requirements compared to A, B, and D. Option F is unrelated to the extraction/redaction/residency workflow requirements.

Therefore, A, B, and D are the best three choices to meet all stated requirements with minimal operational overhead.

Option B best meets the combined resiliency and observability requirements because it applies AWS-recommended retry behavior for transient throttling and enables true distributed tracing across service boundaries. During peak traffic, intermittent failures are commonly caused by throttling and other transient conditions. The AWS SDK standard retry mode provides exponential backoff with jitter, which reduces synchronized retry storms, prevents cascading failures, and improves overall system stability. Jitter is important because it spreads retry attempts over time, reducing load amplification during throttling events.

For observability, AWS X-Ray provides distributed tracing that follows a request across components such as API Gateway or load balancers, application services, and downstream calls to Amazon Bedrock. X-Ray can identify where latency is being introduced and which downstream call is contributing most to end-to-end response time. This is required to “identify latency contributors” and isolate performance issues under load.

The requirement also states that the company must correlate performance issues with specific FM characteristics. X-Ray annotations are designed for this purpose: the application can annotate traces with the model ID, inference parameters, region, or inference profile used. This enables filtering and analysis (for example, comparing latency or error patterns by model, parameter set, or endpoint configuration) without building a separate telemetry system.

Option A’s fixed-delay retries increase synchronized retry behavior and do not provide distributed tracing. Option C does not prevent cascading failures and cannot provide cross-service tracing. Option D is incorrect because CloudTrail is an audit logging service and does not provide distributed tracing for request latency analysis.

Therefore, Option B provides the correct combination of resilient retries and deep, model-correlated distributed observability for Amazon Bedrock workloads.

Option C is the correct solution because AWS AppConfig is designed for real-time, validated, centrally managed configuration changes with safe rollout, immediate propagation, and rollback support—exactly matching the company’s requirements.

By storing routing rules, cost thresholds, regulatory constraints, and A/B testing logic in AWS AppConfig, the company can switch between Amazon Bedrock foundation models without redeploying Lambda code. AppConfig supports feature flags, dynamic configuration updates, JSON schema validation, and staged rollouts, which are essential for safely managing complex and frequently changing routing logic.

Using the AWS AppConfig Agent, Lambda functions can retrieve cached configurations efficiently, ensuring low latency even under thousands of concurrent requests. This approach allows the Lambda function to apply proprietary business logic—such as user tier, transaction value, Region compliance, and real-time cost metrics—before selecting the appropriate FM.

Option A is operationally fragile because environment variable changes require function restarts and do not support validation or controlled rollouts. Option B is too limited for complex, dynamic logic and is difficult to maintain at scale. Option D misuses Lambda authorizers, which are intended for authentication and authorization, not high-frequency dynamic routing decisions.

Therefore, Option C provides the most scalable, flexible, and low-overhead architecture for dynamic, regulation-aware FM routing in a global GenAI system.

Option A is the correct solution because it provides proactive, model-aware token management with fine-grained visibility and alerting, which is required for regulated financial workloads. Amazon Bedrock currently exposes token usage metrics after invocation, but it does not natively enforce proactive, model-specific token limits across multiple applications or business units.

By implementing model-specific tokenizers in AWS Lambda, the company can estimate input and output token usage before sending requests to Amazon Bedrock. This enables early detection of requests that are approaching or exceeding model limits and allows the application to block, truncate, or reroute requests proactively rather than reacting to failures.

Publishing token usage metrics to Amazon CloudWatch enables real-time monitoring and alerting at scale, easily supporting more than 5,000 requests per minute. Storing detailed token usage data in Amazon DynamoDB allows the company to attribute usage and costs to specific applications, teams, or business units—an essential requirement for regulatory reporting and internal chargeback.

Option B is incorrect because Amazon Bedrock Guardrails do not currently provide token quota enforcement or proactive token alerts. Option C is reactive and only analyzes failures after they occur. Option D throttles requests but cannot enforce token-based limits or provide per-model cost attribution.

Therefore, Option A best satisfies proactive alerting, scalability, compliance reporting, and cost allocation requirements with acceptable operational effort.

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.

Option C best satisfies the requirement for flexible FM testing across environments while minimizing operational complexity and aligning with AWS-recommended deployment practices. Amazon Bedrock supports invoking on-demand foundation models through the FoundationModel abstraction, which allows applications to dynamically reference different models without requiring dedicated provisioned capacity. This is ideal for experimentation and A/B testing in both development and production environments.

Using a single AWS CDK application ensures infrastructure consistency and reduces duplication. Environment-specific configuration, such as selecting different foundation model IDs, can be externalized through parameters, context variables, or environment-specific configuration files. This allows product owners to easily switch between FMs in each environment without modifying application logic.

A single AWS CodePipeline with distinct deployment stages for development and production is an AWS best practice for multi-environment deployments. It enforces consistent build and deployment steps while still allowing environment-level customization. AWS CodeBuild deploy actions enable automated, repeatable deployments, reducing manual errors and improving governance.

Option A increases complexity by introducing multiple pipelines and relies on provisioned models, which are not necessary for FM evaluation and experimentation. Provisioned throughput is better suited for predictable, high-volume production workloads rather than frequent model switching.

Option B creates unnecessary operational overhead by duplicating CDK applications and pipelines, making long-term maintenance more difficult.

Option D directly conflicts with infrastructure-as-code best practices by manually recreating development resources, which increases configuration drift and reduces reliability.

Therefore, Option C provides the most flexible, scalable, and AWS-aligned solution for testing and switching foundation models across development and production environments.

The correct combination is C and D because together they enforce centralized governance over both model access and prompt content controls , which are the two core requirements of the scenario.

To ensure employees can use only approved Amazon Bedrock models , governance must be enforced at the organization level and not rely on individual application logic. Service Control Policies (SCPs) are the strongest control mechanism available in AWS Organizations because they define the maximum permissions an account or principal can have. In option C , the SCP prevents any Amazon Bedrock model invocation unless a centrally approved guardrail identifier is specified. This ensures that guardrails are always enforced, regardless of how or where the invocation originates. The additional use of IAM permissions boundaries ensures that even within allowed accounts, employees are restricted to invoking only explicitly approved foundation models.

To prevent specific topics and proprietary information from being included in prompts , Amazon Bedrock Guardrails must be used. Guardrails operate inline during model invocation and can block disallowed content before it is processed by the model. Option D correctly specifies a block filtering policy , which is appropriate when content must be prevented entirely rather than partially redacted. Deploying the guardrail using AWS CloudFormation StackSets allows the company to centrally manage and consistently deploy the same guardrail configuration across all accounts in the organization, ensuring uniform enforcement.

Option E uses mask filtering, which is better suited for redacting sensitive output rather than preventing prohibited content from being submitted in prompts. Option B attempts to use SCPs alone but does not enforce guardrail deployment or content filtering. Option A incorrectly places guardrail enforcement in permissions boundaries, which are not designed to validate request parameters such as guardrail identifiers.

By combining SCP-based enforcement with centrally deployed Bedrock guardrails , options C and D together provide strong, scalable, and centrally managed controls for both content safety and model governance across the organization.

Option A is the correct solution because Amazon Q Business is explicitly designed to provide secure, governed access to enterprise data while preserving customer ownership and control. Each customer maintains their own Amazon Q Business index, which ensures that data never leaves the customer’s control boundary unless explicitly shared through approved access mechanisms.

By designating Example Corp as a data accessor, customers can allow controlled, auditable access to their indexed content through secure APIs. This model satisfies strict data governance requirements, including data ownership, access transparency, and revocation capability. Customers do not need to expose raw data or deploy infrastructure in Example Corp’s environment.

Amazon Q Business provides high semantic accuracy through managed indexing, ranking, and retrieval optimizations. Because real-time access is not required, this approach avoids the complexity and latency challenges of live federated retrieval while still delivering fast query performance suitable for customer experience use cases.

Option B introduces unnecessary operational complexity by requiring real-time MCP servers per customer. Option C requires customers to manage Amazon Bedrock knowledge bases and enable cross-account access, which increases integration complexity and governance risk. Option D requires shared Amazon Kendra indexes across accounts, which complicates access control and data ownership boundaries.

Therefore, Option A provides the cleanest, lowest-overhead architecture that meets data governance, accuracy, performance, and scalability requirements while minimizing operational burden for both Example Corp and its customers.

Option A is correct because the problem is not total model runtime; the problem is perceived UI responsiveness. AWS documentation states that the Amazon Bedrock InvokeModelWithResponseStream API returns the model response as a stream. AWS also explains that streaming allows an application to access responses in chunks without waiting for the entire result. This lets the frontend display generated content as tokens or chunks arrive, improving the user experience even when the total inference duration remains unchanged.

This option also preserves the stated constraints. It does not require changing the foundation model, increasing token counts, provisioning extra compute, or reducing the model’s actual inference time. Instead, it changes how the response is delivered to the user. This is exactly the right pattern when users perceive slowness because the interface waits for the full completion before rendering anything. AWS examples for Bedrock streaming show applications processing response streams in real time, which supports interactive applications during high-concurrency periods.

The monitoring portion of option A is also aligned with AWS guidance. Amazon Bedrock runtime publishes CloudWatch metrics for invocation volume, latency, token consumption, error rates, and model invocation logging delivery. CloudWatch GenAI observability can track invocation count, token usage, and errors using built-in views. This supports audit and compliance visibility across Regions.

Option B adds caching of partially processed fraud explanations, which can be risky for regulated transaction-specific explanations and does not solve the UI issue for unique requests. Option C changes inputs by condensing them, which violates the constraint not to modify token counts or inputs. Option D focuses on Lambda concurrency and log retention, which does not address waiting for the full model response. Therefore, response streaming with CloudWatch and tracing is the correct solution.

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 requirement explicitly calls for character-by-character streaming, long-running responses, low latency, and massive concurrency, which aligns directly with Amazon Bedrock streaming inference patterns.

Amazon Bedrock provides the InvokeModelWithResponseStream API specifically for streaming partial model outputs as tokens are generated. This enables near-instant feedback to users instead of waiting for the full response to complete, which is essential when responses last up to 45 seconds.

Amazon API Gateway WebSocket APIs are purpose-built for bidirectional, low-latency, server-initiated communication, allowing the backend to push characters or tokens to clients in real time. This eliminates inefficient polling and supports thousands of concurrent open connections.

AWS Lambda integrates natively with WebSocket APIs and scales automatically with connection volume, enabling a fully managed, serverless architecture. This approach maintains security, centralized authentication, throttling, and observability while avoiding direct client access to Bedrock APIs.

Option B introduces polling latency and unnecessary API overhead and does not provide true streaming. Option C violates AWS security best practices by exposing Bedrock directly to clients and does not scale securely. Option D only serves completed responses and cannot meet the real-time streaming requirement.

Therefore, Option A is the only solution that fully satisfies streaming behavior, concurrency, latency, and managed-service constraints.

Option B is the best solution because hierarchical chunking is specifically designed to preserve broader semantic context while still enabling precise retrieval at paragraph or sub-paragraph granularity. The problem described—answers citing irrelevant sections when a query spans multiple paper sections—often occurs when chunks are either too small (losing cross-paragraph context) or too “flat” (retrieving isolated snippets without their surrounding rationale).

In a scientific paper, related information is frequently distributed across methodology, results, and discussion. Flat, fixed-size chunking (Option A) can split these logically connected ideas into separate chunks, causing retrieval to surface fragments that match a term but not the full intent. Semantic chunking (Option C) improves boundary placement, but it does not inherently provide a multi-resolution structure that helps preserve section-level continuity at massive scale.

Hierarchical chunking solves this by creating parent chunks (larger context windows) that capture broader section context and child chunks (smaller units) that retain retrieval precision. When the retriever identifies relevant child chunks, it can also bring in the associated parent context so the foundation model sees the surrounding methodological or discussion framing. The defined overlaps further reduce the risk that key transitions or references are split across chunks.

This approach is well suited for a corpus of 25 million papers because it improves relevance without requiring a custom reranking model or a manual preprocessing pipeline. It remains operationally efficient because it is configured at the knowledge base level rather than implemented through custom code per document.

Option D introduces high operational complexity and inconsistent document handling at scale. Therefore, Option B best meets the requirement to preserve semantic context across related paragraphs and improve citation relevance across scientific paper sections.

Option A best meets the requirements because it directly implements a Retrieval Augmented Generation pattern for conversational recommendations using managed Amazon Bedrock capabilities and a scalable vector store. The company’s source data already resides in Amazon S3, which aligns naturally with Amazon Bedrock Knowledge Bases ingestion workflows. A knowledge base can ingest book text, reviews, and metadata, generate embeddings using a supported embedding model, and persist those vectors in a purpose-built vector backend such as Amazon OpenSearch Service. This enables semantic retrieval that is well suited to conversation-driven intent, where user prompts are often descriptive and do not map cleanly to keyword filters.

The requirement to suggest books based on conversations implies the system must interpret natural language context and retrieve relevant passages, reviews, and metadata to ground the recommendation. Knowledge Bases provide managed orchestration for embedding creation and retrieval, which reduces development effort compared to building custom embedding pipelines. OpenSearch Service provides scalable vector search and k-nearest neighbors style similarity retrieval, which supports low-latency responses when properly indexed and sized.

For scaling to more than 10,000 concurrent users, the API layer design in option A is a common AWS pattern: Amazon API Gateway provides a managed front door with throttling and request handling, while AWS Lambda scales horizontally with demand and can invoke the knowledge base retrieval operations. This separates compute scaling from the vector store scaling and helps keep latency predictable under load.

Option B is not the best choice because DynamoDB is not the standard native vector store target for Amazon Bedrock Knowledge Bases in this context and would introduce additional implementation complexity around vector indexing and similarity search behavior. Option C requires substantial ML lifecycle work, model hosting, tuning, and continuous iteration to achieve quality recommendations at scale. Option D provides strong enterprise search, but it focuses on retrieval and FAQs rather than a managed RAG recommendation workflow grounded in embeddings and conversational context for generative responses.

Option B is the correct solution because Amazon Bedrock Prompt Management is purpose-built to manage, govern, and standardize prompt usage at scale across teams and Regions. It provides native version control, allowing teams to track prompt changes over time and ensure that only approved versions are used in production workflows.

Prompt Management supports approval workflows that align with enterprise governance requirements. Approval permissions can be enforced through IAM policies, ensuring that only authorized reviewers can approve or publish prompt versions. This removes the need for custom workflow engines or external storage systems, significantly reducing operational overhead.

Parameterized prompt templates enable consistent prompt structure while allowing controlled variation through defined variables. This ensures consistent quality standards and reduces prompt drift, which is critical when hundreds of prompts are reused across multiple applications and teams.

AWS CloudTrail integrates natively with Amazon Bedrock to provide immutable audit logs for prompt creation, updates, approvals, and usage. These detailed audit trails satisfy compliance requirements and allow security and governance teams to trace prompt activity across Regions and users.

Option A requires significant custom development to coordinate approvals and maintain state. Option C relies on general-purpose workflow services and manual versioning mechanisms that are error-prone and difficult to scale. Option D uses services not designed for large-scale GenAI prompt governance and introduces unnecessary complexity.

Therefore, Option B best meets the requirements for scalable, auditable, and low-overhead governance of AI-generated content using Amazon Bedrock.

Option D is the best choice because it delivers true semantic search with the smallest operational footprint by combining a fully managed embedding service with an automatically scaling vector-capable database. The university’s requirement is explicitly semantic: the metadata has no keywords, and the system must match abstracts based on similarity of meaning. This is a direct fit for an embeddings-based approach, where each abstract is converted into a vector representation and searched using vector similarity. Amazon Titan Embeddings in Amazon Bedrock provides a managed way to generate these vectors without hosting or maintaining an ML model, eliminating the operational work of model provisioning, patching, scaling, and lifecycle management.

For storage and retrieval, Amazon Aurora PostgreSQL Serverless with the pgvector extension supports vector storage and similarity search while minimizing infrastructure operations. Aurora Serverless reduces capacity planning and scaling tasks because it can automatically adjust to changes in workload, which is valuable for a university search application with variable usage patterns. With fewer than 1 million files, a PostgreSQL-based vector store is commonly operationally simpler than running a dedicated search cluster, while still meeting the requirement to query using both text-derived similarity and associated metadata filters stored alongside the vectors.

Option A can also enable vector search, but operating an OpenSearch domain typically introduces additional concerns such as domain sizing, shard strategy, cluster scaling, and performance tuning for k-NN workloads. Option C increases operational overhead the most because it requires deploying and operating a sentence-transformer model endpoint in SageMaker AI, including scaling, monitoring, and model management. Option B does not meet the semantic similarity requirement reliably because topic extraction is not equivalent to embedding-based semantic matching, especially when the metadata lacks keywords and the system must compare abstracts by meaning.

Therefore, D best satisfies semantic search needs with the least operational overhead.

AWS Glue Data Catalog and its associated crawlers are the standard AWS tools for automatic discovery and centralized cataloging of datasets. For the generated summaries, storing them in Amazon S3 allows the use of object tags for metadata (like source IDs), making them easily queryable. The critical requirement for " tamper-evident, immutable audit logs " is met by enabling Bedrock model invocation logging to an S3 bucket protected by S3 Object Lock (compliance mode). To further guarantee that logs have not been altered, AWS CloudTrail log file integrity validation uses cryptographic hashes to provide non-repudiation and a verifiable audit trail. This combination covers data management, metadata attribution, and high-standard security compliance.

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 best satisfies the requirements while minimizing development effort by combining managed semantic search capabilities with fully managed foundation models. AWS Generative AI guidance describes semantic search as a vector-based retrieval pattern where both documents and user queries are embedded into a shared vector space. Similarity search (such as k-nearest neighbors) then retrieves results based on meaning rather than exact keywords.

Amazon OpenSearch Service natively supports vector indexing and k-NN search at scale. This makes it well suited for large datasets such as 20 million restaurants and 200 million reviews while still achieving sub-second latency for the majority of queries. Because OpenSearch is a distributed, managed service, it automatically scales during peak traffic periods and provides cost-effective performance compared with building and tuning custom vector search pipelines on relational databases.

Using Amazon Bedrock to generate embeddings significantly reduces development complexity. AWS manages the foundation models, eliminates the need for custom model hosting, and ensures consistency by using the same FM for both document embeddings and query embeddings. This aligns directly with AWS-recommended semantic search architectures and removes the need for model lifecycle management.

Hourly updates to restaurant data can be handled efficiently through incremental re-indexing in OpenSearch without disrupting query performance. This approach cleanly separates transactional data storage from search workloads, which is a best practice in AWS architectures.

Option A does not meet the semantic search requirement because keyword-based search cannot reliably interpret complex natural language intent. Option C introduces scalability and performance risks by running large-scale vector similarity searches inside PostgreSQL, which increases operational complexity. Option D adds unnecessary ingestion and abstraction layers intended for retrieval-augmented generation, not high-throughput semantic search.

Therefore, Option B provides the optimal balance of performance, scalability, data freshness, and minimal development effort using AWS Generative AI services.

Option B best fulfills all functional, scalability, and collaboration requirements by combining purpose-built AWS services with Amazon Bedrock capabilities. Amazon Bedrock Data Automation is designed to orchestrate large-scale, multimodal data processing pipelines and integrates naturally with foundation models for summarization and concept extraction. Using BDA to process document files ensures consistent preprocessing and model invocation at scale, which is essential for handling more than 10,000 sources per day with high concurrency.

Integrating Amazon Textract for PDFs enables accurate extraction of structured and unstructured text from scanned and digital documents, while Amazon Transcribe is the appropriate service for converting recorded videos into text for downstream semantic analysis. These services are optimized for their respective media types and feed clean, normalized inputs into Bedrock foundation models, improving the quality of contextual summaries.

Storing processed content in Amazon S3 with versioning enabled directly addresses the requirement for version control. S3 versioning provides immutable object history and rollback capabilities without additional complexity. Metadata storage in Amazon DynamoDB supports high-throughput, low-latency access patterns and scales automatically to handle peak upload concurrency.

Real-time collaboration is achieved through AWS AppSync GraphQL subscriptions combined with DynamoDB. AppSync enables real-time updates to connected clients whenever study materials are created or modified, making it well suited for collaborative editing and live synchronization. DynamoDB streams integrate seamlessly with AppSync to propagate changes efficiently.

The other options misuse services or fail to meet key requirements. Amazon SNS does not support collaborative state synchronization, Amazon DocumentDB is not optimized for versioned document storage, Amazon Neptune is unsuitable for document-centric workloads, and Amazon ElastiCache is not designed for durable storage or version control. Option B aligns with AWS best practices for scalable, multimodal generative AI systems built on Amazon Bedrock.

Option D is the correct solution because it directly addresses all three requirements: high retrieval accuracy, hallucination detection, and reduced human review costs. AWS recommends a layered evaluation strategy for high-stakes domains such as healthcare, where generative outputs must be both accurate and safe.

Using an automated LLM-as-a-judge evaluation enables scalable, consistent assessment of generated responses for factual grounding, relevance, and hallucination risk. This automated screening significantly reduces the number of responses that require manual inspection. Only responses that fall below defined quality thresholds or exhibit ambiguous behavior are escalated to targeted human reviews, which optimizes review effort and cost.

The use of Amazon Bedrock built-in evaluations provides standardized metrics specifically designed for RAG systems, including retrieval precision, faithfulness to source documents, and hallucination rates. These evaluations integrate directly with Amazon Bedrock knowledge bases and models, eliminating the need to build and maintain custom evaluation pipelines.

Option A focuses on entity extraction confidence, which does not reliably detect hallucinations in generative text. Option B requires maintaining and scaling a separate fine-tuned evaluation model, increasing complexity and cost. Option C is useful for regression testing but cannot detect hallucinations in real-world, open-ended clinical queries.

Therefore, Option D provides the most effective and operationally efficient approach to maintaining clinical-grade accuracy while minimizing human review effort.

Option A best meets the combined requirements of low latency, stability, and validated safety controls by using purpose-built Amazon Bedrock features designed for production GenAI operations. The company’s latency target of under 1 second and its observation of degradation during spikes strongly indicate capacity and throughput variability. Provisioned throughput for Amazon Bedrock is intended to deliver more predictable performance by reserving inference capacity for a chosen model, reducing throttling risk and stabilizing response times under load. This directly improves operational consistency across Regions where on-demand capacity can vary.

The requirement to “block unsafe or hallucinated recommendations” is most directly addressed by Amazon Bedrock Guardrails . Guardrails provide managed safety enforcement, including sensitive information controls and configurable content policies. Using semantic denial rules enables the application to prevent unsafe guidance such as dangerous brewing temperatures or other harmful procedural instructions, enforcing safety at the model boundary rather than relying on downstream filtering.

The remaining requirement is “99.5% output consistency for identical inputs.” While generative models can be probabilistic, production systems achieve practical consistency by controlling prompt versions, inputs, and policy behavior. Amazon Bedrock Prompt Management supports controlled prompt lifecycle practices, including versioning and approval workflows, which reduce unintended drift across deployments and Regions. By ensuring the same approved prompt templates and parameters are used consistently, the company can materially improve repeatability for the same structured inputs and retrieval context, which is essential in multi-stage prompt chains.

The other options are incomplete. B improves experimentation and observability but does not enforce safety controls or stabilize latency. C can improve performance, but it does not provide validated safety enforcement at inference time. D can help retrieval relevance, but it does not address unsafe outputs or inference stability. Therefore, A is the only option that simultaneously targets predictable latency, governance of prompt behavior, and strong safety controls within Amazon Bedrock.

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 B is the correct solution because it parallelizes independent foundation model inference tasks while maintaining orchestration, observability, and time-bound execution. AWS Generative AI best practices emphasize reducing end-to-end latency by parallelizing independent inference calls rather than scaling individual calls vertically.

In this scenario, each report requires multiple independent analyses such as financial extraction, sentiment analysis, and compliance validation. These tasks do not depend on each other’s output, making them ideal candidates for parallel execution. AWS Step Functions provides a Parallel state that can invoke multiple AWS Lambda functions simultaneously, drastically reducing total processing time compared to sequential execution.

By invoking Amazon Bedrock from separate Lambda functions in parallel, the system can reduce batch execution time from 45 seconds to well under the 10-second requirement, assuming each inference call remains within acceptable latency bounds. Step Functions also provide built-in error handling, retries, and state tracking, which improves reliability without increasing complexity.

CloudWatch metrics allow teams to monitor both workflow execution time and individual model inference latency, enabling performance tuning and operational visibility. Configuring client-side timeouts ensures that slow or failed model invocations do not block the entire batch.

Option A still processes tasks sequentially and therefore cannot meet the strict latency requirement. Option C introduces queuing delays and sequential processing within each report, which increases total execution time. Option D relies on container-based sequential processing and adds unnecessary operational overhead for a workload that is event-driven and latency-sensitive.

Therefore, Option B best meets the performance, scalability, and operational efficiency requirements for high-speed batch document analysis using Amazon Bedrock.

Option C is the correct solution because it uses Amazon Bedrock cross-Region inference profiles, which are explicitly designed to support regional data residency, private connectivity, and resilience with minimal operational overhead.

By using a Europe-scoped inference profile, the application ensures that all inference requests are routed only within European Regions where the FM is deployed, such as eu-central-1 and eu-west-3. This satisfies data residency requirements while still providing resilience and load distribution across Regions.

Configuring an Amazon Bedrock VPC endpoint ensures that all traffic remains on the AWS private network. No public endpoints are used, which aligns with the company’s private networking requirements.

Extending existing SCPs to allow inference profile usage ensures that employees can access the FM only in approved Regions, maintaining governance across the Control Tower environment.

Options A and B introduce unnecessary custom routing layers and EC2 management. Option D moves away from Amazon Bedrock entirely and increases operational complexity.

Therefore, Option C is the only solution that satisfies private access, regional confinement, governance controls, and low operational overhead.

Option B best meets the requirements because it provides systematic diagnosis, measurable comparison, and historical traceability of prompt performance. By placing prompts under version control and testing them against complex clinical documents, the company can consistently reproduce issues, track regressions, and compare prompt behavior using quantifiable metrics such as factual accuracy, completeness, and consistency. Automated testing ensures scalability and repeatability, while version history preserves prompt evolution over time.

Option A lacks objective metrics and does not address complex documents. Option C focuses on live traffic experimentation but does not inherently diagnose prompt inconsistencies or preserve detailed historical evaluations. Option D adds medical entity analysis but introduces unnecessary service coupling and does not provide robust prompt version history or automated comparative benchmarking. Therefore, Option B is the most complete and disciplined solution.

Option B best meets the latency, resilience, and data residency requirements while keeping operational complexity low by using built-in Amazon Bedrock cross-Region inference behavior through inference profiles . Cross-Region inference profiles are designed to provide higher availability and better traffic absorption when a single Region experiences throttling, transient capacity constraints, or quota-related degradation. By selecting the appropriate geography-scoped inference profile (for example, a Europe-scoped profile for European users and a North America-scoped profile for North American users), the application can keep inference traffic within the required geographic boundary. This directly supports EU data residency needs because European requests can be served only by Europe-based Regions while still benefiting from multi-Region resilience inside Europe.

The question also highlights degradation when Regional traffic spikes hit quotas. Cross-Region inference profiles help mitigate these conditions by allowing Bedrock to serve requests from another Region within the same geography, improving continuity during spikes without requiring the company to implement custom retry-and-failover logic across Regions. This reduces development and operational burden compared to building and maintaining a bespoke routing and fallback system.

Using separate Amazon API Gateway HTTP APIs to direct European and North American users to the correct endpoints simplifies request routing and provides a clean boundary for compliance controls, logging, and monitoring. It also allows each geography to scale independently and maintain consistently low latency by keeping users close to the entry point and the Bedrock geography they must use.

Option A requires custom routing and manual operational monitoring and does not inherently solve quota-driven degradation. Option C adds significant complexity by embedding throttling retries and cross-Region selection logic in Lambda while still needing careful controls to prevent cross-border routing mistakes. Option D introduces the highest operational complexity and can inadvertently violate residency if failover crosses geographies unless additional safeguards are implemented.

Option A best meets the requirements because it applies an AWS-aligned multi-agent pattern that cleanly separates responsibilities: a supervisor agent performs intent classification and orchestration, while specialized collaborator agents handle domain-specific tasks using the right knowledge sources. This structure is well suited for healthcare workflows where clinical questions, scheduling, and insurance processes require different policies, terminology, and data access boundaries.

The requirement for appropriate domain-specific responses is addressed by routing each user query to a department-focused collaborator agent that is grounded with its own department-specific knowledge base . Using Retrieval Augmented Generation with the correct knowledge base improves factual alignment and reduces cross-department leakage (for example, avoiding claims content in a clinical answer). It also supports better prompt grounding and more consistent tone and constraints per department.

The requirement to isolate data maps to using separate knowledge bases per agent and enforcing access through IAM controls , ensuring that each agent can retrieve only from the authorized datasets. This is important for minimizing unintended exposure of sensitive or irrelevant departmental data and supports governance and compliance needs.

For scalability and thousands of parallel interactions , this architecture minimizes contention and bottlenecks. Each collaborator agent can scale independently because requests are distributed across multiple agents and multiple retrieval backends. Operationally, onboarding new features is also simpler: the company can add a new collaborator agent (for example, “billing disputes” or “pharmacy refills”) with its own knowledge base and policies without redesigning the entire assistant.

Option B introduces unnecessary complexity with multiple supervisors and manual handoffs. Option C overloads a single agent with broad instructions and rule-based routing, which increases prompt complexity and reduces maintainability as features grow. Option D creates high operational complexity and risks inconsistent outputs when merging responses from parallel supervisors, and it weakens data isolation by using a shared knowledge base across agents.

Amazon SageMaker Serverless Inference is specifically designed for applications that experience intermittent or bursty traffic. It automatically scales compute capacity based on the number of requests and scales down to zero when there is no traffic, satisfying the requirement to optimize resource usage during low demand. To meet the 500 ms latency requirement during peak periods and avoid " cold start " delays, provisioned concurrency keeps a specified number of execution environments warm and ready to respond immediately. This provides a balance between the cost-effectiveness of serverless and the performance predictability of provisioned instances. Multi-model endpoints (Option A) can introduce " noisy neighbor " issues and latency spikes, while asynchronous inference (Option D) is intended for long-running workloads and cannot meet sub-500 ms requirements.

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 B is the correct solution because it uses native AWS governance, access control, and auditing capabilities to protect PII while enabling controlled FM access to authorized data subsets. AWS Lake Formation is designed specifically to manage fine-grained permissions for data lakes, including column-level access control, which is critical when handling sensitive financial and PII data.

LF-Tags allow data administrators to define scalable, attribute-based access control policies. By tagging databases, tables, and columns with business unit and Region metadata, the company can enforce policies that ensure the foundation model only accesses approved datasets with PII-redacted columns. This eliminates the risk of sensitive data leaking into production inference workflows.

IAM role-based authentication ensures that the FM accesses data using least-privilege credentials. This integrates cleanly with Amazon Bedrock, which supports IAM-based authorization for service-to-service access. AWS CloudTrail provides immutable audit logs for all access attempts, satisfying compliance and regulatory requirements.

Option A introduces unnecessary data duplication and weak governance controls. Option C relies on custom application logic, increasing operational risk and complexity. Option D bypasses Lake Formation’s fine-grained controls and relies on presigned URLs, which reduces governance visibility and control.

Therefore, Option B best meets the requirements for security, compliance, scalability, and auditability when integrating Amazon Bedrock with a Lake Formation–governed data lake.

Option C is the best answer because the scenario is centered on a foundation-model GenAI application that needs explainability, fairness iteration, and responsible AI controls inside an Amazon Bedrock workflow. Amazon Bedrock Agents support tracing, and AWS documentation states that traces can show the agent’s path from user input to response, including action group inputs and outputs, knowledge base queries, and the reasoning the agent uses to decide which action or query to take. AWS also describes trace data as a way to understand how an agent arrived at a response. This directly addresses clinicians’ need to review diagnostic reasoning and decision flow.

Amazon Bedrock Guardrails are also the right service for policy compliance in GenAI applications. AWS documentation states that Guardrails can implement safeguards aligned with responsible AI policies, configure denied topics, filter harmful content, and remove sensitive information. For healthcare and life sciences GenAI use cases, AWS Prescriptive Guidance recommends evaluating bias, fairness, and hallucinations and implementing guardrails to prevent harmful responses. This supports strict governance and privacy-sensitive clinical workflows.

The prompt testing and A/B testing component supports rapid iteration. AWS guidance for generative AI operations recommends prompt template management, creating and testing prompt variants, using A/B testing workflows for prompt variants, and analyzing performance against metrics. This is relevant for testing fairness behavior across demographic prompt sets and clinical scenarios.

Option A includes SageMaker Clarify, which is useful for bias detection and model explainability, but it is less directly aligned to Bedrock-native real-time tracing and policy enforcement for an FM application. Option B handles medical text extraction and terminology but not reasoning transparency or governance. Option D provides operational metrics and custom reports, but not native Bedrock reasoning traces or guardrails. Therefore, option C best meets the GenAI governance requirements.

==========

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.

Option B is the best fit because hierarchical chunking is designed to preserve local detail while keeping broader document context available during retrieval, which directly addresses the problem of questions spanning methodology, results, and discussion. In large scientific papers, a single answer often depends on linked paragraphs across adjacent sections. If the knowledge base retrieves only small, isolated chunks, the RAG system can cite text that is semantically close to a query term but not contextually correct, producing inconsistent answers and irrelevant citations.

With hierarchical chunking, the knowledge base creates child chunks that are small enough for high-precision vector similarity matching, such as 200 tokens, which improves the likelihood that the retrieved text is tightly related to the user’s query. At the same time, each child chunk is associated with a larger parent chunk , such as 1,000 tokens, which retains the surrounding narrative and section-level context. This structure helps the retrieval pipeline return passages that include the relevant subsection plus the explanatory framing that prevents misinterpretation, which is especially important in scientific writing where methods, results, and discussion are interdependent.

The configured overlap further reduces boundary effects where key statements split across chunks. This improves continuity for paragraphs that bridge sections, such as a results paragraph that references the methodological setup or a discussion paragraph interpreting a specific metric.

Option A can improve consistency slightly, but fixed-size chunking still risks separating related paragraphs and does not provide a built-in mechanism to retrieve broader context linked to precise matches. Option C can create more meaningful boundaries, but it does not guarantee the parent-level context that hierarchical chunking provides at retrieval time. Option D increases operational burden and is not practical at the scale of 25 million