Amazon Practice Questions, Discussions & Exam Topics by our Authors
A company uses an Amazon Redshift cluster as a data warehouse that is shared across two departments. To comply with a security policy, each department must have unique access permissions.
Department A must have access to tables and views for Department A. Department B must have access to tables and views for Department B.
The company often ru...
Let's analyze each option against the requirements and key factors:
---
Requirements Recap:
Two departments (A and B) share the Redshift cluster.
Each department must have unique access permissions to their own tables and views.
Queries often access objects from both departments simultaneously.
The solution must have least operational overhead.
Permissions must be manageable and enforce separation.
---
Option A: Group tables and views into dedicated schemas per department and manage permissions at schema level
Pros:
Schemas in Redshift are designed for logical grouping and access control.
Permissions can be granted or revoked easily on a per-schema basis.
Allows users to access objects across multiple schemas in a single query without switching databases.
Least overhead as you manage permissions once per schema.
Cons:
Requires creating and maintaining schemas, but this is lightweight and standard practice.
Fits well when:
You want department-level logical separation.
Queries need to join or access data from both departments in one query.
Operational simplicity in permission management is key.
---
Option B: Group tables and views into dedicated databases per department and manage permissions at database level
Pros:
Strong isolation between departments at database level.
Cons:
Redshift does not support cross-database queries natively (unlike some other databases).
Users cannot easily run queries joining objects from both departments if they are in separate databases.
Operational overhead is high because managing multiple databases is more complex.
Fits well when:
Departments require strict physical separation and no cross-access is needed.
No cross-database queries ...
Author: Sam · Last updated Jul 10, 2026
A company wants to ingest streaming data into an Amazon Redshift data warehouse from an Amazon Managed Streaming for Apache Kafka (Amazon MSK) cluster. A data engineer needs to develop a solution that provides low data access time and that opt...
Let's analyze each option based on low data access latency, optimized storage costs, and least operational overhead for streaming data ingestion from Amazon MSK to Amazon Redshift:
---
Option A:
Create an external schema that maps to the MSK cluster. Create a materialized view referencing the external schema to consume streaming data from MSK topic.
Feasibility:
Redshift external schemas typically map to data catalogs like AWS Glue for querying external data in S3 via Redshift Spectrum, or to federated query sources via Redshift Federated Query.
There is no direct external schema mapping to an MSK cluster. Redshift cannot directly query Kafka topics via external schema.
Operational overhead:
Complex or unsupported, likely not possible natively.
Latency and storage:
Even if somehow possible, materialized views require refreshes which can add latency.
Conclusion:
Rejected due to lack of direct support for MSK as an external schema source and likely high complexity.
---
Option B:
Develop an AWS Glue streaming ETL job to process incoming data from MSK, load into Amazon S3, then use Redshift Spectrum to read data from S3.
Feasibility:
Glue Streaming ETL supports consuming from MSK and writing to S3 in near real-time.
Redshift Spectrum allows querying data directly from S3 without loading it into Redshift tables.
Latency:
Near real-time ingestion, but some delay due to Glue streaming and S3 eventual consistency.
Query latency depends on the size and format of data in S3.
Storage optimization:
Data stored in cost-effective S3.
No need to load all data into Redshift storage, saving storage costs.
Operational overhead:
Glue manages scaling and streaming, reducing overhead.
No manual ingestion pipelines needed.
Conclusion:
Meets low data access time (near real-time), cost-optimized storage (S3), and least...
Author: Liam · Last updated Jul 10, 2026
A sales company uses AWS Glue ETL to collect, process, and ingest data into an Amazon S3 bucket. The AWS Glue pipeline creates a new file in the S3 bucket every hour. File sizes vary from 200 KB to 300 KB. The company wants to build a sales prediction model by using data from the previous 5 years. The historic data includes 44,000 files.
The company builds a second AWS Glue ETL pipeline by using the smallest worker type. The second pipeline retrieves the historic files from the S3 bucket and processes the files for downstream ...
Let's analyze the problem and each option carefully.
---
Problem summary:
A sales company runs an AWS Glue ETL pipeline creating small files (\~200-300 KB) every hour.
The historical dataset includes 44,000 small files over 5 years.
The second AWS Glue ETL pipeline uses the smallest worker type to process these many small files.
The second pipeline faces significant performance issues.
The company wants to improve performance in a cost-effective manner.
---
Key factors:
Small files: 200-300 KB is quite small, which leads to overhead in processing many small files.
Large number of files: 44,000 files is a lot of individual files to process.
Worker type currently smallest, which may not be powerful enough.
Cost-effectiveness is important.
The performance bottleneck is probably due to overhead in managing too many small files, or under-provisioned compute resources.
---
Evaluation of options:
---
A) Use a larger worker type.
Larger worker types provide more compute power per worker.
This can improve performance per worker because bigger workers have more CPU and memory.
However, larger worker types cost more per hour.
Given that many small files incur overhead, the bottleneck might not just be raw compute power but inefficient processing of many small files.
Using a larger worker type might improve speed but may not be the most cost-effective since cost scales up quickly.
This is a straightforward solution, but not necessarily the most cost-effective.
Use case: When CPU or memory is clearly a bottleneck and processing each file is CPU-intensive.
---
B) Increase the number of workers in the AWS Glue ETL jobs.
Adding more workers horizontally scales the job.
More workers allow more parallel processing of files, especially helpful when you have many small files.
With more parallelism, many small files can be processed simultaneously.
This can greatly improve performance.
Cost increases with more workers but this is linear and can be optimized by balancing number of workers vs job duration.
Using many smaller workers (instead of a few large ones) is often more cost-effective for many small tasks.
This option addresses the "many small files" problem by increasing parallelism.
Use case: When workload is embarrassingly parallel (e.g., many independent files), increasing worker count scales horizontally and improves throughput.
---
C) Use the AWS Glue DynamicFrame grouping option.
...
Author: Isabella1 · Last updated Jul 10, 2026
A company wants to combine data from multiple software as a service (SaaS) applications for analysis.
A data engineering team needs to use Amazon QuickSight to perform the analysis and build dashboards. A data engineer needs to extract the data from the SaaS applications and make the d...
Let's analyze the options to determine the most operationally efficient solution for extracting data from multiple SaaS apps for use in Amazon QuickSight.
---
Key Factors to Consider:
Operational efficiency: Minimal manual intervention, automation, scalability.
Integration with SaaS: Native connectors or easy API integration.
Data cataloging & querying: Make data easily queryable by QuickSight.
Maintenance overhead: Lower is better.
Scheduling & automation: Ability to keep data updated without manual work.
---
Option A: AWS Lambda functions to call SaaS APIs → S3 → Glue catalog → QuickSight
Pros: Full control over data extraction logic. Glue catalog enables schema and querying.
Cons: Requires building and maintaining Lambda code for each SaaS API integration (complex and time-consuming). Handling API changes, pagination, error handling adds operational overhead. Less scalable for many SaaS apps.
Use case: When SaaS APIs are custom or no native connectors exist; teams want complete control and customization.
---
Option B: AWS Lambda federated Athena queries against SaaS APIs → Athena → QuickSight
Pros: Query SaaS data in place without ETL. Federated query is powerful for real-time access.
Cons: Setting up and maintaining federated query Lambda connectors is complex. Performance depends on APIs, and high query latency can degrade QuickSight experience. Operational overhead to keep connectors updated.
Use case: When near real-time access is critica...
Author: Charlotte · Last updated Jul 10, 2026
A company runs multiple applications on AWS. The company configured each application to output logs. The company wants to query and visualize the application lo...
Let's analyze each option carefully based on the requirements:
Requirements Recap:
Multiple applications running on AWS output logs.
The company wants to query and visualize the application logs in near real-time.
---
Option A:
Configure apps to output logs to CloudWatch Logs. Export logs on a schedule (via Lambda) to S3. Use Athena to query logs in S3.
Pros: Athena is great for querying large volumes of data stored in S3 using SQL.
Cons: Exporting logs from CloudWatch Logs to S3 via Lambda runs on a schedule, meaning this is not near real-time. There will be a delay between logs generated and when they appear in S3 and can be queried.
Use case scenario: Good for historical or batch analytics on logs, not real-time or near real-time visualization.
---
Option B:
Create Amazon OpenSearch Service domain. Stream logs from CloudWatch Logs via subscription filters to OpenSearch. Use OpenSearch queries and dashboards.
Pros: OpenSearch supports near real-time ingestion and querying of log data. Subscription filters enable streaming logs directly as they are generated. Visualization can be done via Kibana dashboards.
Cons: Requires managing an OpenSearch cluster, but this is a common and powerful solution for log analytics.
Use case scenario: Ideal for near real-time log analytics and visualization at scale.
---
Option C:
Output logs to CloudWatch Logs. Use CloudWatch Logs Anomaly Detection to qu...
Author: Emma · Last updated Jul 10, 2026
An ecommerce company processes millions of orders each day. The company uses AWS Glue ETL to collect data from multiple sources, clean the data, and store the data in an Amazon S3 bucket in CSV format by using the S3 Standard storage class. The company uses the stored data to conduct daily ...
Let's analyze each option carefully with key factors such as cost optimization for storage and retrieval, data access patterns, and suitability for daily analysis.
---
A) Transition the data to Amazon S3 Glacier Flexible Retrieval
Pros:
Glacier Flexible Retrieval (formerly Glacier) is very cost-effective for long-term archival storage.
Low storage cost compared to S3 Standard.
Cons:
Glacier retrieval times range from minutes to hours, not suitable for frequent or daily data access.
Since the company uses the data for daily analysis, Glacier's slow retrieval and higher retrieval costs make it a poor fit.
Scenario suitable for:
Archival data that is rarely accessed and does not require immediate retrieval.
Conclusion: Not ideal due to frequent daily access requirement.
---
B) Transition the data from Amazon S3 to an Amazon Aurora cluster
Pros:
Aurora is a relational database optimized for OLTP and complex queries.
Can speed up analytics if you need low-latency queries on structured data.
Cons:
Storing large volumes of raw data (millions of orders daily) in Aurora is costly and not typical for raw data storage.
Aurora is more expensive than S3 for storage and doesn't optimize storage costs.
Data ingestion and schema management can become complex at scale.
Scenario suitable for:
When the data needs to be accessed with relational queries frequently and requires transactional consistency.
Conclusion: Not cost-effective or scalable for raw data storage and simple analytics where large raw data is stored in S3.
---
C) Configure AWS Glue ETL to transform the incoming data to Apache Parquet format
Pros:
Parquet is a columnar storage format that significantly reduces storage size compared to CSV (better compression).
Parquet enables faster query performance and lower data scan costs during analysis, especially with tools like Athena or Redshift Spectrum....
Author: Elizabeth · Last updated Jul 10, 2026
A data engineer is optimizing query performance in Amazon Athena notebooks that use Apache Spark to analyze large datasets that are stored in Amazon S3. The data is partitioned.
An AWS Glue crawler updates the partitions.
The data engineer wants to minimize the amo...
Let's analyze each option carefully in the context of optimizing query performance in Athena when querying partitioned data stored in S3, with an AWS Glue crawler updating partitions.
---
Key factors to consider:
Athena charges based on the amount of data scanned.
Minimizing data scanned means efficient partition pruning and filtering.
AWS Glue crawler updates partitions metadata in the Glue Data Catalog, which Athena uses.
Spark in this scenario is used for analyzing data, but Athena itself is a serverless interactive query engine directly querying S3.
Partitioning and correct filtering can reduce data scanned significantly.
Directory structure affects partitioning but Athena partitions are registered in Glue catalog.
In-memory caching affects Spark but not Athena directly.
Frequency of Glue crawler updates affects metadata freshness, not data scanned per query.
---
Option A: Apply partition filters in the queries
Why it fits:
Athena is very efficient at pruning partitions if partition filters are applied in the WHERE clause of the query.
This directly limits the partitions scanned, hence reducing the amount of data read from S3.
Example scenario: Query with `WHERE year=2025 AND month=08` only scans the relevant partitions.
Key factor: Partition pruning is the most effective way to reduce scanned data in Athena.
---
Option B: Increase frequency of AWS Glue crawler invocations
Why it doesn’t fit for scanning reduction:
Glue crawler updates partition metadata, which is important for accuracy and availability of partitions but does not reduce the amount of data scanned during a query.
More frequent crawling might help with data freshness but does not optimize query cost or performance directly.
Could add cost and overhead if run too frequently without benefit to scanning size.
---
Option C: Organize the data in Amazon S3 by using a nested directory structure
Why...
Author: Joseph · Last updated Jul 10, 2026
A company manages an Amazon Redshift data warehouse. The data warehouse is in a public subnet inside a custom VPC. A security group allows only traffic from within itself. An ACL is open to all traffic.
The company wants to generate several visualizations in Amazon QuickSight for an upcoming sales event. The company will run QuickSight Enterprise edition in a second AWS account inside a public subnet within a second custom VPC. The new public subnet has a security group that allows outbound traffic to the existing...
Let's analyze each option carefully based on the architecture and requirements:
---
Scenario Recap:
Redshift cluster: in public subnet of custom VPC, security group allows only traffic from itself.
Network ACL: open to all traffic.
QuickSight Enterprise: in a second AWS account, in a public subnet of a different custom VPC.
QuickSight security group: allows outbound traffic to Redshift.
Goal: QuickSight must query Redshift to refresh dashboards.
---
Option A:
"Configure the Redshift security group to allow inbound traffic on the Redshift port from the QuickSight security group."
Pros:
Security groups can reference other security groups across accounts only if they are in the same VPC or peered VPCs.
This would allow QuickSight instances to connect on the Redshift port securely.
Cons:
QuickSight and Redshift are in different VPCs in different accounts with no VPC peering mentioned.
Security groups referencing across accounts but across VPCs require VPC peering or Transit Gateway connectivity.
Without network-level connectivity (peering), this won't work.
Conclusion:
This option requires network connectivity between VPCs which isn't stated as established. So, it's not sufficient by itself.
---
Option B:
"Assign Elastic IP addresses to the QuickSight visualizations. Configure the QuickSight security group to allow inbound traffic on the Redshift port from the Elastic IP addresses."
Issues:
QuickSight is a managed service, you don't control or assign Elastic IPs to QuickSight endpoints or visualizations.
QuickSight doesn't expose Elastic IPs that you can whitelist for inbound rules.
Also, the Redshift cluster's security group currently only allows traffic from itself, so you'd have to change it to allow inbound traffic from these EIPs, which is not feasible since you can't assign static EIPs for QuickSight visualizations.
Conclusion:
This is not possible due to how QuickSight is managed and the inability to assign or rely on Elastic IPs in this context.
---
Option C:
"Confirm that the CIDR ranges of the Redshift VPC and the QuickSight VPC are the same. If CIDR ranges are different, reconfigure one CIDR range to match the other. Establish network peering between the VPCs."
Pros:
VPC p...
Author: Noah · Last updated Jul 10, 2026
A data engineer is building a data pipeline. A large data file is uploaded to an Amazon S3 bucket once each day at unpredictable times. An AWS Glue workflow uses hundreds of workers to process the file and load the data into Amazon Redshift. The...
Let's analyze each option carefully based on the problem requirements and key factors:
Problem recap:
Large data file arrives once per day at unpredictable times in an S3 bucket.
AWS Glue workflow uses hundreds of workers to process the file and load into Redshift.
The goal is to process the file as quickly as possible once it arrives.
---
Option A:
Create an on-demand Glue trigger + Lambda runs every 15 minutes to check S3 + start Glue workflow if file exists.
Pros:
Relatively simple to implement.
Glue workflow only starts if file is present.
Cons:
Potential delay up to 15 minutes before Lambda detects file and triggers Glue workflow.
Inefficient polling approach—not event-driven, so not immediate.
Use case:
When event-driven triggers are not possible and low frequency checks are acceptable.
---
Option B:
Create an event-based Glue trigger. Configure S3 to log PutObject events to CloudTrail, then use EventBridge rule to forward PutObject events to Glue trigger.
Pros:
Event-driven — Glue workflow triggers immediately after file upload.
No polling or delays.
Scalable and cost-efficient.
Cons:
Slightly complex setup involving CloudTrail and EventBridge.
Requires correct event pattern filtering.
Use case:
When immediate processing after file upload is critical.
When you want fully automated event-driven pipelines.
---
Option C:
C...
Author: David · Last updated Jul 10, 2026
A data engineer needs to run a data transformation job whenever a user adds a file to an Amazon S3 bucket. The job will run for less than 1 minute. The job must send the output through an email message to the data engineer. The data engineer expects users to add one ...
Let's analyze each option based on operational efficiency, cost, complexity, and scalability given the requirements:
Requirements Recap:
Run a data transformation job whenever a file is added to S3.
Job runs for less than 1 minute.
Output sent via email to the data engineer.
File arrival frequency: about once every hour (low frequency).
Solution must be operationally efficient (minimal maintenance/management).
---
Option A: EC2 instance polling S3 and sending emails via OS commands
Polling approach is inefficient and not event-driven; this causes unnecessary compute usage.
Running a constantly-on EC2 instance for just one file per hour is overkill and not cost-efficient.
Managing the EC2 instance (patches, scaling, monitoring) increases operational overhead.
Sending emails via OS commands requires setup and management of email servers or external SMTP.
Best for: Long-running or high-frequency batch jobs, or when custom OS-level control is required.
Rejected because: inefficient, costly, and operationally complex for a simple hourly event-triggered job.
---
Option B: ECS task polling S3 and sending emails via OS commands
Similar to Option A but using containers on ECS.
Polling is still inefficient and not event-driven.
ECS adds some operational overhead: cluster management or using Fargate (serverless containers).
Requires custom email sending setup.
Best for: Containerized workloads needing some scalability, but still not ideal for event-driven, infrequent triggers.
Rejected because: same reasons as A — inefficient polling, unnecessary complexity, and operational overhead.
---
Option C: Lambda triggered by S3 Event Notification + SNS for email delivery
Lambda can be triggered immediately on new object creation (event-driven).
Lambda has sub-second startup times, perfect for short (<1 minute) j...
Author: Rahul · Last updated Jul 10, 2026
A company uses Amazon S3 and AWS Glue Data Catalog to manage a data lake that contains contact information for customers. The company uses PySpark and AWS Glue jobs with a DynamicFrame to run a workflow that processes data within the data lake.
A data engineer notices that the workflow is generating errors as a result of how customer postal codes are stored in the data lake. Some pos...
Let's analyze each option in the context of the problem:
Problem Recap:
The company uses AWS Glue + PySpark with DynamicFrames to process customer contact data.
Postal codes have invalid characters or extra numbers causing processing errors.
The goal is to clean or correct postal codes in the data lake during processing to avoid errors.
---
Option A:
Create a schema definition for PySpark that matches the format the processing workflow requires for postal codes. Pass the schema to the DynamicFrame during processing.
This option involves defining a strict schema for the postal code field to enforce correct data types and formats.
However, schema definition alone won't fix or clean invalid postal codes; it will more likely cause job failures if data doesn't match the schema.
This approach validates the format but doesn't correct errors.
Also, DynamicFrames generally infer schema or use Glue catalog schema but do not automatically clean data.
This option does not address cleaning or correcting data, only structure validation.
Rejection reason: Doesn't correct data, only schema validation; errors likely continue.
---
Option B:
Use AWS Glue workflow properties to allow job state sharing. Configure the AWS Glue jobs to read values from the postal code column by using the properties from a previously successful run of the jobs.
This option is about sharing state or metadata between Glue jobs within a workflow.
It doesn't relate directly to cleaning or validating postal codes.
Reading previous run properties doesn't fix bad postal codes in current data.
This is more suitable for job orchestration or parameter passing, not data correction.
Rejection reason: Doesn't fix or clean postal code data; unrelated to data correction.
---
Option C:
Configure the column.push\_down\_predicate setting and the catalogPartitionPredicate settings for the postal code column in the DynamicFrame.
Push-down predicates allow filtering data at the source before reading it into the job.
Using predicates on postal code could filter out bad records, but it doesn't cl...
Author: Evelyn · Last updated Jul 10, 2026
A data engineer is troubleshooting an AWS Glue workflow that occasionally fails. The engineer determines that the failures are a result of data quality issues. A business reporting team needs to receive an email notific...
Let's analyze each option carefully based on the requirement:
Requirement Summary:
Notify a business reporting team via email whenever an AWS Glue workflow fails.
The solution should be reliable for occasional failures caused by data quality issues.
Notification on job state FAILED.
---
Option A
Create an SNS FIFO topic.
Subscribe the team's email to SNS.
Trigger an AWS Lambda function on Glue job state FAILED.
Lambda publishes to SNS topic.
Pros:
Lambda allows custom logic if needed.
SNS supports email subscriptions.
Cons:
FIFO SNS topics do not support email subscriptions. SNS FIFO topics only support application, SQS, Lambda, and HTTP/S endpoints, not email.
This means email notifications cannot be sent directly from SNS FIFO.
Lambda is an extra component here that might not be needed if EventBridge can trigger SNS directly.
Conclusion:
SNS FIFO is not suitable for email notifications. Lambda adds complexity unnecessarily.
---
Option B
Create an SNS standard topic.
Subscribe the team's email to SNS.
Create an EventBridge rule that triggers on AWS Glue job FAILED state.
Set SNS as the EventBridge target.
Pros:
SNS standard topics support email subscriptions directly.
EventBridge can detect Glue job state changes easily.
No extra Lambda needed; direct notification.
Simple, scalable, and reliable.
Well suited for the use case of triggering notifications on specific event states.
Conclusion:
This is a clean, direct, and appropriate solution.
-...
Author: Amelia · Last updated Jul 10, 2026
A company uses AWS Glue jobs to implement several data pipelines. The pipelines are critical to the company.
The company needs to implement a monitoring mechanism that will alert stakeholders if the pipeline...
Let's analyze each option carefully with respect to least operational overhead, effectiveness, and simplicity for monitoring AWS Glue job failures.
---
Option A
Create an EventBridge rule to match AWS Glue job failure events.
Target: Lambda function processes events and sends notifications to SNS.
Pros:
Directly reacts to Glue job failure events.
Customizable Lambda function logic for filtering or formatting alerts.
Reliable and near real-time.
Cons:
Requires managing and maintaining a Lambda function.
Lambda introduces operational overhead (code updates, monitoring, error handling).
Slightly more complex setup than direct notification.
When to use: When custom processing of failure events or complex alert logic is needed.
---
Option B
Use CloudWatch Logs log group for Glue jobs.
Create EventBridge rule on new log creation events.
Lambda reads logs, filters failures, sends notifications via SNS.
Pros:
Works at log level, very flexible for complex log analysis.
Can detect nuanced failure types or partial failures.
Cons:
More complex: requires parsing logs inside Lambda.
Higher operational overhead (managing Lambda, log parsing logic).
Potential latency (waits for logs to be created and ingested).
Overkill if you only need simple failure notifications.
When to use: When detailed log analysis or specific failure pattern detection is necessary.
---
Option C
Create EventBridge rule to match Glue job failure events.
Define CloudWatch metric from these events.
Set CloudWatch alarm on this metric to send notifications to SNS.
Pros:
Serverless, no Lambda needed — les...
Author: Ravi Patel · Last updated Jul 10, 2026
A company uses AWS Glue Apache Spark jobs to handle extract, transform, and load (ETL) workloads. The company has enabled logging and monitoring for all AWS Glue jobs.
One of the AWS Glue jobs begins to fail. A data engineer investigates the error and wants to...
Let's analyze each option carefully, focusing on how a data engineer can access stage-level metrics in an AWS Glue Apache Spark job:
---
A) Examine the AWS Glue job and stage details in the Spark UI.
Why this is relevant:
AWS Glue Spark jobs run on Apache Spark, which provides a Spark UI with detailed job, stage, and task metrics.
The Spark UI offers granular insight into each stage's runtime, shuffle read/write, task success/failure, and more.
This is the best source for stage-level metrics because it is specifically designed to show the breakdown of Spark job execution.
Limitations:
The Spark UI is ephemeral and available only during or shortly after job execution unless logs are preserved or pushed to an external system.
Requires enabling Glue job bookmarks or configuring the job to allow Spark UI access.
---
B) Examine the AWS Glue job and stage metrics in Amazon CloudWatch.
Why this is relevant:
CloudWatch collects metrics at the job level, such as job duration, success/failure, and resource usage.
It provides overall Glue job metrics but does not provide detailed Spark stage-level metrics.
Limitations:
CloudWatch is great for monitoring job success/failure, errors, and resource usage but lacks fine-grained Spark stage breakdown.
Not suitable for troubleshooting individu...
Author: Daniel · Last updated Jul 10, 2026
A data engineer notices slow query performance on a highly partitioned table that is in Amazon Athena. The table contains daily data for the previous 5 years, partitioned by date.
The data engineer wants to improve query ...
Let's analyze each option carefully against the key requirements:
Scenario:
Table is highly partitioned by date (daily partitions for 5 years = \~1825 partitions).
Query performance is slow.
Automation of partition management is needed.
---
Option A: Use an AWS Lambda function that runs daily to manually create new partitions in AWS Glue.
Pros: Automates partition creation, so no manual intervention needed.
Cons:
Manual partition management can become complex and error-prone at scale, especially with many partitions.
Each partition must be explicitly added, which adds overhead and maintenance complexity.
Doesn't directly improve query performance beyond automating partition creation.
When to use: Good for scenarios with infrequent or unpredictable partition additions or where dynamic partitioning isn't supported.
Why rejected:
Manual partition management can be a maintenance burden.
Slow query performance due to large partition count is not solved by just automating partition addition.
---
Option B: Use partition projection in Athena with a date range from 5 years ago to present.
Pros:
Automatically projects partitions without needing to add them to the Glue Data Catalog manually.
Eliminates the overhead of managing partitions in Glue, which reduces query planning time.
Significantly improves query performance by avoiding costly metadata calls for thousands of partitions.
Automates partition management via configuration rather than code.
Cons: Requires partition scheme to follow a predictable pattern (which it does — daily date partitions).
When to use: Highly partitioned tables with predictable partition key formats and large partition counts.
Why selected:
Addresses both requirements: improves query performance by reducing metadata lookups and automates partition management through projection.
---
Option C: Reduce number of partitions by changing from daily to month...
Author: John · Last updated Jul 10, 2026
A company has deployed an ML model. The company wants to provide external customers with secure access to the model through the customers' own...
The key requirement is:
External customers need access.
Access must be secure.
Customers will access the model through their own applications.
Let's evaluate each option like you would in an AWS certification exam.
| Option | Verdict | Key Factor |
| ------ | --------- | ---------------------------------------------------- |
| A | ❌ Reject | Authentication only, no secure service interface |
| B | ❌ Reject | Credential sharing is insecure |
| C | ✅ Correct | Standard AWS architecture for secure external access |
| D | ❌ Reject | No centralized control or security |
---
Option A) Use a custom script in the customers' application for authentication.
Why rejected
This only discusses authentication, not how customers securely access the deployed model.
Problems:
Every customer would need to maintain custom authentication logic.
Doesn't expose the model as a managed service.
Hard to scale.
Difficult to revoke or manage access.
Reinvents functionality AWS already provides (API Gateway, IAM, Cognito, Lambda authorizers).
Key factor
Authentication alone is not an access mechanism.
AWS prefers managed services over custom security implementations.
When this option is used
Rarely.
Custom authentication scripts may be used:
Internal prototypes
Legacy applications
Special authentication mechanisms
Not recommended for exposing production ML models.
---
Option B) Store model credentials and share them with the customers directly for authentication.
Why rejected
This violates AWS security best practices.
Problems:
Sharing credentials is insecure.
Credentials can be leaked.
Difficult to rotate.
No fine-grained permissions.
No audit trail.
Violates the principle of least privilege.
Key factor
Never share backend credentials directly with customers.
AWS exams frequently reject answers involving credential sharing.
When this option is used
Essentially never for customer-facing services.
Instead AWS uses:
IAM Roles
Cognito
OAuth
API Keys
Signed requests
---
Option C) Create a secure API endpoint that customers can use.
✅ Correct Answer
This is the AWS standard architecture.
Typical implementation:
```
Customer App
│
▼
Amazon...
Author: Aarav2020 · Last updated Jul 19, 2026
A company is using Retrieval Augmented Generation (RAG) in its generative AI (GenAI) application. The company wants to use Amazon Bedrock Knowledge Bases evaluations to measure how well responses avoi...
The correct answer is D) Faithfulness.
Key requirement in the question
The important keywords are:
Retrieval Augmented Generation (RAG)
Amazon Bedrock Knowledge Bases evaluations
Measure how well responses avoid hallucination
Based on the retrieved texts
The phrase "based on the retrieved texts" is the biggest clue. In a RAG system, the model should generate answers that are supported by the documents retrieved from the knowledge base. The evaluation metric that measures whether the generated answer stays grounded in those retrieved documents is Faithfulness.
---
Option D) Faithfulness ✅ (Correct)
What it measures
Faithfulness evaluates whether the generated response is supported by the retrieved context.
It checks:
Is the answer grounded in the retrieved documents?
Did the model invent facts not present in the retrieved text?
Does the response accurately reflect the provided evidence?
Why it matches this question
The question specifically wants to:
> "measure how well responses avoid hallucination based on the retrieved texts."
Hallucination in RAG means:
The retrieved document says one thing.
The model answers something else or invents additional facts.
Faithfulness directly measures this.
Example
Retrieved document:
> "Amazon Bedrock was launched in 2023."
Generated answer:
> "Amazon Bedrock launched in 2024."
The answer is not faithful because it contradicts the retrieved evidence.
---
Option A) Refusal ❌
What it measures
Refusal measures whether the model appropriately declines to answer requests that should not be answered.
Typical scenarios:
Dangerous instructions
Requests for illegal activities
Sensitive information
Unsupported requests when the model should refuse
Why it is rejected
The question is not about refusing answers.
It is about checking whether answers are grounded in retrieved documents.
When Refusal is used
Examples:
"Tell me how to build malware."
"Generate phishing emails."
"Give me someone's private medical records."
Here the correct behavior is to refuse.
Key factor: Safe refusal behavior, not hallucination detection.
---
Option B) Harmfulness ❌
What it measures
Harmfulness evaluates whether responses contain harmful content such as:
Violence
Hate speech
Dangerous advice
Toxic language
Why it is rejected
The question does not mention:
Safety
Tox...
Author: StarryEagle42 · Last updated Jul 19, 2026
A global logistics company is using generative AI (GenAI) models on Amazon Bedrock to automate paperwork and shipment documentation. The company wants to set up a clear AI governance process to make sure the models are used res...
The question is testing AI Governance in Amazon Bedrock / Responsible AI.
Key factors in the question
The company wants to:
Set up a clear AI governance process
Ensure responsible AI usage
Meet company policies
AI governance is about people + processes + technology. It includes continuous monitoring, policy enforcement, employee awareness, and accountability.
---
Option A) Set up a regular review process to check that the models' results are accurate and fair and follow company policies.
✅ Selected
Why?
A good AI governance program requires continuous evaluation of AI systems. Models can change in behavior over time because:
Prompts change
Business data changes
New use cases emerge
Risks such as bias or hallucinations may appear
Regular reviews help verify:
Accuracy
Fairness
Compliance with company policies
Responsible AI practices
This is exactly what governance frameworks recommend.
Key factors
Continuous monitoring ✔
Policy compliance ✔
Responsible AI ✔
Risk management ✔
AWS perspective
AWS recommends ongoing evaluation and monitoring of foundation models rather than assuming they remain safe forever.
When is this used?
Use whenever an organization has production AI systems that must remain compliant with internal policies or regulations.
---
Option B) Provide training for all employees who work with AI tools so the employees understand company rules, data handling, and responsible AI use.
✅ Selected
Why?
Governance is not only about technology—it also includes people.
Employees need to understand:
Responsible AI principles
Data privacy
Security
Proper prompt usage
Company policies
Compliance requirements
Without training, employees may:
Upload sensitive data
Misuse AI outputs
Violate regulations
Ignore governance procedures
Training is a fundamental governance control.
Key factors
Organizational governance ✔
Responsible AI awareness ✔
Security awareness ✔
Policy adherence ✔
When is this used?
Whenever employees interact with AI systems or foundation models.
---
Why the other options are rejected
Option C) Let the cloud provider manage all AI safety checks and reviews to save internal effort.
❌ Rejected
Why?
AWS provides tools and features for responsible AI, but customers are still responsible for governing how AI is used within their organization.
This follows the idea of AWS's shared responsibility model:
AWS secures the cloud and provides governance capabilities.
Customers gove...
Author: Elijah · Last updated Jul 19, 2026
A company wants to call a single Amazon Bedrock endpoint and needs Amazon Bedrock to pick the most suitable foundation model (FM) for each request. The company does not want to hardcode a...
The key phrase in the question is:
> "call a single Amazon Bedrock endpoint" and "Amazon Bedrock picks the most suitable foundation model (FM) for each request" and "does not want to hardcode a model."
These are the deciding factors.
| Key Factor | Requirement |
| ------------------------- | ----------- |
| Single endpoint | Yes |
| Automatic model selection | Yes |
| No hardcoded FM | Yes |
Now evaluate each option.
---
A) Amazon Bedrock Guardrails ❌
What it does
Guardrails apply safety policies to model responses.
Examples:
Block harmful content
Filter profanity
Prevent prompt injection
Mask sensitive information
Restrict topics
Why it is rejected
The question is about choosing the best FM.
Guardrails:
do not select models
do not route requests
do not provide a unified endpoint
When to use Guardrails
Use Guardrails when you need:
content moderation
safety controls
PII filtering
responsible AI
Key factor
> Safety layer, not routing layer.
---
B) Amazon Bedrock Knowledge Bases ❌
What it does
Knowledge Bases provide Retrieval-Augmented Generation (RAG).
Workflow:
User Question
↓
Retrieve relevant documents
↓
Send documents to an FM
↓
Generate answer
It connects to data sources like:
Amazon S3
OpenSearch
Aurora
Pinecone
Redis
Why it is rejected
Knowledge Bases help an FM answer using enterprise data.
They do not decide which FM to use.
The model is still chosen separately.
When to use Knowledge Bases
Use when:
enterprise documents
PDFs
company wiki
internal knowledge
RAG applications
Key factor
> Retrieves data, does not choose models.
---
C) Amazon Bedrock Prompt Router ✅
What it does
Prompt Router allows applications to call one Bedrock endpoint, while Amazon Bedrock automatically routes each request to the best foundation model based on the prompt.
This avoids:
hardcoding Claude
hardcoding Llama
hardcoding Nova
manually writing routing logic
Exactly what the question describes.
Why it matches
Question statement:
> wants a single endpoint
Prompt Router:
✔ Si...
Author: Lucas · Last updated Jul 19, 2026
A company is using a generative AI (GenAI) system to generate medical summaries from patient records. The system sometimes produces inaccurate information...
The key phrase in the question is:
> "The system sometimes produces inaccurate information that appears credible."
This describes hallucination, one of the most common problems with GenAI models. The AWS exam expects you to identify the technique that reduces hallucinations by grounding the model in trusted data.
---
Analyze each option
A) Implement strict input validation and output formatting rules.
Why it is not correct
Input validation ensures users provide acceptable inputs (correct format, required fields, no malicious prompts).
Output formatting ensures responses follow a specific structure (JSON, bullet points, sections).
Neither of these addresses whether the generated facts are true.
For example:
```
Patient Summary
Diagnosis: Diabetes
Medication: Metformin
```
The format is perfect.
But if the patient never had diabetes, the answer is still wrong.
Key factor
Improves structure
Improves security
Does not reduce hallucinations
When this option is used
Use when you need:
consistent JSON/XML output
prompt injection protection
validation of user inputs
standardized reports
---
B) Implement Retrieval Augmented Generation (RAG) to ground responses.
Why this is correct
RAG allows the model to retrieve relevant information from an external trusted knowledge source before generating the answer.
Instead of relying only on its internal training, the model consults:
patient records
medical databases
hospital documents
latest guidelines
The response is then generated using those retrieved documents.
This significantly reduces hallucinations because the answer is based on actual data.
For medical summaries:
```
Patient Record
--------------
Blood Pressure: 145/95
Medication: Amlodipine
↓
Retriever fetches this information
↓
LLM summarizes
↓
"The patient has hypertension and is taking Amlodipine."
```
The answer is grounded in the patient's records.
Key factor
AWS exam keywords:
ground responses
reduce hallucinations
retrieve external knowledge
use enterprise documents
knowledge base
Whenever you see these phrases, think RAG.
When this option is used
Use RAG for:
medical records
legal documents
financial reports
company knowledge bases
product manuals
customer support
internal enterprise data
Essentially, whenever answers s...
Author: Zain · Last updated Jul 19, 2026
A company is building an agentic AI application by using Model Context Protocol (MCP) servers with Amazon Q Developer CLI. The company wants to follow MCP security p...
The correct answers are:
A) Keep MCP servers and the Amazon Q Developer CLI updated.
E) Install servers only from trusted sources.
Let's analyze each option from an AWS exam perspective.
---
Key factors in the question
The question asks about following MCP security practices while using Model Context Protocol (MCP) servers with Amazon Q Developer CLI.
Think about the core security principles:
Keep software patched
Trust only verified software
Prevent supply-chain attacks
Protect against vulnerabilities
Follow least privilege and secure configuration
---
Option A) Keep MCP servers and the Amazon Q Developer CLI updated.
✅ Selected
Why?
Keeping software updated is one of the most fundamental security best practices.
Updates provide:
Security patches
Vulnerability fixes
Bug fixes
Improvements against newly discovered exploits
Old MCP servers may contain vulnerabilities that attackers can exploit.
AWS documentation recommends keeping both the client (Amazon Q Developer CLI) and MCP servers updated.
Key factor
> Patch management = Security
Whenever an option mentions:
update
latest version
security patches
it is almost always a strong security best practice.
When this option is used
Use whenever the scenario involves:
software security
vulnerability management
agent security
AWS security best practices
---
Option B) Monitor MCP logs for normal successful activity.
❌ Rejected
Why?
Logging is important.
However, the wording is the problem.
It says:
> Monitor logs for normal successful activity
Security monitoring focuses on:
unusual activity
failed authentication
suspicious tool execution
anomalies
unauthorized access
Monitoring only successful normal activity does not help detect attacks.
The wording intentionally avoids mentioning suspicious behavior.
Key factor
Security monitoring should detect:
abnormal behavior
failed requests
malicious activity
not merely normal successful operations.
When a similar option would be correct
If it said:
> Monitor logs for suspicious or anomalous activity
or
> Audit MCP server logs for unauthorized tool execution
then it would likely be correct.
---
Option C) Use plain text files to store sensitive configurations.
❌ Rejected
Why?
Plain text storage is never considered a security best practice.
Sensitive information includes:
API keys
credentials
authentication tokens
secrets
These should be stored using secure secret management solutions.
For AWS examples:
AWS Secrets Manager
AWS Systems Manager Parameter Store
Key factor
Never store secrets...
Author: Maya · Last updated Jul 19, 2026
A company wants to establish a data governance framework for its AI system. The framework must give the company the ability to monitor when data is generated, updated, and schedul...
The key requirement in the question is:
> The company must be able to monitor when data is generated, updated, and scheduled for deletion.
This is asking about managing data throughout its entire lifespan, from creation until deletion.
Let's evaluate each option.
---
A) Data residency ❌
What it is
Data residency is about where data is physically stored (country, region, or jurisdiction).
Examples:
Customer data must remain inside the EU.
Financial records must stay in India.
Healthcare data must remain in a specific AWS Region.
Key factors
Geographic location of data
Regulatory compliance
Legal requirements
Why it is rejected
The question is not asking where the data lives.
It asks:
when data is created
when it is updated
when it will be deleted
Those are lifecycle events, not location requirements.
Use this option when
GDPR
Data sovereignty
Regional storage requirements
---
B) Data lifecycle management ✅ (Correct)
What it is
Data lifecycle management manages data through every stage of its life:
1. Data creation
2. Data storage
3. Data usage
4. Data updates
5. Data archival
6. Data deletion
Organizations define policies such as:
retain for 7 years
archive after 1 year
delete after 10 years
Key factors
Look for words like:
generated
created
updated
retained
archived
scheduled for deletion
expiration
retention policy
These all indicate data lifecycle management.
Why it matches perfectly
The question literally describes monitoring lifecycle events:
generated ✔
updated ✔
scheduled for deletion ✔
These are all phases of the data lifecycle.
Use this option when
Data retention policies
Automatic deletion
Archiving
Compliance retention periods
Managing data from creation to destruction
---
C) Data observability ❌
What it is
Data observability focuses on monitoring the health and quality of data.
It helps answer:
Is data arriving?
Is data complete?
Is data accurate?
Has the schema changed?
Are pipelines failing?
Examples:
Missing records
Duplicate data
Broken ETL jobs
Poor data quality
Key factors
Think:
quality
freshness
completeness
consistency
monitoring pipelines
Why it is rejected
Although "monitor" appear...
Author: Mia · Last updated Jul 19, 2026
A company is training a foundation model (FM). The company wants the FM training data to be well managed, secure, and compliant throughout the data lifecycle. The data must follow governance practices.
Wh...
The correct answer is:
✅ D) Establish data lifecycle policies, access controls, logging, and monitoring.
Why D is correct
AWS data governance is about ensuring that data is managed, secure, compliant, and usable throughout its entire lifecycle (creation, storage, usage, sharing, archival, and deletion).
The question specifically mentions:
Well managed
Secure
Compliant
Throughout the data lifecycle
Follow governance practices
The key components of AWS data governance include:
Data lifecycle policies – Define how long data is retained, archived, and deleted.
Access controls – Ensure only authorized users can access data (IAM, Lake Formation, resource policies).
Logging – Record who accessed or modified data (AWS CloudTrail).
Monitoring – Continuously monitor data usage and detect suspicious activities (Amazon CloudWatch, AWS Config, GuardDuty).
These are all fundamental governance practices recommended by AWS.
Key factors that match the question:
✔ Security
✔ Compliance
✔ Data lifecycle management
✔ Governance
✔ Auditing
✔ Controlled access
---
Why A is incorrect
A) Allow unrestricted access to all data for every employee.
Why rejected
This completely violates AWS security and governance best practices.
Governance requires:
Least privilege access
Role-based permissions
Controlled access
Protection of sensitive information
Giving everyone unrestricted access:
Increases security risks
Violates compliance requirements
Can expose confidential or regulated data
Removes accountability
Key factor
The phrase "unrestricted access" is the biggest red flag.
AWS always recommends:
Least privilege
Need-to-know access
IAM policies
When could something similar be used?
Only in:
Small development sandboxes
Temporary testing environments
Training labs
Never for production or governed foundation model datasets.
---
Why B is incorrect
B) Store data indefinitely without classification or retention policies.
Why rejected
Data governance requires managing data throughout its lifecycle.
That includes:
Data classification
Retention periods
Archiving
Secure deletion
Keeping data forever without policies:
Increases storage costs
Creates compliance issues
Violates regulations like GDPR or industry retention requirements
Makes governance impossible
Key factor
The phrase "without classification or retention policies" directly contradicts governance.
When could long-term storage be used?
Long retention is appropriate when:
Regulations require it
Business policies require historical records
Legal hold is necessary
Even then, the data still has:
Classification
Retention policies
Access controls
---
Why C is incorrect
C) Rely solely on manual reviews for data quality and compliance.
Why rejected
Manual reviews can help, b...
Author: Emily · Last updated Jul 19, 2026
A company needs to document an ML model's purpose, owners, and limitations.
Which AWS service or ...
The correct answer is:
✅ D) Amazon SageMaker Model Cards
Key requirement in the question
The company wants to document:
ML model purpose
Model owners
Model limitations
These are all model governance and documentation requirements.
The keyword "document" is the biggest clue.
---
Option A) Amazon Bedrock ❌
What it is
Amazon Bedrock is a fully managed service for building and deploying generative AI applications using foundation models.
Key factors
Provides foundation models (Claude, Llama, Titan, etc.)
Supports RAG, agents, fine-tuning
Used for GenAI application development
Not a documentation or governance service
Why rejected
The question is asking about recording metadata and governance information (purpose, owner, limitations), not building or serving AI models.
When this option is used
Choose Amazon Bedrock when the scenario mentions:
Foundation models
LLMs
Chatbots
Text generation
Image generation
Generative AI applications
---
Option B) AWS AI Service Cards ❌
What it is
AWS AI Service Cards are documents published by AWS that explain AWS-managed AI services.
They include information such as:
Intended use
Limitations
Responsible AI considerations
Performance characteristics
Key factors
Created by AWS
Describe AWS AI services
Help customers understand AWS services
Why rejected
The company wants to document its own ML model.
AI Service Cards describe AWS services, not customer-created models.
When this option is used
Choose AWS AI Service Cards when the question asks:
How to understand AWS AI service limitations
Responsible AI documentation for AWS services
Transparency documentation published by AWS
---
Option C) AWS Prescriptive Guidance ❌
What it is
AWS Prescriptive Guidance provides:
Architecture patterns
Migration strategies
Best practices
Design recommendations
Key factors
Best-practice documentation
Solution architectures
Migration guidance
Why rejected
It does not store documentation about a specific ML model.
When this option is used
Choose AWS Prescriptive Guidance when the question involves:
Migration plannin...
Author: Joseph · Last updated Jul 19, 2026
A company needs to evaluate AI-generated summaries against reference text. The company must measure semantic similarity and coverage of key infor...
Let’s analyze this with exam-style reasoning:
---
✅ Correct Options
- B) BERTScore
- Why selected: BERTScore uses contextual embeddings from transformer models (like BERT) to measure semantic similarity between AI-generated summaries and reference text. It goes beyond surface-level word overlap, capturing meaning.
- Scenario use: Comparing whether an AI-generated shipment summary conveys the same meaning as the official reference documentation.
- E) ROUGE
- Why selected: ROUGE measures coverage of key information by evaluating overlap of n-grams, word sequences, and recall against the reference text. It is widely used for summarization tasks.
- Scenario use: Ensuring that AI-generated summaries include the critical details from the original shipment paperwork.
---
❌ Incorrect Options
- A) F1 score
- Why rejected:...
Author: Aarav2020 · Last updated Jul 19, 2026
A human resources company is building an AI/ML solution to screen resumes and select relevant applicants for various job roles.
Which AI methodologies will hel...
We need to identify which AI/ML methodologies help ensure impartial treatment across demographic groups in a resume-screening system.
The key requirement is reducing bias and ensuring decisions are fair and transparent.
---
✅ Correct Options: B) Fairness and C) Explainability
---
B) Fairness — ✔️ Selected
Fairness in AI/ML refers to designing models that do not discriminate against protected or sensitive attributes such as gender, age, ethnicity, or disability.
Why it is correct:
Resume screening models can unintentionally learn bias from historical hiring data.
Fairness techniques help ensure:
Equal opportunity across demographic groups
Balanced false positive/false negative rates
Mitigation of biased training data
When used:
HR hiring systems
Loan approval models
University admissions AI
---
C) Explainability — ✔️ Selected
Explainability ensures that AI decisions can be interpreted and understood by humans.
Why it is correct:
HR teams must justify why a candidate was selected or rejected.
Helps detect whether bias influence...
Author: Lucas Carter · Last updated Jul 19, 2026
An AI practitioner wants to quickly deploy and fine-tune foundation models (FMs) for generative AI (GenAI) tasks. The AI practitioner needs access to pre-trained models, solution templates, and example notebooks that can...
The requirement is: quickly deploy and fine-tune foundation models (FMs) with access to pre-trained models, solution templates, and example notebooks to accelerate GenAI development.
Let’s evaluate each option using AWS exam reasoning.
---
A) Amazon SageMaker Studio
Amazon SageMaker Studio
SageMaker Studio is a fully integrated development environment (IDE) for ML. It provides notebooks, debugging, pipelines, and model training tools.
✔ Good for: building ML workflows, experimentation, full lifecycle ML development
✔ Supports notebooks and model training
✖ Does NOT directly provide curated foundation model catalogs or one-click GenAI solutions
✖ Does NOT focus specifically on prebuilt GenAI solution templates
👉 Use case: When you want a custom ML development environment and full control over training pipelines.
---
B) Amazon SageMaker JumpStart (Correct Answer)
Amazon SageMaker JumpStart
This is specifically designed for fast GenAI and ML onboarding.
It provides:
✔ Pre-trained foundation models (FMs)
✔ One-click deployment of models
✔ Fine-tuning capabilities
✔ Solution templates (end-to-end ML workflows)
✔ Example notebooks and reference implementations
👉 This exactly matches the question requirements:
> “quickly deploy and fine-tune foundation models + access to pre-trained models + templates + notebooks”
👉 Use case:
Rapid prototyping of GenAI apps
Fine-tuning LLMs with minimal setup
Experimenti...
Author: Aria · Last updated Jul 19, 2026
A company wants to use foundation models (FMs) for multiple use cases, including content summarization, code generation, and customer service AI assist...
The correct answer is A) Select the smallest model that meets the performance requirements for each specific use case.
Why A is correct (most cost-effective)
In AWS foundation model usage (e.g., Amazon Bedrock), cost is primarily driven by:
Model size (parameters)
Inference compute per token
Latency requirements
Task complexity
Using the smallest model that still meets quality requirements per task is the most cost-efficient strategy because:
Simple tasks (like summarization) can use smaller models.
Complex tasks (like code generation or customer service reasoning) may require mid/large models.
You avoid overpaying for unnecessary model capacity.
You optimize cost per inference while still meeting SLAs.
This aligns with AWS best practices: right-size the model to the workload.
---
Why the other options are incorrect
B) Use the largest and most capable model for all tasks
This is technically valid but financially inefficient.
Large models (e.g., high-parameter LLMs) incur:
Higher token inference cost
Higher latency
Unnecessary compute for simple tasks like summarization
Best only when quality is absolutely critical and cost is not a concern.
Key ...
Author: Lucas · Last updated Jul 19, 2026
A company that runs AI workloads on Amazon Bedrock needs to evaluate and document compliance with regulatory standards.
...
The correct answer is A) AWS Audit Manager.
Why AWS Audit Manager is correct
AWS Audit Manager is designed specifically to help organizations continuously evaluate and document compliance against regulatory frameworks such as SOC 2, ISO 27001, GDPR, and industry-specific standards.
In this scenario, the company running AI workloads on Amazon Bedrock needs:
Evidence collection across AWS services
Mapping AWS resource usage to compliance controls
Automated generation of audit-ready reports
Continuous compliance tracking (not just one-time checks)
AWS Audit Manager directly fulfills this by aggregating configuration, usage, and security data across AWS accounts and producing structured compliance evidence.
---
Why the other options are incorrect
B) Amazon SageMaker Model Cards
Amazon SageMaker Model Cards
Used to document machine learning model details (training data, intended use, ethical considerations, evaluation metrics).
Best for model transparency and governance, not enterprise-wide regulatory compliance audits.
Works at the model level, not AWS account/service compliance level.
Useful when you want to explain or document an ML model for stakehol...
Author: Leo · Last updated Jul 19, 2026
An AI practitioner is developing a recommendation system. The AI practitioner wants to document a business problem, data assumptions, training considerations, and usage risks. The company must follow guidelines for tr...
The correct answer is B) Model Cards.
Why Model Cards is the correct choice
Amazon SageMaker Model Cards are specifically designed to support ML governance, transparency, and documentation requirements. They provide a structured way to record and communicate:
Business problem definition (what the model is solving)
Intended use cases and limitations
Data assumptions and training dataset details
Training configuration and evaluation metrics
Ethical considerations and known risks (bias, misuse, etc.)
In regulated or enterprise environments, Model Cards are used to ensure auditability and responsible AI practices, which aligns directly with the question’s requirement for transparency and governance.
---
Why the other options are incorrect
A) Model Registry
Purpose: Manages model versioning, lineage, and approval workflows
Best used for: MLOps lifecycle management (e.g., promoting models from staging → production)
Why not correct: It do...
Author: Noah · Last updated Jul 19, 2026
A company wants to develop an AI solution to automatically extract structured and unstructured data from scanned PDF documents and ...
Correct answer: D) Amazon Textract
---
Why Amazon Textract is the right choice
The requirement is to automatically extract structured and unstructured data from scanned PDFs and forms. This is exactly what Amazon Textract is built for.
Key capabilities:
Extracts printed text from scanned documents (OCR)
Identifies forms (key-value pairs like Name: John)
Extracts tables with structure preserved
Works with PDFs, images, scanned documents
Supports both structured data (forms, tables) and unstructured text (paragraphs, invoices, contracts)
👉 In AWS exam terms, anytime you see:
“scan documents”
“extract text from PDFs/images”
“forms or tables data extraction”
→ Textract is the go-to service.
---
Why the other options are incorrect
A) Amazon Polly
Amazon Polly
Converts text → speech
It does NOT process documents or extract data
Use case: audio narration, voice assistants, accessibility tools
❌ Rejected because it is output generation (speech), not document analysis.
---
B) Amazon Lex
Amazon Lex
Builds chatbots and voice bots
Handles intent recognition and conver...
Author: Emily · Last updated Jul 19, 2026
A company built a Retrieval Augmented Generation (RAG) based AI assistant by using Amazon Bedrock Agents. Sometimes the AI assistant gives incomplete or inaccurate answers. The company wants to improve and...
In a Retrieval Augmented Generation (RAG) system built using Amazon Bedrock Agents, poor or inconsistent answers usually come from two main sources: (1) retrieval failures (irrelevant or missing documents) and (2) generation issues (model not correctly using retrieved context or hallucinating). Therefore, evaluation must cover both stages, not just the final output.
Option A) Use BLEU scores to measure response similarity to reference answers
BLEU is designed for machine translation and measures n-gram overlap with a reference text.
Why it’s not suitable:
RAG outputs are often semantically correct but worded differently, so BLEU can falsely score them low.
It does not evaluate whether retrieved documents were relevant.
When it can be used:
Simple NLP tasks like translation or templated text generation with fixed expected outputs.
Option B) Monitor response latency and token generation speed
This is purely a performance/observability metric, not an accuracy evaluation method.
Why it’s not suitable:
It does not assess correctness or relevance of answers.
A fast but incorrect answer is still a failure in RAG systems.
When it can be used:
System optimization for user experience, sc...
Author: NebulaEagle11 · Last updated Jul 19, 2026
An AI practitioner wants to use Retrieval Augmented Generation (RAG) architecture. However, company leadership thinks RAG will make the architecture too complex.
Whi...
Retrieval Augmented Generation (RAG) is primarily used to improve the factual accuracy of responses from large language models by grounding outputs in external, up-to-date knowledge sources (like vector databases or document stores).
Evaluating the options:
A) RAG improves large language model (LLM) inference time.
This is incorrect. RAG typically increases inference latency because it adds retrieval steps (querying a knowledge base, embedding search, reranking) before generation. While it improves answer quality, it does not optimize speed.
→ Use case where this would matter: systems prioritizing response quality over latency (e.g., enterprise Q&A, documentation assistants).
---
B) RAG improves model training speed.
Incorrect. RAG does not speed up training of the base model. In fact, most RAG systems do not retrain the LLM at all; they rely on external retrieval instead of additional training.
→ Use case where this misconception arises: teams trying to avoid fine-tuning costs by using retrieval instead.
---
C) RAG decreases hallucinations.
Correct. Thi...
Author: Krishna · Last updated Jul 19, 2026
A company plans to use a dataset to train a new AI model. The company needs to determine whether a bias against a specific user group exists in the dataset before the ...
The requirement is to detect whether bias exists in the dataset before training begins, i.e., pre-training data bias analysis. This points directly to tools that analyze training data distributions and fairness metrics prior to model training.
✅ Correct Option: A) Use Amazon SageMaker Clarify to compute pre-training bias metrics.
Amazon SageMaker Clarify is specifically designed to evaluate datasets before model training. It analyzes data for potential bias across features such as age, gender, or other sensitive attributes and provides pre-training bias metrics. This makes it the right choice for ensuring the dataset is fair before it is used for training.
---
Why other options are incorrect
❌ B) Use Amazon SageMaker Model Cards to compute pre-training bias metrics
Model Cards are used for documentation and reporting, not for computing bias metrics. They summarize model ...
Author: Ethan · Last updated Jul 19, 2026
A software development company wants to increase its speed to market delivery. The company needs a solution that helps developers generate real-time co...
The requirement is:
Increase speed to market (faster delivery)
Help developers generate real-time code and unit tests
This clearly points to an AI-assisted software development tool, not analytics or search services.
---
✅ Correct Answer: B) Amazon Q Developer
Why Amazon Q Developer is correct
Amazon Q Developer is an AI-powered assistant designed specifically for software development tasks. It helps developers:
Generate code in real time
Create unit tests automatically
Explain code and suggest improvements
Work inside IDEs like VS Code and JetBrains
Accelerate SDLC (Software Development Life Cycle)
Key reasoning factors:
Directly targets developers and coding workflow
Uses generative AI for code creation
Improves developer productivity and time-to-market
Designed for software engineering tasks (not business analytics or search)
This matches the requirement exactly: real-time code + unit test generation
---
❌ Why the other options are incorrect
A) Amazon Personalize
Amazon Personalize
Used for personalized recommendations (e.g., produc...
Author: Henry · Last updated Jul 19, 2026
Which benefit does a company gain by using ongoing pre-training to fine-tune a foundation model (FM)...
Correct concept: ongoing pre-training (also called continual pretraining or domain-adaptive pretraining) is used to keep a foundation model (FM) updated with new domain-specific or time-evolving data so it becomes more accurate and relevant over time.
---
✅ Correct Answer: B) Improved model performance over time
Ongoing pre-training continuously exposes the foundation model to new or domain-specific data before or alongside fine-tuning. This improves:
Knowledge freshness (recent data patterns)
Domain adaptation (e.g., legal, medical, financial text)
Overall downstream task accuracy
This is the key expected benefit in AWS exam contexts.
---
❌ Why other options are incorrect
A) Decreased model complexity
Ongoing pre-training does not simplify model architecture.
Model complexity (layers, parameters) remains unchanged.
When this would apply: Techniques like model pruning or distillation r...
Author: Noah · Last updated Jul 19, 2026
A company is preparing data to fine-tune a large language model (LLM). The company must follow the principles of responsible AI.
...
The question is about responsible AI when preparing data for fine-tuning an LLM, which mainly focuses on fairness, transparency, data quality, and reducing bias.
✅ Correct Options:
A) Include demographically diverse data sources to improve model fairness.
B) Apply consistent labeling standards across the training dataset.
---
✔️ Why A is correct (Fairness, Bias Reduction)
Including demographically diverse data sources helps ensure the model does not learn biased patterns from underrepresented groups.
Key reasoning factors:
Promotes fairness and inclusivity
Reduces model bias toward dominant groups
Improves generalization across user populations
When this applies:
Training customer support LLMs used globally
Healthcare or hiring-related AI systems where bias is critical
👉 This is a core Responsible AI principle in AWS: Fairness & Bias mitigation
---
✔️ Why B is correct (Data Quality, Consistency)
Applying consistent labeling standards ensures training data is reliable and interpretable.
Key reasoning factors:
Improves data quality and consistency
Reduces noise and labeling ambiguity
Leads to more stable and predictable model behavior
When this applies:
Supervised fine-tuning tasks (classification, instruction tuning)
Human-annotated datasets across multiple labelers or teams
👉 This supports Respo...
Author: Olivia · Last updated Jul 19, 2026
Which AWS service provides a broad range of high-performing generative AI foundation models (FMs)?
The correct answer is:
A) Amazon Bedrock
Why Amazon Bedrock is correct
Amazon Web Services Amazon Bedrock is the AWS service specifically designed to provide access to a broad range of high-performing foundation models (FMs) from leading AI companies (such as Anthropic, Meta, Cohere, etc.) through a single API.
Key exam factors:
It is a fully managed generative AI service
Provides multiple foundation models (text, image, multimodal)
Supports customization (fine-tuning, RAG integration)
No need to manage underlying infrastructure
Designed specifically for generative AI applications
Typical use cases:
Building chatbots using LLMs
Content generation (text, summarization, Q&A)
Retrieval-Augmented Generation (RAG) applications
Enterprise generative AI assistants
---
Why the other options are incorrect
B) Amazon Rekognition
Focus: Computer vision
Used for:
Image and video analys...
Author: Ella · Last updated Jul 19, 2026
A company has created an AI assistant to provide relevant information to employees about internal processes. The AI assistant uses a fine-tuned foundation model (FM). The company wants to use feedback from employ...
The requirement is: an internal AI assistant (fine-tuned foundation model) should improve its responses using feedback from employees. This is a classic “use human feedback to improve model behavior” problem.
Correct approach: C) Use reinforcement learning from human feedback (RLHF)
RLHF is specifically designed for scenarios where:
Users (employees) provide explicit feedback (ratings, preferences, rankings)
That feedback is used to train a reward model
The foundation model is then fine-tuned to maximize reward signals
It directly improves response quality, helpfulness, and alignment with user expectations
In AWS contexts, RLHF aligns with improving model behavior based on human preference signals, which is exactly what the question describes.
---
Why other options are incorrect
A) Implement model distillation ❌
Distillation is about compressing a large model into a smaller one
It transfers knowledge from a “teacher model” to a “student model”
It does not use employee feedback
Use case: deploying lightweight models for edge devices or cost reduction
👉 Not suitable because the goal is not model size reduction, but improving response quality using feedback
---
B) Perform continued pre-training and incorporate feedback from employee ratings ❌
Continued pre-training means training on large unlabeled domain-specific text data
...
Author: Kunal · Last updated Jul 19, 2026
A company has fine-tuned an Amazon Bedrock foundation model (FM) to produce short document summaries. The company wants an automated metric that compares each model-generated summary with i...
The correct choice is B) Recall-Oriented Understudy for Gisting Evaluation (ROUGE).
In this scenario, the company is evaluating short document summaries generated by a fine-tuned Amazon Bedrock foundation model against human-written reference summaries. This is a classic text summarization evaluation problem, where the goal is to measure how well the generated summary overlaps with a reference in terms of content coverage.
Why ROUGE (B) is correct
ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is specifically designed for:
Text summarization tasks
Machine translation evaluation (in some cases)
Comparing generated text against one or more reference texts
It works by measuring overlap of n-grams, word sequences, and longest common subsequences between the generated and reference summaries.
It is widely used in AWS and NLP benchmarks for summarization quality.
Key factors:
Focuses on content overlap
Supports reference-based evaluation
Common in summarization pipelines
Works well for extractive and abstractive summaries
---
Why the other options are incorrect
A) F1 Score
F1 score is used for classification tasks, not text generation.
It requires true positive...
Author: Manish · Last updated Jul 19, 2026
A company is building a chatbot. The chatbot uses a large language model (LLM) and answers customer questions about products. The company wants the chatbot to answer only product questions. The company does not want the chatbot to answer questio...
Key requirement
The chatbot must only answer product-related questions and refuse or avoid answering everything else, with least operational overhead.
This is essentially a topic restriction / scope control problem for an LLM-based chatbot.
---
Option A: Set guardrails on the LLM prompt template ✅ (Best choice)
Why this works
Prompt-level guardrails (also called system prompts or instruction constraints) can explicitly instruct the model:
“Answer only product-related questions”
“If the question is not about products, respond with a refusal or redirect”
“Do not answer any unrelated topics”
Modern LLMs are designed to follow these instructions reliably, especially when clearly defined in the system prompt.
Key advantages
Low operational overhead (no extra infrastructure or code logic)
Easy to update (just change prompt)
Works directly with the model behavior
Standard AWS best practice when using services like Amazon Bedrock
When this is used
Basic topic restriction
Content filtering at generation time
Lightweight governance rules
---
Option B: Write custom application logic to identify questions about other topics ❌
Why this is not ideal
This means building a separate classification system, such as:
Keyword filtering
Another ML model
Rule-based NLP system
Problems
High operational overhead
Requires maintenance and tuning
Adds latency (extra processing step)
Duplicates what LLM guardrails can already do
When this is used
High-security systems (banking, legal compliance)
When deterministic filtering is required before LLM input
Multi-tier moderation pipelines
---
...
Author: Maya · Last updated Jul 19, 2026
Which strategy will evaluate the performance of a foundation model (FM) in real-world applications?
The question asks for the best strategy to evaluate a foundation model (FM) in real-world applications (AWS exam context). The key idea is real-world performance, meaning how the model behaves with actual users and production-like traffic—not just offline metrics or internal analysis.
---
A) Conducting A/B testing with users in a controlled environment — ✅ Correct
A/B testing is the most reliable way to evaluate a foundation model in real-world or near-production scenarios.
Why it is correct:
It exposes the model to real user behavior and real inputs
Compares two or more model versions (A vs B) under the same conditions
Measures business and user-impact metrics (click-through rate, task success rate, satisfaction, latency, etc.)
Reflects production performance, not just theoretical accuracy
When this is used:
Deploying a new FM version in production
Comparing prompt strategies or fine-tuning approaches
Evaluating chatbot improvements, recommendation systems, or search relevance
This is the closest to real-world validation among all options.
---
B) Human evaluation by subject matter experts — ⚠️ Partially correct but not real-world performance
Why it is not the best answer:
Experts evaluate outputs in a static or sampled setting
Does not reflect real user diversity or live traffic conditions
Can be subjective and not scalable
When this is used:
Evaluating domain-specific correctness (medical, legal, financial text)
Fine-tuning feedback loops (RLHF-style...
Author: Charlotte · Last updated Jul 19, 2026
A financial company uses an ML model to detect potentially fraudulent transactions. The company needs to ensure that some types of predictions receive review by human analysts before the co...
The requirement is to force certain ML predictions (fraud cases) into human review before any business action is taken. This is a classic human-in-the-loop inference workflow problem.
---
✅ Correct Answer: C) Amazon Augmented AI (Amazon A2I)
Amazon Augmented AI (Amazon A2I) is specifically designed to insert human review steps into machine learning workflows, including real-time or batch inference.
In this scenario:
The ML model predicts whether a transaction is potentially fraudulent
Some predictions (e.g., high-risk or low-confidence cases) must be sent to human reviewers
Analysts review and approve/reject before action is taken
👉 This is exactly what Amazon A2I provides:
conditional routing of predictions to human review teams
---
❌ Why the other options are incorrect
A) Amazon SageMaker Clarify
Amazon SageMaker Clarify
Used for:
Detecting bias in training data and models
Explaining model predictions (feature importance, SHAP values)
❌ Not used for human review workflows
❌ Does not route predictions to humans
👉 Use case:
When you need fairness analysis or explainability reports, not o...
Author: Siddharth · Last updated Jul 19, 2026
A company runs an application on servers in an Amazon VPC. The company's application uses Amazon Bedrock APIs for AI features. The company does not want API calls to travel...
Key requirement
The company wants Amazon Bedrock API calls to NOT traverse the public internet while the application runs inside an Amazon VPC.
So we are looking for:
Private network connectivity from VPC → Bedrock
No internet gateway / NAT / public endpoint usage
AWS-native private access pattern
---
✅ Correct Answer: A) Use AWS PrivateLink to establish a private connection between the Amazon VPC and Amazon Bedrock.
Why A is correct
Amazon Web Services provides AWS PrivateLink, which allows private connectivity between a VPC and supported AWS services without using the public internet.
For Amazon Bedrock:
PrivateLink creates VPC interface endpoints
Traffic stays entirely on the AWS private network backbone
No need for Internet Gateway, NAT Gateway, or public IPs
Meets the requirement: “API calls do not travel across the public internet”
Key exam reasoning points:
PrivateLink = private service access inside AWS
Ideal for SaaS-like AWS services (Bedrock, S3, DynamoDB, etc.)
Ensures secure, internal routing
When A is used
Calling AWS services privately from VPC
Avoiding internet exposure for compliance/security
High-security workloads (AI/ML, finance, healthcare)
---
❌ Why other options are incorrect
B) Sign API requests using IAM access key and secret key
This only provides:
Authentication (who y...
Author: Victoria · Last updated Jul 19, 2026
A company is deploying a new AI application to generate content for internal users.
Which strategy will ...
Correct Answer: A) Decreasing the temperature
---
Why this is correct (key AWS AI/LLM reasoning)
In generative AI models (such as those used via AWS services like Amazon Bedrock or similar LLM endpoints), determinism refers to producing more consistent, repeatable outputs for the same input prompt.
✅ A) Decreasing the temperature — Correct
Temperature controls randomness in output generation.
Lower temperature (e.g., 0 to 0.3):
Makes the model more deterministic
Chooses higher-probability tokens more consistently
Reduces creativity and variability
At temperature = 0, outputs are typically most deterministic (greedy decoding behavior)
📌 When to use:
Internal enterprise content generation where consistency matters (policy docs, summaries, templates)
Automated reporting systems
Chatbots requiring stable responses
---
Why other options are incorrect
❌ B) Increasing the learning rate
Learning rate is used in training ML models, not inference/generation.
It affects how fast a model learns during training, not how outputs are generated.
📌 When it is used:
Training or fine-tuning models (e.g., SageMaker training jobs)
Not relevant for deploy...
Author: Aarav · Last updated Jul 19, 2026
A company maintains a large product catalog with detailed descriptions. The company wants to build an AI assistant to answer customer questions about the products. However, the company's labeled training data is l...
Key requirement analysis
Goal: AI assistant answering questions over a large product catalog with detailed descriptions
Constraint: Limited labeled training data
Objective: Least implementation effort
---
✅ Correct Approach: A) Retrieval Augmented Generation (RAG)
Why A is correct
Retrieval Augmented Generation (RAG) is designed exactly for this scenario:
No need for large labeled datasets → works with raw product documents
Uses existing product database as knowledge source
Retrieves relevant product descriptions at runtime and feeds them to the model
Keeps data fresh without retraining
Lowest operational and ML engineering overhead among options
Key AWS exam reasoning factors:
Data availability: Works even with minimal labeled data
Maintenance: Updates happen by updating the knowledge base, not model retraining
Scalability: Handles large catalogs efficiently via retrieval indexing (e.g., vector DB / OpenSearch / Kendra)
Accuracy: Grounded responses reduce hallucination
When RAG is used:
Product catalogs / documentation Q&A
Enterprise knowledge assistants
Dynamic or frequently updated content
---
❌ Why other options are incorrect
B) Fine-tune FM on limited labeled data
Requires high-quality labeled dataset, which is explicitly li...
Author: Emma · Last updated Jul 19, 2026
A company uses foundation models (FMs) to automate daily tasks. An AI practitioner at the company is creating system instructions that include context that is relevant to the tasks. The AI practitioner wants to save and reuse the instructions in da...
The requirement is to create system instructions (prompts) with contextual information and reuse them across daily interactions with foundation models in Amazon Bedrock.
The key phrase here is “save and reuse the instructions”, which directly points to a feature that manages, versions, and reuses prompts.
---
Correct Answer: D) Prompt management
Why Prompt management is correct
Amazon Bedrock Prompt management is designed specifically to:
Store reusable prompts (including system instructions, templates, and context)
Version and organize prompts for different use cases
Allow consistent reuse across applications and model invocations
Reduce duplication of prompt engineering effort
Support testing and iterative improvement of prompts
In this scenario, the AI practitioner is building system instructions with relevant context and wants to reuse them daily, which exactly matches prompt management capabilities.
---
Why the other options are incorrect
A) Knowledge Bases
Used for Retrieval-Augmented Generation (RAG)
Connects FMs to external/private data sources (documents, PDFs, databases)
Helps models retrieve...
Author: Olivia · Last updated Jul 19, 2026
What is an example of structured data?
Correct Answer: C) A CSV file that consists of measurement data
Why C is the correct choice (Structured Data)
Structured data is data that follows a predefined schema, typically organized into rows and columns, making it easily searchable and processable by machines. In AWS exam terms, it is highly suitable for storage in systems like relational databases (e.g., Amazon RDS) or analytics tools (e.g., Amazon Redshift).
A CSV file with measurement data fits this definition because:
It has a fixed format (comma-separated values)
Each row represents a record
Each column represents a consistent attribute (e.g., temperature, time, sensor ID)
It can be easily ingested into databases or analytics pipelines without heavy preprocessing
This makes it a classic example of structured data.
---
Why the other options are incorrect
A) A file of text comments from an online forum
This is unstructured data
Free-form text with no consistent schema
Re...
Author: IceDragon2023 · Last updated Jul 19, 2026
A company wants to use a large language model (LLM) to generate responses based on company data.
...
The key requirement is: the LLM must generate responses using company data. In AWS architecture, the best practice is to avoid baking company data into the model weights (fine-tuning) and instead use a pre-trained foundation model with retrieval of company data at runtime (typically via Amazon Bedrock Knowledge Bases or RAG pattern).
Evaluation of options
A) Use first-party pre-trained models from Amazon Bedrock
These include AWS-hosted foundation models (e.g., Amazon Titan models).
Strength: Fully managed, secure, and optimized for AWS ecosystem.
Limitation: By itself, it does not inherently incorporate company data—you still need RAG/Knowledge Base integration.
Use case: When you want AWS-native models for summarization, Q&A, or chat with RAG on private data.
B) Use pre-trained open source models
These require self-hosting (e.g., on EC2 or SageMaker).
Higher operational overhead (scaling, patching, security).
Not ideal for enterprise “managed LLM” exam scenarios.
Use case: Highly customized environments or cost-sensitive deployments with strong MLOps capability.
C) Fine-tune a custom model on company data
Not recommended for “company data Q&A” use cases.
Fine-...
Author: Ishaan · Last updated Jul 19, 2026
A company built an AI chatbot. The chatbot uses large language models (LLMs) to answer user questions. The company wants to keep the chatbot's LLM instruc...
The correct answer is B) Prompt leakage.
Why Prompt leakage is correct
Prompt leakage refers to a security risk where a user is able to extract or infer the hidden system instructions, developer prompts, or internal configuration used to control an LLM’s behavior.
In this scenario:
The company explicitly wants to keep the chatbot’s LLM instructions private.
Attackers may try techniques like prompt injection (“Ignore previous instructions…”, “What were your system instructions?”) to reveal hidden prompts.
If successful, sensitive system instructions (which may include business logic, safety rules, or proprietary prompting strategies) can be exposed.
This is a well-known LLM security concern in AWS-related AI security contexts (often discussed under prompt injection and prompt extraction risks).
When this applies:
Protecting system prompts or hidden instructions in chatbots
Preventing users from reverse-engineering LLM behavior
Securing multi-tenant or enterprise LLM applications
---
Why the other options are incorrect
A) Data poisoning
Data poisoning refers to corrupting the training data of a model to influence its behavior.
This is a training-time attack, not a runtime prompt exposure issue.
It wou...
