Free AIP-C01 Practice Test Questions 2026

C.   Use Amazon CloudWatch Logs to capture model invocation logs. Create CloudWatch metric filters to extract tool-specific invocation patterns. Apply CloudWatch anomaly detection alarms that automatically adjust baselines for each tool’s token metrics.

Explanation:

This question tests your ability to design a dynamic monitoring solution for Amazon Bedrock that pinpoints specific tool integrations causing abnormal token usage. The requirement for automatic threshold adjustment rules out static or manual approaches, making anomaly detection the ideal choice.

✔️ Option C (Correct Option):
This solution fully meets the requirements. Using CloudWatch Logs captures the necessary Bedrock invocation data. Metric filters extract tool-specific patterns, and CloudWatch anomaly detection employs machine learning to establish dynamic baselines. This automatically adjusts thresholds as traffic patterns evolve, eliminating the need for manual intervention and enabling you to identify which specific tools are causing the surges.

❌ Option A (Incorrect Option):
This option fails because it uses static, fixed thresholds. These would not adapt to changing traffic patterns, making them ineffective for detecting unusual behavior in a dynamic environment. Without automatic adjustment, the alarms would either generate false positives or miss genuine anomalies as usage patterns shift.

❌ Option B (Incorrect Option):
While this provides a method for analyzing historical logs, it is a reactive, batch analysis. AWS Glue and Athena are designed for data warehousing and analytics, not real-time detection. It does not provide the immediate detection and automatic threshold adjustment required by the scenario.

❌ Option D (Incorrect Option):
This approach relies on manual updates to alarm thresholds based on Lambda processing. While Lambda offers real-time log processing, the requirement is to automatically adjust thresholds. Relying on manual trends analysis makes it labor-intensive, error-prone, and incapable of adapting autonomously to traffic fluctuations.

🔧 Reference:
→ Amazon CloudWatch: Model Invocations. Confirms enabling Bedrock invocation logging to CloudWatch for detailed metrics like InputTokenCount.

→ AWS re:Post: Check the number of tokens in Amazon Bedrock . Confirms that enabling logging to CloudWatch allows you to view inputTokens and outputTokens for each model invocation, which is essential for creating metric filters.

C.   Create an Amazon Bedrock knowledge base. Implement Retrieval Augmented Generation RAG. Set the PerformanceConfigLatency parameter to optimized.

Explanation:

This question tests your understanding of combining context grounding with latency optimization in Amazon Bedrock applications. It addresses the challenges of model hallucinations (recommending unlisted items) and high operational latency when handling highly unique, uncacheable user interactions.

✅ Correct Option:

Option C
Creating an Amazon Bedrock knowledge base using Retrieval Augmented Generation (RAG) directly addresses relevance and availability issues by grounding Anthropic Claude's responses using verified data from the company's product catalog. Furthermore, setting the PerformanceConfigLatency parameter to optimized reduces processing delays by utilizing low-latency model configurations. This cleanly solves the latency bottleneck for unique customer interactions without requiring complex custom validation layers.

❌ Incorrect options:

Option A
Increasing grounding within Bedrock Guardrails detects misalignments but does not supply the live catalog data needed to generate accurate recommendations. While provisioned throughput handles heavy traffic spikes, it does not dynamically optimize standard inference latency for individual unique queries.

Option B
Prompt engineering can guide behavior but cannot reliably prevent hallucinations or ensure absolute alignment with a constantly changing product catalog. Streaming via InvokeModelWithResponseStream merely alters perceived performance for users rather than reducing the actual processing overhead.

Option D
Validating recommendations against OpenSearch Service and implementing response caching adds heavy operational complexity. Because the customer interactions are primarily unique, a DynamoDB response caching layer provides minimal performance benefits since very few query results can be reused.

🔧 Reference:
→ AWS Documentation: Knowledge bases for Amazon Bedrock confirms that RAG allows foundation models to securely access verified catalog data to ground responses and prevent hallucinations.

→ AWS Documentation: Optimize model invocation latency confirms how adjusting performance configuration parameters can prioritize lower latency during foundation model inference.

D.   Use the latest Amazon reranker model through the reranking configuration within Amazon Bedrock Knowledge Bases. Use the model to improve document relevance scoring and to reorder results based on contextual assessments.

Explanation:

The issue is poor retrieval quality in a large RAG system (50,000+ documents), where semantically similar but contextually wrong documents are being returned. This leads to hallucinations and incorrect outputs. The requirement is to improve retrieval relevance with minimum operational overhead, meaning native Bedrock features should be preferred over custom pipelines or external services.

🟢 Correct Option:

D. Use the latest Amazon reranker model through the reranking configuration within Amazon Bedrock Knowledge Bases. Use the model to improve document relevance scoring and to reorder results based on contextual assessments.
This option is correct because Bedrock Knowledge Bases now support built-in reranking models that improve retrieval quality without requiring external infrastructure. The reranker evaluates retrieved chunks and reorders them based on contextual relevance to the query. This directly reduces irrelevant document injection, lowers hallucination risk, and requires minimal operational effort since it is fully managed within Bedrock.

🔴 Incorrect options:

A. Deploy an Amazon SageMaker endpoint to run a fine-tuned ranking model. Use an Amazon API Gateway REST API to route requests. Configure the application to make requests through the REST API to rerank the results.
This introduces significant operational overhead, including model hosting, scaling, and API management. While it can improve ranking, it is not a managed or integrated Bedrock-native solution and violates the requirement for minimal operational effort.

B. Use Amazon Comprehend to classify documents and apply relevance scores. Integrate the RAG application’s reranking process with Amazon Textract to run document analysis. Use Amazon Neptune to perform graph-based relevance calculations.
This is overly complex and unrelated to efficient RAG reranking. It introduces multiple services (Comprehend, Textract, Neptune) that add latency, cost, and operational burden without directly solving embedding-level retrieval relevance issues.

C. Implement a retrieval pipeline that uses the Amazon Bedrock Knowledge Bases Retrieve API to perform initial document retrieval. Call the Amazon Bedrock Rerank API to rerank the results. Invoke the InvokeModelWithResponseStream operation to generate responses.
While conceptually correct in separating retrieval, reranking, and generation, it still introduces additional orchestration complexity compared to using built-in Knowledge Base reranking configuration. It requires managing multiple API calls and pipeline logic, increasing operational overhead.

🔧 Reference:
⇒ Amazon Bedrock Knowledge Bases Reranking Documentation
Explains how Bedrock Knowledge Bases use reranking models to improve document relevance by reordering retrieved results based on contextual understanding, reducing irrelevant outputs in RAG applications.

C.   Enable invocation logging in Amazon Bedrock. Monitor key metrics such as Invocations, InputTokenCount, OutputTokenCount, and InvocationThrottles. Distribute traffic across cross-Region inference endpoints.

Explanation:

This question tests the ability to resolve throttling issues in a serverless, globally distributed application using Amazon Bedrock without incurring fixed hourly costs. The solution must handle time-zone-based peak traffic gracefully while maintaining performance quality and avoiding reserved capacity pricing.

✅ Correct Option — C:
Enabling invocation logging and monitoring throttle-specific metrics like InvocationThrottles gives precise visibility into when and where limits are being hit. Cross-Region inference endpoints distribute the load across AWS Regions, naturally absorbing time-zone-based traffic spikes. This approach requires no provisioned throughput, so no fixed hourly cost is incurred during low-traffic periods — fully meeting all stated requirements.

❌ Incorrect Options:

A. Provisioned throughput with CloudWatch metrics:
Provisioned throughput in Amazon Bedrock carries a fixed hourly cost regardless of usage. While it does reduce throttling, it directly violates the requirement to avoid fixed costs during low-traffic periods. CloudWatch metrics alone do not resolve cross-region demand distribution needs.

B. Failover to a backup Region based on error thresholds:
Redirecting traffic only after errors exceed a threshold introduces latency and brief service disruptions before failover triggers. This reactive approach does not proactively prevent throttling and may degrade user experience during the switchover window, failing the continuous operation requirement.

D. Distributing traffic across multiple model versions:
Multiple versions of the same model within a single Region share the same regional quota limits. This does not reduce throttling caused by regional capacity constraints. Additionally, the monitored metrics — InvocationLatency and InvocationClientErrors — do not directly target throttling visibility or prevention.

🔧 Reference:
⇒ Amazon Bedrock Cross-Region Inference → Confirms how cross-Region inference endpoints distribute model invocation traffic to reduce throttling without provisioned capacity.

⇒ Amazon Bedrock Monitoring with CloudWatch → Confirms InvocationThrottles and related metrics available for tracking and diagnosing throttling in Bedrock-based applications.

A.   Isolate data for each agent by using separate knowledge bases. Use IAM filtering to control access to each knowledge base. Deploy a supervisor agent to perform natural language intent classification on patient inquiries. Configure the supervisor agent to route queries to specialized collaborator agents to respond to department-specific queries. Configure each specialized collaborator agent to use Retrieval Augmented Generation (RAG) with the agent’s department-specific knowledge base.

Explanation:

This question tests your understanding of multi-agent collaboration in Amazon Bedrock for a domain-specific, high-scale healthcare application. The ideal solution employs a supervisor-routing pattern that classifies intent and distributes queries to specialized agents, each with its own isolated knowledge base. This ensures scalability, department-specific accuracy, domain isolation, and easy feature onboarding for thousands of concurrent patient interactions.

✔️ Option A (Correct Option):
This architecture is the standard best practice for multi-agent systems in Amazon Bedrock . A supervisor agent performs natural language intent classification to route queries correctly, while collaborator agents handle department-specific responses using their own knowledge bases. Separate knowledge bases per department ensure data isolation and domain accuracy, and IAM filtering enforces secure access control . This design scales horizontally for thousands of parallel interactions and allows new features to be onboarded by adding new agents without disrupting existing ones .

❌ Option B (Incorrect Option):
This approach is flawed because multiple supervisor agents create unnecessary complexity and redundancy in intent classification across departments. Manual handoff processes between supervisor agents introduce latency, potential errors, and violate the real-time responsiveness requirement . This architecture also makes it difficult to scale and maintain consistent routing logic across departments.

❌ Option C (Incorrect Option):
A single general-purpose agent with rule-based routing and action groups does not scale effectively for thousands of interactions. It creates a single point of contention and tightly couples departmental logic, making it difficult to onboard new features . Multiple action groups within one agent also lack the isolation and specialized processing capabilities that a true multi-agent architecture provides for domain-specific responses.

❌ Option D (Incorrect Option):
Multiple independent supervisor agents running in parallel create duplicated effort, require complex external routing logic to merge responses, and introduce response conflicts . Using the same knowledge base for all departments violates the requirement for domain-specific responses and creates data leakage and security risks . This architecture does not scale efficiently and complicates maintenance.

🔧 Reference:
→ Amazon Bedrock Documentation: Supervisor routing in Bedrock Agents. Confirms the use of a supervisor agent for intent classification and routing to collaborator agents.

→ Amazon Bedrock Documentation: Multi-agent collaboration. Confirms that separate knowledge bases per agent and IAM filtering are recommended for domain-specific responses and secure data access.

B.   Configure the AWS SDK with standard retry mode and exponential backoff with jitter. Use AWS X-Ray tracing with annotations to identify and filter service components.

Explanation:

This question tests your knowledge of resilience patterns and observability mechanisms when managing Amazon Bedrock API throttling. It requires a client-side retry strategy that avoids overwhelming foundation models during traffic spikes, paired with end-to-end distributed tracing to correlate specific FM attributes with latency and performance issues.

✅ Correct Option:

Option B
Configuring the AWS SDK with standard retry mode alongside exponential backoff and jitter progressively spaces out retries and randomizes delays. This successfully prevents a "thundering herd" effect and curbs cascading failures during peak throttling events. Concurrently, implementing AWS X-Ray provides end-to-end distributed tracing across microservice boundaries, while X-Ray annotations permit adding custom key-value pairs (like specific FM names or model IDs) to index, filter, and correlate performance bottlenecks.

❌ Incorrect options:

Option A
Implementing a custom retry mechanism with a fixed 1-second delay can amplify the problem. Without exponential backoff or jitter, all throttled client requests will repeatedly crash back into the Bedrock endpoint simultaneously, sustaining the bottleneck. Furthermore, standard CloudWatch alarms monitor aggregate metrics but cannot track requests across complex distributed service boundaries.

Option C
Client-side caching is ineffective for dynamic or unique generative AI responses where customer queries vary wildly. While custom logging captures timing locally within application boundaries, it fails to provide the true end-to-end distributed tracing needed to comprehensively map downstream bottlenecks and latency contributors across various external service integrations.

Option D
Although adaptive retry mode dynamically checks token bucket capacities, combining it with AWS CloudTrail is incorrect for this scenario. CloudTrail acts as an API auditing and compliance service rather than a distributed tracing tool. It cannot analyze end-to-end application latency or allow custom indexing to isolate specific FM performance characteristics.

🔧 Reference:
→ AWS Documentation: Timeouts, retries, and backoff with jitter confirms that exponential backoff with jitter is the standard best practice for mitigating cascading throttling failures in AWS services.

→ AWS Documentation: What is AWS X-Ray? confirms that X-Ray traces requests across service boundaries and uses annotations to allow the indexing and filtering of specific system characteristics.

B.   Use CloudWatch Logs Insights to analyze Amazon Bedrock invocation logs for token consumption patterns and usage attribution by application. Create custom queries to identify high-usage scenarios. Add log widgets to dashboards to enable continuous monitoring.

C.   Create custom Amazon CloudWatch dashboards that combine native Amazon Bedrock token and invocation CloudWatch metrics. Set up CloudWatch alarms to monitor token usage thresholds.

Explanation:

This question tests the ability to design a comprehensive observability solution for multi-model, multi-application Amazon Bedrock deployments with the least operational overhead. The solution must deliver real-time token visibility, support custom dashboards for varied stakeholder groups, and provide alerting — all without building or managing additional infrastructure.

✅ Correct Option — B:
CloudWatch Logs Insights enables deep analysis of Bedrock invocation logs, surfacing token consumption patterns and per-application attribution through custom queries. Log widgets can be embedded directly into CloudWatch dashboards for continuous, real-time monitoring. This approach requires no additional services, integrations, or ETL pipelines, making it operationally lightweight while addressing multi-model observability needs comprehensively.

✅ Correct Option — C:
Native Amazon Bedrock CloudWatch metrics such as InputTokenCount and OutputTokenCount provide out-of-the-box token tracking across all foundation models. Custom CloudWatch dashboards allow tailored views for different stakeholder groups, while CloudWatch Alarms deliver threshold-based alerting with no additional tooling. Together, these features satisfy all requirements using fully managed, natively integrated AWS capabilities with minimal setup overhead.

❌ Incorrect Options:

A. QuickSight dashboards using CloudWatch metrics as data source:
While QuickSight supports rich visualizations, connecting it to CloudWatch requires additional configuration and data source management. QuickSight also does not natively support real-time alerting on token thresholds, adding operational complexity compared to a native CloudWatch-only solution.

D. Bedrock zero-ETL integration with Amazon Managed Grafana:
There is no native zero-ETL integration between Amazon Bedrock and Amazon Managed Grafana. This option introduces unverified architectural assumptions. Grafana also requires additional workspace management and data source configuration, increasing operational overhead beyond what CloudWatch natively provides.

E. EventBridge → Firehose → OpenSearch Serverless pipeline:
This architecture involves multiple managed services — EventBridge, Firehose, and OpenSearch Serverless — each requiring individual configuration, monitoring, and maintenance. While powerful, this introduces significant operational overhead that contradicts the least-overhead requirement, especially when CloudWatch already natively supports Bedrock metrics and dashboards.

🔧 Reference:
⇒ Monitor Amazon Bedrock with Amazon CloudWatch → Confirms native Bedrock metrics including InputTokenCount and OutputTokenCount available in CloudWatch for alarms and dashboards.

⇒ Amazon CloudWatch Logs Insights → Confirms query-based analysis of Bedrock invocation logs with support for log widgets in custom CloudWatch dashboards.

B.   Use Amazon Bedrock intelligent prompt routing to automatically analyze inquiries. Route simple product inquiries to smaller models and route complex return policy inquiries to more capable larger models.

Explanation:

This question tests your ability to implement a cost-effective model selection framework that routes customer inquiries based on complexity while maintaining high satisfaction and minimizing latency. Intelligent Prompt Routing is a fully managed feature that automatically analyzes each prompt and routes it to the optimal model within the same model family . This approach requires the least implementation effort compared to building custom orchestration logic that can take months of engineering effort .

✔️ Option B (Correct Option):
Amazon Bedrock Intelligent Prompt Routing provides a single serverless endpoint that predicts the performance of each model for each request and dynamically routes to the model most likely to give the desired response at the lowest cost . It can route simple product inquiries to smaller, cost-effective models like Claude Haiku and complex policy questions to more capable models like Claude Sonnet, achieving up to 30% cost reduction without compromising accuracy . This solution requires no custom orchestration code, saving months of development effort . Each request is fully traceable, enabling easy debugging and monitoring .

❌ Option A (Incorrect Option):
This approach requires building a multi-stage custom classification and routing architecture using AWS Lambda. Developing and maintaining the classification logic, handling errors, and managing the routing workflow involves significant implementation effort. In contrast, Intelligent Prompt Routing provides the same functionality as a managed service with zero custom code . This option does not meet the "least implementation effort" requirement.

❌ Option C (Incorrect Option):
Using a single mid-sized model for all inquiries fails to optimize cost effectively. Simple product questions (70% of traffic) would be processed by a more expensive model than necessary. While simpler to implement, this approach does not meet the cost-effectiveness requirement. Benchmarking shows that choosing the right model for each task is a cost decision with 10-60x variance between model tiers .

❌ Option D (Incorrect Option):
Building separate endpoints with keyword-based routing is labor-intensive and less accurate than managed routing. Keyword detection cannot reliably distinguish between simple and complex inquiries, leading to misrouting. This custom approach requires ongoing maintenance of keyword lists and routing rules, whereas Intelligent Prompt Routing dynamically predicts performance for each request based on the actual prompt content .

🔧 Reference:
→ Amazon Bedrock Documentation: Understanding Intelligent Prompt Routing. Confirms that intelligent prompt routing provides a single serverless endpoint for routing requests between models to optimize response quality and cost, with zero custom orchestration logic required.

→ Amazon Bedrock Documentation: Intelligent Prompt Routing Benefits. Confirms cost reduction of up to 30% and explains the automatic routing mechanism that predicts model performance for each request.

A.   Configure Amazon Bedrock guardrails to apply custom content filters and toxicity detection. Use Amazon Bedrock Model Evaluation to detect hallucinations. Store promptresponse pairs in Amazon DynamoDB to capture audit trails and set a TTL. Integrate Amazon CloudWatch custom metrics with the existing compliance dashboard.

Explanation:

This question evaluates your ability to architect a highly secure, regulated, and compliant Generative AI application under tight timeline (60 days) and hard real-time latency (<200 ms) constraints. It requires balancing managed guardrails, low-latency database storage for auditing, and frictionless integration with existing corporate compliance dashboards.

✅ Correct Option:

Option A
This architecture natively satisfies the strict sub-200 ms response window by avoiding heavy runtime layers like multi-turn agents or live vector database lookups. Amazon Bedrock Guardrails provides low-latency content filtration and safety controls, while Amazon DynamoDB delivers rapid single-digit millisecond performance for tracking prompt-response pairs. Finally, publishing custom metrics to Amazon CloudWatch provides immediate, out-of-the-box integration capabilities to feed tracking data straight into the company's existing compliance dashboard.

❌ Incorrect options:

Option B
Using AWS Lambda functions to execute custom prompt validation routines and text parsing adds unnecessary cold starts and operational latency that can easily breach the 200 ms response budget. Additionally, relying on standard CloudWatch dashboards for reporting fails the core requirement to feed model behavior and compliance tracking data back into the company’s preexisting compliance dashboard.

Option C
Deploying Amazon Bedrock Agents alongside an Amazon Bedrock Knowledge Base (RAG workflow) introduces heavy multi-step pipeline latency that makes achieving a 200 ms response threshold computationally impossible. Furthermore, creating new Amazon QuickSight visual reports bypasses and violates the strict constraint to integrate data into the organization's current, established compliance infrastructure.

Option D
Leveraging Amazon SageMaker Model Monitor and AWS WAF to filter model inputs or monitor text drift introduces immense architectural friction, configuration complexity, and operational overhead. Managing standalone SageMaker instances, custom HTTP APIs inside Amazon API Gateway, and structural schemas within relational Amazon RDS instances makes hitting the 60-day deployment target highly unrealistic.

🔧 Reference:
→ AWS Documentation: Guardrails for Amazon Bedrock confirms that native Bedrock guardrails apply automated content filtering, toxicity blocks, and safety controls directly at the model interface level with minimal latency overhead.

→ AWS Documentation: Amazon DynamoDB Performance confirms that DynamoDB provides consistent, single-digit millisecond latency required for building high-throughput auditing mechanisms.

B.   Use Amazon OpenSearch Service to deploy a hybrid search architecture that combines vector search with keyword search. Apply an Amazon Bedrock reranker model to optimize result relevance.

Explanation:

The requirement is high-precision legal retrieval with:

semantic understanding of legal concepts and citations
keyword accuracy for legal terminology
fast and relevant retrieval
ranking optimization for relevance

Legal search is a classic case where hybrid retrieval + reranking is required, not just vector search or post-processing.

🟢 Correct Option:

B. Use Amazon OpenSearch Service to deploy a hybrid search architecture that combines vector search with keyword search. Apply an Amazon Bedrock reranker model to optimize result relevance.
This option is correct because hybrid search combines semantic vector search (for conceptual similarity in legal meanings) with keyword search (for exact legal citations and terminology). This is critical for legal domains where exact phrasing matters. The Bedrock reranker further refines results by evaluating contextual relevance, ensuring the most legally accurate and precise documents are prioritized for generation.

🔴 Incorrect options:

A. Configure an Amazon Bedrock knowledge base to use a default vector search configuration. Use Amazon Bedrock to expand queries to improve retrieval for legal documents based on specific terminology and citations.
Vector-only search is insufficient for legal workloads because it may miss exact citations and precise legal phrasing. Query expansion also increases noise and does not guarantee citation-level accuracy required in legal research.

C. Enable the Amazon Kendra query suggestion feature for end users. Use Amazon Bedrock to perform post-processing of search results to identify semantic similarity in the documents and to produce precise results.
Kendra query suggestions improve user input, not retrieval quality at scale. Post-processing with Bedrock is inefficient and does not fix the core retrieval problem. It adds latency and still risks retrieving irrelevant legal documents.

D. Use Amazon OpenSearch Service with vector search and Amazon Bedrock Titan Embeddings to index and search legal documents. Use custom AWS Lambda functions to merge results with keyword-based filters that are stored in an Amazon RDS database.
While partially correct (vector + keyword idea), this is overly complex. Using Lambda + RDS for merging adds unnecessary operational overhead and latency. It also lacks a proper reranking mechanism, which is essential for legal precision.

🔧 Reference:
⇒ What is Amazon OpenSearch Service?
Explains how hybrid search combines vector and keyword search to improve relevance for complex retrieval workloads such as semantic + exact-match queries.

C.   Create one AWS CDK application. Configure the application to invoke the Amazon Bedrock FMs by using the aws_bedrock.FoundationModel.fromFoundationModelId() method. Create a pipeline in AWS CodePipeline that has a deployment stage for each environment that uses AWS CodeBuild deploy actions.

Explanation:

This question tests the ability to design a flexible, maintainable CI/CD deployment architecture for a multi-environment Amazon Bedrock application. The solution must allow product owners to easily switch between foundation models in both development and production environments without incurring fixed costs or duplicating infrastructure management efforts.

✅ Correct Option — C:
A single AWS CDK application with environment-specific deployment stages in one CodePipeline provides a unified, maintainable codebase. Using fromFoundationModelId() allows dynamic FM selection by simply updating the model ID parameter per environment, making FM switching straightforward for product owners without infrastructure changes. CodeBuild deploy actions handle environment-specific deployments cleanly, satisfying both flexibility and operational simplicity requirements across dev and production.

❌ Incorrect Options:

A. Multiple CodePipeline pipelines with per-pipeline FM settings using ProvisionedModel ARN:
Using fromProvisionedModelArn() ties each deployment to a specific provisioned model, which carries a fixed hourly cost and reduces flexibility for testing multiple FMs. Managing separate pipelines per FM configuration also increases operational overhead and complicates the switching process for product owners significantly.

B. Separate CDK applications per environment with FoundationModel method:
While fromFoundationModelId() is the correct invocation method, creating entirely separate CDK applications per environment duplicates infrastructure code and increases maintenance burden. Any FM configuration change must be replicated manually across applications, reducing agility and introducing risk of environment drift over time.

D. Production-only CDK application with manual dev environment recreation:
Manually recreating development environment resources from production code eliminates infrastructure consistency and introduces significant operational risk. Using fromProvisionedModelArn() also locks the solution into provisioned throughput pricing, conflicting with the need for flexible, low-overhead FM switching during testing phases.

🔧 Reference:
⇒ AWS CDK Amazon Bedrock Module — FoundationModel → Confirms fromFoundationModelId() as the correct method for dynamically referencing foundation models by ID without provisioned throughput commitment.

⇒ AWS CodePipeline Multi-Environment Deployments → Confirms the pattern of using a single pipeline with multiple deployment stages to manage dev and production environments from one unified pipeline.

D.   Implement a data processing pipeline that uses AWS Step Functions to orchestrate a workload that uses Amazon Comprehend to detect PII and Amazon Bedrock to generate embeddings. Directly integrate the workflow with Amazon OpenSearch Serverless to store vectors and provide similarity search capabilities.

Explanation:

This question tests your ability to design a cost-effective, time-bound data processing pipeline for a RAG application. The key requirements are processing 50GB of JSON data, removing PII, generating embeddings, and completing within 4 hours with minimal operational overhead. The optimal solution leverages serverless, managed AWS services that scale automatically and require minimal custom code.

✔️ Option D (Correct Option):
This is the most efficient solution because it uses AWS Step Functions with its Distributed Map state, which can automatically scan millions of S3 objects and run up to 10,000 parallel workflows . This makes processing 50GB of data within a 4-hour window straightforward. Amazon Comprehend provides managed PII detection with 2–3x higher accuracy than regex patterns . Amazon Bedrock offers cost-effective embeddings through services like Amazon Titan Text Embeddings . Direct integration with Amazon OpenSearch Serverless eliminates the need for custom vector storage code , significantly reducing operational overhead.

❌ Option A (Incorrect Option):
AWS Lambda has a 15-minute execution timeout limit, making it unsuitable for processing large volumes of data without complex orchestration. Additionally, Lambda's concurrency limits and API rate limiting would require custom handling, increasing operational overhead significantly . Managing 50GB of data with Lambda alone would require extensive code for timeout handling and error recovery.

❌ Option B (Incorrect Option):
While AWS Glue ETL jobs can detect PII, using SageMaker Processing with HuggingFaceProcessor for embeddings requires managing custom infrastructure and pre-trained models. This approach involves more operational overhead than using Bedrock's managed embedding APIs. The solution also lacks the orchestration capabilities needed to efficiently process 50GB of data within the time constraint.

❌ Option C (Incorrect Option):
Deploying an Amazon EMR cluster introduces significant operational overhead for cluster management, scaling, and maintenance. Using Aurora PostgreSQL with pgvector requires managing database infrastructure and provides less optimized vector search compared to OpenSearch Serverless. This solution requires the most manual effort and infrastructure management.

🔧 Reference:
→ AWS Prescriptive Guidance: Agentic AI Workflows on Serverless. Confirms Step Functions' Distributed Map state can run up to 10,000 parallel workflows and automatically scale with data volume.

→ AWS Glue Documentation: AWS Glue Studio PII Detection. Confirms Glue's built-in Detect PII transform can identify and redact sensitive fields.