AIP-C01 Amazon Web Services AWS Certified Generative AI Developer - Professional Free Practice Exam Questions (2026 Updated)

To achieve the ultra-low latency requirement of less than 500 ms, the system must utilize streaming capabilities at every stage. Using Amazon Transcribe streaming with small (100-ms) audio chunks ensures that transcription begins immediately as the customer speaks. On the model side, Amazon Bedrock’s InvokeModelWithResponseStream allows the application to receive tokens as they are generated, rather than waiting for the entire completion, which is critical for real-time interactions. Amazon DynamoDB is the ideal choice for storing supervisor ratings during a live call because it provides the single-digit millisecond latency required for high-frequency writes without impacting the application ' s performance. Options involving batch processing or SQS queuing are unsuitable for sub-500 ms interactive requirements.

Amazon CloudWatch provides the most integrated path for unifying technical and business metrics. By importing business metrics into CloudWatch (via custom metrics or metric streams), teams can build custom dashboards that provide a single pane of glass for both system health and conversion performance. Composite alarms allow stakeholders to be notified only when multiple conditions are met (e.g., high latency and dropping conversion rates), reducing alert fatigue. Applying anomaly detection to these metrics is essential for GenAI workloads because performance baselines can shift subtly; CloudWatch can automatically detect these deviations and trigger alerts through Amazon SNS . This solution provides comprehensive correlation and automated alerting with less operational complexity than managing external visualization servers (Option B) or multi-service analytics pipelines (Option C).

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 C is correct because Amazon Bedrock agent tracing exposes the internal execution path needed to identify precisely where a multi-step workflow fails. When tracing is enabled for InvokeAgent, the response can include structured trace events. AWS documents OrchestrationTrace for orchestration activity and FailureTrace for the reason a particular step failed. Those records can be aggregated to calculate per-step attempts, successes, failures, and completion rates. Option A monitors broad client/server error metrics; even with custom metrics, it does not inherently provide the same structured execution context. Option B uses CloudTrail, which is primarily an API audit trail rather than a step-by-step agent reasoning trace. Option D requires custom EventBridge instrumentation and storage. Native agent trace data therefore provides the most direct evidence for exact failure-point analysis and detailed workflow completion analytics. AWS Documentation

================

Option B matches the defining requirement: the company, rather than a managed agent harness, must own the orchestration loop . Amazon Bedrock AgentCore Runtime provides a serverless, purpose-built environment for hosting agents and tools while remaining framework agnostic. AWS explicitly supports agents created with frameworks such as LangGraph, Strands, and CrewAI as well as fully custom agents that use no agent framework.

AWS further distinguishes AgentCore Runtime from its managed harness by stating that with Runtime, the customer brings the agent code and “the orchestration loop is yours.” The custom application can therefore implement proprietary tool-selection logic, complex conversation-state transitions, specialized retry algorithms, proprietary telemetry, validation stages, and any other control-flow behavior required by the business. Runtime supplies infrastructure capabilities such as isolation, scaling, sessions, authentication, and observability plumbing rather than taking ownership of the decision loop.

Amazon Bedrock can separately provide managed foundation-model inference, allowing the company to use Bedrock FMs without deploying or operating model-serving infrastructure.

A is incorrect specifically because of its final statement. AgentCore Policy is an authorization mechanism, not an orchestration or retry engine. AWS documents that Policy evaluates Cedar or Dogwood policies to determine whether tool invocations are permitted or forbidden. It can govern which actions are authorized, but it does not implement an agent ' s tool-selection algorithm or failure-retry strategy.

C relinquishes precisely the orchestration control the company requires by depending on managed behavior. D could provide deterministic workflow coordination but places Step Functions outside the agent loop and is cumbersome for highly dynamic multi-turn agent reasoning, proprietary state transitions, and tool-selection decisions.

Therefore, B preserves complete application-level orchestration control while outsourcing scalable runtime infrastructure and foundation-model inference to AWS.

==========

Option A is the best solution because it satisfies streaming, token control, and retry requirements while keeping operational overhead low by using fully managed, serverless AWS services. Amazon API Gateway HTTP APIs provide a lightweight, cost-effective front door for APIs and integrate cleanly with AWS Lambda for request processing and security controls.

AWS Lambda response streaming allows the API to begin returning content to the client as soon as partial model output is available, reducing perceived latency and improving user experience for long responses. Using Lambda as the integration layer also provides a centralized place to enforce token-aware request handling, such as rejecting oversized requests, truncating optional context, or applying consistent limits across users and tenants to manage compute usage.

Retry logic is best handled in the client or integration layer for transient failures such as timeouts and throttling. Lambda can implement controlled retries with exponential backoff and jitter, while API Gateway timeouts help bound request lifetimes and prevent hung connections from consuming resources indefinitely. Because the model service is managed, the company avoids infrastructure management and focuses only on request shaping, safety, and resiliency behavior.

Option B is not suitable because client-side polling is not true streaming, front-end token enforcement is insecure and inconsistent, and API Gateway does not provide model-aware retry behavior on its own. Option C introduces container hosting and scaling complexity, which increases operational overhead compared to serverless. Option D can work, but REST APIs are generally heavier than HTTP APIs for this pattern and do not reduce overhead compared to Option A.

Therefore, Option A provides the required streaming and resiliency capabilities with the least infrastructure management effort.

AWS Glue Data Quality is the correct core service because it directly addresses the distinctive requirements that separate this question from ordinary ETL validation. AWS describes Glue Data Quality as a managed, serverless capability for measuring and monitoring dataset quality. It uses Data Quality Definition Language (DQDL) for rules, can automatically analyze datasets and recommend rules, generates a Data Quality score after rule evaluation, supports machine-learning-based anomaly detection, and integrates with Amazon CloudWatch.

Completeness can be evaluated through DQDL rules such as IsComplete . AWS rule recommendations can automatically generate completeness, uniqueness, value-domain, and column-length rules based on observed data. Anomaly detection learns historical statistics and identifies values outside predicted bounds; AWS can additionally recommend future data-quality rules based on detected anomalies.

Glue Data Quality can publish pass/fail metrics into the Glue Data Quality CloudWatch namespace, making the results usable for monitoring, alarms, and regulatory-quality dashboards.

There is one important technical issue in the wording of option B: AWS Glue Data Quality itself does not remove PII. The complete AWS Glue implementation would pair Glue Data Quality with the AWS Glue Detect PII transform. AWS documents that this transform can identify sensitive entities and then mask, redact, hash, or otherwise process identified PII. Therefore, B is clearly the intended and strongest listed answer, but a production implementation should add the Glue PII transform to fully satisfy the question ' s PII-removal requirement.

A requires extensive custom validation. C does not provide the requested automated rule recommendations and managed quality-score capabilities. D handles PII detection but lacks automated DQDL recommendations, ML anomaly detection, and native data-quality scoring.

==========

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 is the best answer because it implements a decoupled, queue-based moderation pipeline that invokes the expensive model only when the low-latency model is not confident enough. Amazon SQS is designed to decouple distributed application components and support asynchronous processing. AWS documentation describes SQS as a fully managed message queuing service that enables decoupling and scaling of microservices, distributed systems, and serverless applications. This matches the requirement for high resiliency and sudden demand spikes because incoming requests can be buffered in a durable queue rather than overwhelming the model-processing layer.

Using AWS Fargate to process queue messages is also appropriate because Fargate provides serverless container compute for Amazon ECS or Amazon EKS workloads. It allows the company to run scalable processing workers without managing EC2 capacity directly. AWS Prescriptive Guidance includes architectures that use API Gateway, Amazon SQS, and AWS Fargate to process events asynchronously, which supports the same decoupled processing model required in this question.

The two-stage queue design also optimizes cost. The small, low-latency classifier is used first for all requests. Only requests with confidence below 0.65 are placed into the second queue and processed by the larger model. This avoids running the larger model for every moderation request. High-confidence results can be completed quickly by the first-stage processor, while uncertain results are isolated into an asynchronous second-stage workflow.

Option A is incorrect because it synchronously calls the larger model for low-confidence results, which violates the requirement to process low-confidence requests asynchronously. Option B is incorrect because it invokes both models for every request, increasing cost and eliminating the benefit of confidence-based escalation. Option D requires managing EC2 instances and uses keyword heuristics instead of model confidence, so it is less resilient and less aligned with Bedrock-based moderation. Therefore, option C is correct.

The correct combination is A, D, and F because these guardrail features directly map to the stated financial compliance and governance requirements.

Option A is required because denied topics guardrails are explicitly designed to block entire categories of requests, such as requests for guaranteed returns or specific stock recommendations. These are regulatory-sensitive scenarios where partial filtering is insufficient and full blocking is required to prevent violations.

Option D is correct because custom word filters are the appropriate guardrail mechanism to block references to specific competitor names. Content filters are category-based (such as hate, sexual, or violence-related content) and are not suitable for blocking organization-specific competitor references. Custom word filters allow precise blocking at both input and output stages.

Option F is required because a high grounding score threshold enforces that model outputs must be strongly supported by approved source material. This prevents the AI assistant from making speculative or unfounded claims that are not aligned with the company’s approved financial guidance, which is critical in regulated financial environments.

Option B is incorrect because content filters do not target domain-specific financial advice patterns. Option C is incorrect for the same reason—competitor names are not a content filter category. Option E would weaken factual grounding and increase hallucination risk.

Therefore, A, D, and F together provide topic blocking, competitor exclusion, and factual grounding enforcement.

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 D is the intended Bedrock prompt-engineering solution. AWS guidance recommends using output indicators to explicitly describe constraints and characteristics that the model should follow when constructing its response. The prompt should clearly state that the promotional message is mandatory, where it should appear, and how it should be integrated with the surrounding recommendation. This gives the model a stronger output constraint than an indirect instruction embedded elsewhere in a dynamically assembled prompt. Option A uses Guardrails, which are designed to evaluate and constrain unsafe or disallowed content rather than require insertion of specific marketing text. Option B adds unnecessary model calls and still does not enforce the desired response structure. Option C introduces additional AgentCore and reranking processing for a requirement that should be addressed directly through explicit output instructions in the prompt. AWS Documentation

================

Option C combines AWS-native capabilities for the three required monitoring dimensions with minimal custom code. Amazon Bedrock model invocation logging can capture request and response information and deliver invocation data to Amazon S3 or CloudWatch Logs. Bedrock Guardrails contextual grounding checks are specifically designed to detect and filter responses that are not sufficiently grounded in supplied source information; AWS explicitly lists summarization as a supported use case. CloudWatch provides token-usage observability, while anomaly-detection mechanisms can establish adaptive baselines instead of requiring manually maintained static thresholds. This enables earlier detection of unusual consumption and potential cost anomalies. Option A requires custom Athena-based hallucination analysis. Option B relies on evaluation jobs and custom Lambda processing rather than near-real-time managed controls. Option D combines services that do not directly provide the required Bedrock-specific hallucination monitoring. AWS Documentation

================

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

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

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

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

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

For a 3-week proof-of-concept in a regulated field like healthcare, Retrieval Augmented Generation (RAG) is more efficient and safer than fine-tuning. RAG allows the use of anonymized patient records without risking the leak of sensitive data into the model ' s permanent memory. To evaluate accuracy quantitatively and rapidly, the " LLM-as-a-judge " pattern is recommended. Using a strong judge model to score the outputs of multiple candidate FMs provides objective metrics (e.g., factual alignment, completeness) that manual qualitative feedback (Option C) cannot scale to provide within the timeline. Fine-tuning (Option B) typically takes longer than 3 weeks to properly data-prep and validate for clinical accuracy.

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

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

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

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

Option C is the correct solution because it uses a single, well-tuned Amazon Bedrock guardrail that applies different actions to different content types, which is the recommended approach for minimizing false positives while enforcing strong policy controls.

Setting content filters to medium rather than high reduces overblocking of benign customer conversations while still preventing harmful content. Amazon Bedrock guardrails are designed to balance precision and recall, and medium sensitivity is commonly recommended for customer-facing financial services use cases.

Denied topics explicitly prevent the assistant from discussing investment advice, which is a regulatory requirement. Including definitions and sample phrases improves detection accuracy and reduces ambiguity.

Sensitive information filters support different actions per context. Masking PII in responses preserves conversational usefulness for legitimate customer support while preventing exposure of sensitive data. Blocking sensitive financial information in inputs prevents downstream processing of disallowed content before it reaches the foundation model.

Critically, enabling both input and output evaluation ensures that guardrails are applied consistently at every stage of interaction. Custom blocked messages and audit logging provide clear compliance evidence for regulators and internal audits.

Option A causes excessive false positives by blocking all PII outright. Option B introduces unnecessary complexity and is not how Bedrock guardrails are intended to be applied. Option D uses orchestration logic that Bedrock guardrails already handle natively.

Therefore, Option C best satisfies enforcement, flexibility, auditability, and accuracy requirements.

Option C best satisfies the requirement for rapid, correlated detection of model-related performance degradation. Amazon CloudWatch Application Insights provides automated observability across application components running on Amazon EC2, identifying abnormal behavior patterns without requiring extensive manual configuration.

Using custom metrics for recommendation quality, token usage, and response latency allows the company to directly monitor FM behavior, not just infrastructure health. Applying dimensions such as request type and user segment enables fine-grained correlation between performance issues and specific customer interactions or workloads.

CloudWatch anomaly detection is critical because it establishes dynamic baselines from historical data and detects deviations automatically. This enables alerts to be generated within minutes when FM behavior changes unexpectedly, satisfying the 10-minute alerting requirement without static thresholds that can miss subtle degradations.

CloudWatch Logs Insights complements metrics by enabling rapid analysis of log patterns, error messages, or unusual request flows associated with degraded recommendations. Because all data remains within CloudWatch, correlation between metrics, logs, and alerts is straightforward and operationally efficient.

Option A focuses on infrastructure metrics and lacks behavioral baselining. Option B provides tracing but not automated anomaly detection. Option D adds significant operational overhead and ingestion complexity for a use case already well supported by CloudWatch-native features.

Therefore, Option C delivers the most effective, scalable, and low-overhead observability solution for detecting FM-related performance deviations.