Amazon Practice Questions, Discussions & Exam Topics by our Authors
A company wants to identify harmful language in the comments section of social media posts by using an ML model. The company will not use labeled data to train the mode...
Let's analyze each option based on the key factor that the company will not use labeled data to train the model and wants to identify harmful language in social media comments.
---
Option A: Use Amazon Rekognition moderation
What it is: Amazon Rekognition is primarily an image and video analysis service, including moderation of visual content (e.g., nudity, violence).
Relevance: It does not analyze text or language.
Reason for rejection: Since the task is to detect harmful language in text comments, Rekognition is not applicable here.
---
Option B: Use Amazon Comprehend toxicity detection
What it is: Amazon Comprehend provides natural language processing services, including pre-built models for detecting sentiment, entities, and specifically toxicity or harmful language in text.
Relevance: It uses pre-trained models, so no labeled data is required from the customer side.
Reason for selection: This fits the requirement perfectly because the company can directly analyze text for harmful language without needing to train or label their own datas...
Author: Grace · Last updated Jul 19, 2026
A media company wants to analyze viewer behavior and demographics to recommend personalized content. The company wants to deploy a customized ML model in its production environment. The company also wants to observe if...
Let's analyze the requirements and the given AWS options carefully:
Requirements:
1. Analyze viewer behavior and demographics to recommend personalized content
This implies building a customized ML model (likely a recommendation or prediction model based on user data).
2. Deploy the customized ML model in production environment
Need a service that supports custom ML model deployment.
3. Observe if the model quality drifts over time
Need model monitoring capabilities to detect data or model performance drift.
---
Evaluating the options:
A) Amazon Rekognition
What it is: A pre-built service for image and video analysis (facial recognition, object detection, etc.).
Use case: Analyzing visual media, not designed for custom model building or monitoring model drift.
Why rejected: It doesn’t support custom ML model deployment or model drift monitoring. Also, it’s not intended for viewer behavior/demographics data analysis directly.
B) Amazon SageMaker Clarify
What it is: A tool to detect bias and explain model predictions.
Use case: Helps with model interpretability and bias detection before deployment.
Why rejected: It does not handle mo...
Author: Isabella · Last updated Jul 19, 2026
A company is deploying AI/ML models by using AWS services. The company wants to offer transparency into the models' decision-making processes and provide explanations for t...
Let's analyze each option in the context of the company's need: offering transparency into AI/ML model decision-making and providing explanations for model outputs.
---
A) Amazon SageMaker Model Cards
What it is: Model Cards in Amazon SageMaker are designed specifically to document details about machine learning models, including their intended use cases, performance metrics, data characteristics, and importantly, explainability features.
Relevance: Model Cards help provide transparency and explainability by documenting how a model works and its decision rationale, fulfilling the requirement of explaining model outputs.
When to use: Best when deploying ML models and wanting to provide users or stakeholders with detailed, transparent information about model behavior, limitations, and explanations.
Key factors: Built into SageMaker, tightly integrated with model deployment, directly supports explainability and transparency.
---
B) Amazon Rekognition
What it is: A service for image and video analysis using pre-trained deep learning models.
Relevance: Rekognition can provide outputs like object detection, face recognition, or text in images, but it does not inherently provide explainability or transparency features for the decision process.
When to use: Use when you want to analyze images/videos but not for explaining the model’s decision-making process in general ML deployments.
Why rejected: It does not support explaining or prov...
Author: Liam · Last updated Jul 19, 2026
A manufacturing company wants to create product descriptions in multiple languages.
Which AWS ser...
Let's analyze each AWS service option based on the requirement: automate creating product descriptions in multiple languages.
---
A) Amazon Translate
Purpose: Amazon Translate is a fully managed neural machine translation service that provides fast, high-quality, and customizable language translation.
Key Factor: It can translate large volumes of text from one language to another automatically.
Use Case Fit: Perfect for translating product descriptions into multiple languages without manual effort.
Why Selected: This service directly addresses the need for multilingual text generation.
---
B) Amazon Transcribe
Purpose: Amazon Transcribe converts speech to text (speech recognition).
Key Factor: It is designed for transcription of audio, not for translation or text generation.
Use Case Fit: Used when you want to transcribe spoken content like call center conversations or meetings.
Why Rejected: The task requires text translation, not converting speech to text.
---
C) Amazon Kendra
Purpose: Amazon Kendra is an intelligent search service po...
Author: Ryan · Last updated Jul 19, 2026
SNAPSHOT
-
A company wants more customized responses to its generative AI models' prompts.
Select the correct customization methodology from the followi...
Author: ElectricLionX · Last updated Jul 19, 2026
Which AWS feature records details about ML instance data for governance and reporting?
Let's analyze each option in the context of recording details about ML instance data for governance and reporting:
---
A) Amazon SageMaker Model Cards
Purpose: Model Cards provide documentation and transparency about ML models, including intended use, performance metrics, and ethical considerations.
Use case: Primarily for model documentation, transparency, and governance at a high level.
Why rejected: While important for governance, Model Cards do not record or monitor live instance data or dataset quality during model training or deployment. They focus more on static metadata and documentation, not operational data logging or monitoring.
---
B) Amazon SageMaker Debugger
Purpose: Provides real-time debugging and profiling of ML training jobs by capturing system metrics, tensors, and performance data.
Use case: Useful for debugging model training to identify bottlenecks or anomalies.
Why rejected: Debugger focuses on performance and debugging during training, not long-term governance or continuous monitoring of data quality or drift for reporting purposes.
---
C) Amazon SageMaker Model Monitor
Purpose: Continuously monitors ML models in p...
Author: John · Last updated Jul 19, 2026
A financial company is using ML to help with some of the company's tasks.
Which option is a use o...
Let's analyze each option carefully to determine which one is a use of generative AI models, considering key factors:
---
A) Summarizing customer complaints
What it involves: Taking large text data (customer complaints) and generating a concise summary.
Relation to generative AI: This involves generating new text that captures the essence of the original text. Generative AI models like GPT or other language models are designed for tasks like summarization, text generation, and natural language understanding.
Key factor: The output is newly generated text based on input data.
Verdict: This is a classic use case for generative AI.
---
B) Classifying customers based on product usage
What it involves: Assigning categories or labels (like "heavy user," "casual user") to customers based on their product usage data.
Relation to generative AI: This is a discriminative task — the model predicts existing labels rather than generating new content.
Key factor: Classification tasks typically use discriminative models (e.g., decision trees, logistic regression, or classification neural networks) rather than generative models.
Verdict: Not a generative AI use case.
---
C) Segmenting customers based on type of investmen...
Author: StarlightBear · Last updated Jul 19, 2026
A medical company wants to develop an AI application that can access structured patient records, extract relevant information, and generate conc...
Let's analyze each option carefully based on the requirements:
Requirements:
Access structured patient records (so data is already digital and organized).
Extract relevant information (medical entities and relationships).
Generate concise summaries.
---
Option A: Amazon Comprehend Medical + rule-based logic
Amazon Comprehend Medical is specifically designed to extract medical entities (like conditions, medications, treatments) and relationships from unstructured medical text.
It can process structured or unstructured text, making it ideal for medical records.
Combining this with rule-based logic to structure and format the extracted info into summaries fits the requirement perfectly.
Key factor: specialized medical NLP service for entity extraction and relationship understanding.
Use case scenario: Best when you want medically accurate, domain-specific extraction and customized summaries from patient records.
---
Option B: Amazon Personalize + general summarization tool
Amazon Personalize is designed for building personalized recommendation systems based on user behavior data.
It’s about analyzing engagement patterns, not extracting medical info or summarizing text.
Using it here would be irrelevant and ineffective for medical record summarization.
Key factor: Not intended for text extraction or summarization; focused on personalization/recommendation.
Use case scenario: Best for tailoring user experiences or recommendations, not text summarization.
---
Option C: Amazo...
Author: William · Last updated Jul 19, 2026
Which option describes embeddings in the context of AI?
Correct Option: D) A numerical method for data representation in a reduced dimensionality space
✅ Why D is the correct option:
Embeddings in AI are numerical representations of data (like words, images, or users) in a lower-dimensional vector space. This allows models to process and analyze complex input efficiently while preserving semantic or structural relationships. Common examples include word embeddings like Word2Vec or GloVe, which map words to vectors based on context and similarity.
Key factors:
Dimensionality reduction: Transforms high-dimensional data into compact vectors.
Preserves semantic meaning: In NLP, similar words have similar embeddings.
Usability: Used in recommendation systems, search ranking, image recognition, etc.
Typical scenario: In a chatbot, embeddings help convert user input into vector representations so that the model can find semantically similar responses.
---
❌ Why the other options are incorrect:
A) A method for...
Author: Olivia Johnson · Last updated Jul 19, 2026
A company is building an AI application to summarize books of varying lengths. During testing, the application fails to summarize some book...
The most likely reason the application fails to summarize some books is:
---
Option A: The temperature is set too high
Rejected.
Temperature controls the randomness of the output — a high value (closer to 1) makes the output more creative and diverse, while a lower value makes it more deterministic. While this affects the quality or consistency of the summaries, it would not cause the model to fail or crash during summarization. This parameter is about response variability, not functional failure.
Scenario where it matters: When you want more deterministic (low temperature) or creative (high temperature) outputs, such as poetry or story generation.
---
Option B: The selected model does not support fine-tuning
Rejected.
Fine-tuning allows customizing a model to specific data or tasks. However, fine-tuning is not required for summarizing books. Pre-trained models like GPT-4 can already summarize well without fine-tuning. The application may not fail — it just might give generic summaries. Also, failure to fine-tune doesn't cause token-length-related crashes or errors.
Scenario where it matters: When the summarization style or domain (e.g., legal or medical texts) requi...
Author: Maya · Last updated Jul 19, 2026
An airline company wants to build a conversational AI assistant to answer customer questions about flight schedules, booking, and payments. The company wants to use large language models (LLMs) and a knowledge base to create a text-base...
To determine the best solution for building a text-based conversational AI assistant that answers questions about flight schedules, booking, and payments, we must consider the key factors:
Key Factors:
Development effort: The company wants the least development effort.
Conversational ability: Needs natural language understanding and generation.
Knowledge base integration: Requires up-to-date, accurate responses based on business-specific info.
Maintainability and scalability.
---
Option A: Train models on Amazon SageMaker Autopilot
Use case: Autopilot is for tabular data ML problems like classification, regression.
Why rejected: It is not optimized for conversational AI or natural language understanding tasks. Requires labeled data and ML expertise.
Scenario where useful: Predicting customer churn, pricing models.
Effort: High, due to dataset preparation, training, and integration with a chatbot.
---
Option B: Develop a Retrieval Augmented Generation (RAG) agent by using Amazon Bedrock
Use case: Ideal for combining LLMs with a knowledge base (FAQs, docs, flight info).
Why selected:
Uses fully managed foundation models (FM) like Anthropic Claude, AI21, Meta, etc.
Requires no model training.
Easily integrates RAG with knowledge bases (Amazon Kendra, S3, etc.).
Built-in support for text-based chat interfaces and enterprise search.
...
Author: Zain · Last updated Jul 19, 2026
What is tokenization used for in natural language processing (NLP)?
Tokenization in Natural Language Processing (NLP) is the process of breaking down text into smaller units such as words, subwords, or sentences. This is a fundamental preprocessing step in NLP, allowing algorithms to work with manageable and meaningful chunks of language.
Let’s analyze each option:
---
A) To encrypt text data
Rejected: Encryption is a security task, unrelated to linguistic structure or meaning.
Used when? In cybersecurity or secure communication, not NLP.
Key Factor: Tokenization deals with structure; encryption deals with confidentiality.
---
B) To compress text files
Rejected: Compression reduces file size using algorithms like Huffman coding or LZW.
Used when? In storage or transmission optimization, not language understanding.
...
Author: Aditya · Last updated Jul 19, 2026
Which option is a characteristic of transformer-based language models?
Let's analyze each option based on key characteristics of transformer-based language models:
---
A) Transformer-based language models use convolutional layers to apply filters across an input to capture local patterns through filtered views.
Rejected.
This describes convolutional neural networks (CNNs), not transformers. While CNNs are great at capturing local patterns in data (especially images), transformers rely on self-attention mechanisms rather than convolution. Transformers can model both local and global dependencies without the inductive bias of local receptive fields in CNNs.
Use case for CNNs: Image recognition or tasks with strong local structure.
Why not transformer: Transformers use attention, not convolutional filters.
---
B) Transformer-based language models can process only text data.
Rejected.
Transformers were originally designed for NLP, but they’ve since been adapted for various data types, including images (Vision Transformers), audio, code, and even multimodal data (e.g., combining text and images). So, they are not limited to only text data.
Use case for text-only models: Traditional NLP tasks like sentiment analysis or trans...
Author: SolarFalcon11 · Last updated Jul 19, 2026
A financial company is using AI systems to obtain customer credit scores as part of the loan application process. The company wants to expand to a new market in a different geographic area. The company must ensure tha...
To determine which compliance laws a financial company must review when expanding to a new geographic market while using AI to obtain customer credit scores, we must examine the nature of the company's operations and the regulatory relevance of each option.
---
Key Operational Factors:
Industry: Financial services (loan applications).
Activity: Use of AI systems for assessing customer credit scores.
Expansion goal: Entering a new geographic area, which implies local legal compliance is essential.
---
Option Analysis:
A) Local health data protection laws
Use Case: Regulates the collection and use of personal health data (e.g., HIPAA in the U.S.).
Relevance: Not applicable here. The company is working with financial and credit data, not health data.
Scenario for Use: Would apply if the company were handling medical records or insurance underwriting based on health data.
✅ Rejected – Does not apply to financial or AI-based credit scoring.
---
B) Local payment card data protection laws
Use Case: Protects credit/debit card information (e.g., PCI DSS standards).
Relevance: Only relevant if the company directly processes card payments, which is not part of the credit score assessment process.
Sc...
Author: Vivaan · Last updated Jul 19, 2026
A company uses Amazon Bedrock for its generative AI application. The company wants to use Amazon Bedrock Guardrails to detect and filter harmful user inputs and model-generated ...
To determine which two content categories Amazon Bedrock Guardrails can filter, let’s break down the options based on how Bedrock Guardrails are designed and the key factors Amazon uses to classify content risks.
---
✅ Key Features of Amazon Bedrock Guardrails
Amazon Bedrock Guardrails can detect and filter harmful or inappropriate content across specific high-risk categories. The categories align with safety, ethics, and compliance concerns in AI applications. These include:
Hate and Harassment
Violence
Sexual content
Criminal activity
Insults or profanities
These categories help organizations ensure responsible AI use by moderating inputs/outputs.
Now, let’s evaluate the options:
---
Option A: Hate ✅
Why selected:
Hate speech falls directly under Amazon’s “Hate and Harassment” category, which is a primary focus of Bedrock Guardrails. This includes:
Discrimination based on race, gender, religion, or identity.
Harassment or toxic content.
Scenario:
A chatbot for customer service should reject inputs like racial slurs or offensive political statements. Guardrails detect and block this.
Conclusion: Strong alignment with Bedrock Guardrail goals.
Selected.
---
Option B: Politics ❌
Why rejected:
Politics as a general topic is not inherently harmful or unsafe, so Bedrock Guardrails do not block political content by default. While politically sensitive content might escalate to harmful speech (like hate or misinformation), “politics” alone is too broad and subjective to be filte...
Author: Maya · Last updated Jul 19, 2026
Which scenario describes a potential risk and limitation of prompt engineering in the context of a g...
To evaluate which scenario best describes a potential risk and limitation of prompt engineering in the context of generative AI, we must examine each option in terms of key factors such as security vulnerabilities, output consistency, reliability with real-world data, and misconceptions about prompt engineering guarantees.
---
🔍 Option Analysis:
A) Prompt engineering does not ensure that the model always produces consistent and deterministic outputs, eliminating the need for validation.
Why it's incorrect:
This option contains a logical contradiction. It says prompt engineering does not ensure consistency but then claims it eliminates the need for validation. This suggests a misunderstanding of the role of prompt engineering. In reality, prompt engineering alone is insufficient to guarantee determinism, and validation is still required, especially in critical applications. The risk is framed incorrectly, so this option is rejected.
B) Prompt engineering could expose the model to vulnerabilities such as prompt injection attacks.
Why it's correct:
This highlights a real security vulnerability. Prompt injection is a known attack vector where malicious inputs can alter or hijack the behavior of the model. Even well-crafted prompts can be manipulated or exploited if the input channel isn't properly sanitized. This is a direct risk associated with how prompts are engineered and used dynamically, especially in user-facing applications like chatbots, copilots, and AI assistants.
Scenario where it's applicable:
In applications where user input is dynamically added to prompts (e.g., AI-powered help desks or code generation assistants), attackers may inject malicious content that causes unintended behavior. Prompt engineering must account for input sanitization and context management to mitigate this.
C) Properly designed prompts reduce but do not eliminate the risk of data poisoning or model hijacking.
...
Author: Liam123 · Last updated Jul 19, 2026
A publishing company built a Retrieval Augmented Generation (RAG) based solution to give its users the ability to interact with published content. New content is published daily. The company wants to provide a near real-time experience to users.
Which steps in the R...
To determine which steps in the Retrieval-Augmented Generation (RAG) pipeline should be implemented using offline batch processing, we need to analyze the nature of each step in terms of its data freshness requirements, computational cost, and latency sensitivity.
Let’s break down each option:
---
A) Generation of content embeddings ✅
What it is: Creating vector representations of new documents/content.
Key factors:
Content is published daily, not in real-time.
Embeddings for content don’t change once generated.
Can be precomputed before user interaction.
Scenario: Suitable for offline batch processing because it’s not time-sensitive once content is finalized and doesn’t require instant computation.
✅ Selected
---
B) Generation of embeddings for user queries ❌
What it is: Turning user’s real-time question into an embedding to search relevant documents.
Key factors:
Happens at query time, unique per interaction.
Requires low latency.
Cannot be precomputed, as user queries are dynamic.
Scenario: Requires online processing, not suitable for batch mode.
---
C) Creation of the search index ✅
What it is: Building or updat...
Author: Mia · Last updated Jul 19, 2026
Which technique breaks a complex task into smaller subtasks that are sent sequentially to a large la...
Let's analyze each option based on the requirement:
Technique that breaks a complex task into smaller subtasks and sends them sequentially to an LLM.
---
A) One-shot prompting
Key factor: One-shot prompting means providing the model with a single example (or prompt) to perform a task.
Usage: The entire task is attempted in one go, without breaking it down.
Scenario: Useful when you want the model to generalize from one example immediately.
Verdict: Does not break tasks into smaller subtasks or sequential steps.
---
B) Prompt chaining
Key factor: Prompt chaining refers to breaking a complex problem into multiple smaller prompts executed in sequence, where each prompt's output can feed into the next.
Usage: Useful for complex workflows that require stepwise reasoning or multi-stage processing.
Scenario: Ideal for tasks where intermediate steps matter, e.g., multi-step math problems, multi-turn reasoning.
Verdict: Correct choice that matches the description.
---
C) Tree of thoughts
Key factor: Tree of thoughts is...
Author: ElectricLionX · Last updated Jul 19, 2026
A company wants to collaborate with several research institutes to develop an AI model. The company needs standardized documentation of model version tracking and a ...
Let's analyze each option based on the company's need for standardized documentation of model version tracking and a record of model development across collaboration with research institutes.
---
A) Track the model changes by using Git
Pros:
Git is a powerful version control system widely used for source code and documentation.
It can track changes over time, support collaboration, branching, and merging.
Can manage code and documentation, including model training scripts and configurations.
Cons:
Git tracks files but doesn't inherently support AI/ML model metadata, model evaluation metrics, or detailed experiment tracking.
Tracking large model files directly in Git is inefficient.
Lacks built-in structured model versioning or standardized model documentation specifically for AI models.
Use case: Good for tracking code and text files, but not ideal for detailed AI model version tracking and development history.
---
B) Track the model changes by using Amazon Fraud Detector
Pros:
Amazon Fraud Detector is a managed service specialized in detecting fraud using ML.
It helps create and manage fraud detection models.
Cons:
Not a general model tracking or documentation tool.
Designed specifically for fraud detection use cases, not for model version tracking or documentation.
Does not meet requirements for standardized documentation or cross-institute collaboration on general AI models.
Use case: Only suitable for fraud detection ML models, irrelevant for general AI model version tracking/documentation.
---
C) Track the model changes by using Amazon SageMaker Model Cards...
Author: Mia · Last updated Jul 19, 2026
What is the purpose of chunking in Retrieval Augmented Generation (RAG)?
Let's analyze each option carefully with respect to the purpose of chunking in Retrieval Augmented Generation (RAG):
---
A) To avoid database storage limitations for large text documents by storing parts or chunks of the text
Reasoning:
Chunking does break large documents into smaller pieces, but the primary motivation in RAG is not just to avoid storage limits. Most modern vector databases can store large amounts of data, and chunking is not primarily for avoiding storage limits.
When it can be used:
This option could be valid in systems with strict storage or document size limits, but it's not the core reason in RAG architectures.
Verdict: Not the main purpose of chunking in RAG.
---
B) To improve efficiency by avoiding the need to convert large text into vector embeddings
Reasoning:
This option implies chunking avoids embedding large texts. However, chunking actually involves splitting a large text into smaller chunks to embed each chunk separately. This means you still have to embed all chunks; chunking doesn't avoid embedding but makes embedding manageable.
When it can be used:
Not applicable because chunking still requires embedding each chunk; it doesn't skip or avoid embeddings.
Verdict: Incorrect purpose; chunking doesn't avoid embeddings but structures data for embedding.
---
C) To improve the contextu...
Author: Zara · Last updated Jul 19, 2026
A company is developing an editorial assistant application that uses generative AI. During the pilot phase, usage is low and application performance is not a concern. The company cannot predict application usage after the application is ...
Let's analyze each option against the key factors:
Key factors:
Pilot phase usage is low.
Performance is not currently a concern.
Future usage is unpredictable.
Goal is to minimize costs.
---
A) Use GPU-powered Amazon EC2 instances
Pros: Complete control over infrastructure and performance tuning.
Cons: Requires manual management of instances, scaling, and cost optimization. GPU instances are expensive, and running them continuously can lead to high costs, especially if usage is low or unpredictable.
When to use: Best for workloads with predictable usage patterns or where customized model training or inference is needed at scale.
Why rejected here: Since usage is low and unpredictable, and cost minimization is important, this approach is likely over-provisioned and costly for the pilot and unknown future usage.
---
B) Use Amazon Bedrock with Provisioned Throughput
Pros: Provides dedicated capacity and guaranteed performance.
Cons: You pay for provisioned throughput whether you use it or not, leading to higher costs during low or unpredictable usage.
When to use: Ideal for applications with steady, predictable high throughput requirements where consistent performance is critical.
Why rejected here: Because usage is currently low and unpredictable, paying for provisioned throughput would be unnecessarily expensive.
---
C) Use Amazon Bedrock with On-Demand Throughput
Pros: Automatically scales with usage; you pay only for what you use.
Co...
Author: Maya · Last updated Jul 19, 2026
A company deployed a Retrieval Augmented Generation (RAG) application on Amazon Bedrock that gathers financial news to distribute in daily newsletters. Users have recently reported politically influenced ideas ...
Let's analyze each option based on the need:
Identify and filter politically influenced content from newsletters generated by a RAG application on Amazon Bedrock.
---
A) Word filters
Key factor: Word filters typically block or flag specific words or phrases.
Usage: Good for filtering explicit or offensive language but may miss nuanced or indirect politically influenced ideas.
Scenario: Effective for straightforward keyword blocking, less so for complex ideological content.
Verdict: Too simplistic for identifying nuanced political bias.
---
B) Denied topics
Key factor: Denied topics allow blocking entire subject areas or themes.
Usage: Can prohibit generation or inclusion of content related to specific sensitive or disallowed topics (e.g., politics, religion).
Scenario: Suitable to block broad categories of content like political discussions.
Verdict: Very relevant for filtering politically influenced ideas.
---
C) Sensitive information filters
Key factor: These filters are designed to detect and protect personally identifiable information (PII), confiden...
Author: Jack · Last updated Jul 19, 2026
A financial company is developing a fraud detection system that flags potential fraud cases in credit card transactions. Employees will evaluate the flagged fraud cases. The company wants to minimize the amount of time the employees spend reviewing...
Let's analyze the problem carefully:
Scenario:
A fraud detection system flags credit card transactions as potentially fraudulent.
Employees review flagged cases.
The company wants to minimize employee time spent reviewing cases that are flagged but are NOT actually fraudulent.
This means false positives (cases flagged as fraud but are actually legitimate) are costly in terms of employee time.
---
Evaluation Metrics Analysis:
A) Recall:
Recall = (True Positives) / (True Positives + False Negatives)
It measures how many actual fraud cases are detected out of all actual fraud cases.
High recall means fewer fraud cases are missed.
Does NOT focus on reducing false positives.
In this case, recall maximizes catching fraud, but might flag many legitimate transactions too — increasing employee review time.
Not suitable here because the priority is reducing false positives.
---
B) Accuracy:
Accuracy = (True Positives + True Negatives) / Total cases.
It measures overall correctness of the model.
However, in fraud detection, fraud cases are usually very rare (imbalanced data).
A model predicting "no fraud" all the time can have high accuracy but is useless.
Accuracy ignores the trade-off between false positives and false negatives and is n...
Author: StarryEagle42 · Last updated Jul 19, 2026
A company designed an AI-powered agent to answer customer inquiries based on product manuals.
Which strategy can improve custom...
Let's analyze each option carefully based on key factors that impact customer confidence in AI-powered agent responses:
---
A) Writing the confidence level in the response
Pros: Shows transparency by indicating how sure the AI is about its answer.
Cons: Customers may misinterpret low confidence scores as a sign of unreliability or get confused if they don’t understand confidence metrics. It might undermine trust rather than build it if the confidence is low or not clearly explained.
Use case: Good for internal or technical users who understand AI confidence levels but less effective for general customers.
---
B) Including referenced product manual links in the response
Pros: Provides direct evidence backing the response. Customers can verify the answer by themselves, which greatly improves trust and confidence. It makes the AI appear more transparent and credible by linking to authoritative sources.
Cons: Requires the manuals to be accessible and well-indexed; might slightly slow response generation if fetching links dynamically.
Use case: Excellent for any customer-facing scenario where verification of information increases trust.
---
C) Designing an agent avatar that looks like a computer
Pros: May create a visual identity for the agent.
Cons: The avatar’s appearance has minimal impact on confidence in content accuracy. Customers focus more on the quality and trustworthiness of the information than on h...
Author: Sofia · Last updated Jul 19, 2026
A hospital developed an AI system to provide personalized treatment recommendations for patients. The AI system must provide the rationale behind the recommendations and make the insights accessible to do...
Let's analyze the scenario and the options based on the key factors involved:
Scenario:
An AI system provides personalized treatment recommendations.
The AI must explain the rationale behind the recommendations.
The insights must be accessible to both doctors and patients.
---
Option A: Explainability
Key factor: AI systems should provide transparent, understandable reasons for their outputs, especially in critical domains like healthcare.
Why it fits:
The AI must explain the rationale behind its recommendations, which directly aligns with explainability.
Making insights accessible means the explanations should be understandable by human users (doctors and patients).
Explainability ensures trust, helps in verifying AI decisions, and supports informed consent in healthcare.
Option B: Privacy and Security
Key factor: Protecting patient data and ensuring confidentiality.
Why it doesn’t fit:
The scenario does not mention data protection, privacy concerns, or securing information.
While privacy is critical in healthcare AI, it’s not the focus here.
Op...
Author: Matthew · Last updated Jul 19, 2026
Which statement presents an advantage of using Retrieval Augmented Generation (RAG) for natural lang...
Let's analyze each option carefully with key factors about Retrieval Augmented Generation (RAG):
---
A) RAG can use external knowledge sources to generate more accurate and informative responses.
Key factor: RAG combines retrieval of relevant documents or knowledge from external databases (like Wikipedia, knowledge bases, or any text corpora) with generation from a language model.
Advantage: This means it can ground its responses in up-to-date or domain-specific data, improving accuracy and informativeness beyond what the pretrained model alone contains.
Scenario: Useful in question answering, open-domain chatbots, or any NLP task requiring current or specialized information.
Verdict: Correct and directly describes the main benefit of RAG.
---
B) RAG is designed to improve the speed of language model training.
Key factor: RAG is not specifically about speeding up training but about improving generation quality by incorporating retrieval.
Reality: Training language models is still computationally heavy; RAG’s focus is more on inference-time augmentation rather than traini...
Author: SilverBear · Last updated Jul 19, 2026
A company is building a new application that ingests CSV files into Amazon Redshift. The company has developed the frontend for the application.
The files are stored in an Amazon S3 bucket. Files are no larger than 5 MB.
A data engineer is developing the extract, transform, and load (ETL) pipeline for the CSV files. The data engineer configured a Redshift cluster and an AWS La...
The key requirement is:
New CSV files are uploaded to Amazon S3
Automatically invoke the existing Lambda function
Lambda loads data into Amazon Redshift
Files are small (≤ 5 MB)
Need an event-driven ETL pipeline
Let's evaluate each option.
---
Option A
> Configure the bucket to send S3 event notifications to Amazon EventBridge. Configure an EventBridge rule that matches S3 new object created events. Set the Lambda function as the target.
How it works
```
User uploads CSV
│
▼
Amazon S3
│
Object Created Event
▼
EventBridge
│
Rule
▼
Lambda
│
COPY into Redshift
```
Why this works
S3 can publish Object Created events to Amazon EventBridge.
EventBridge can directly invoke Lambda.
This creates a fully serverless event-driven architecture.
Key factors
✔ Event-driven
✔ No polling
✔ Minimal components
✔ Native AWS integration
✔ Low latency
When to use
Use this when:
You want direct event processing
No buffering is required
Event volume is manageable
Missing an occasional duplicate isn't a concern (Lambda should be idempotent)
This is the simplest and most AWS-recommended architecture.
---
Option B
> Configure the S3 bucket to send S3 event notifications to an Amazon SQS queue. Configure the Lambda function to process the queue.
Architecture:
```
S3
│
▼
SQS
│
▼
Lambda
│
▼
Redshift
```
Why it works
S3 supports sending notifications directly to SQS.
Lambda natively polls SQS.
This is also a valid event-driven architecture.
Advantages
Durable message storage
Automatic retries
Decouples producer and consumer
Handles traffic bursts
Why it is not selected
The question doesn't mention:
traffic spikes
reliability concerns
buffering
asynchronous decoupling
Adding SQS introduces an extra service without a stated requirement.
AWS exam questions usually prefer the simplest architecture that satisfies the requirements.
When should you use SQS?
Use SQS when:
Lambda may become overloaded
You need retries
You need buffering
Processing can happen later
High-scale ingestion
---
Option C
> Configure AWS DMS to stream new S3 objects to Amazon Kinesis Data Streams.
Why this is wrong
AWS Database Migration Service is designed for:
database migrations
continuous database replication
CDC (Change Data Capture)
It is not intended to detect new files in S3 and stream them...
Author: Ethan · Last updated Jul 10, 2026
An ecommerce company collects daily customer transaction logs in CSV format and stores the logs in Amazon S3. The company uses Amazon Athena to scan a subset of attributes from the logs on the same day the company receives each log.
Query times are increasing because of increasing transaction volu...
Key requirements in the question
Focus on the keywords:
Amazon Athena
CSV logs
Scans a subset of attributes (only a few columns are queried)
Daily logs
Query times are increasing
Wants the SHORTEST query times
These clues immediately suggest:
Use a columnar storage format (Parquet or ORC), since Athena reads only required columns.
Partition by date, because queries are performed on daily logs.
Enable predicate/column pushdown to reduce data scanned.
---
Evaluate each option
A) Convert the CSV logs into multiple ORC files for better parallelism in Athena. Partition by date in Amazon S3. Use columnar pushdown filters.
Why this is good
This option contains several performance best practices.
Key factors
✅ ORC is a columnar format
Athena reads only requested columns.
Huge reduction in data scanned compared to CSV.
✅ Multiple ORC files
Athena is a distributed query engine.
Multiple reasonably sized files allow more workers to scan in parallel.
Better than one very large file.
✅ Partition by date
Daily queries only read one partition.
Prevents scanning historical data.
✅ Columnar pushdown
Reads only needed columns.
Since the question explicitly says subset of attributes, this is extremely beneficial.
Why this is very strong
It optimizes
Storage format
Parallelism
Partition pruning
Column pruning
All major Athena optimizations.
---
B) Convert the CSV logs to JSON. Partition by date in Amazon S3. Use Athena with dynamic filtering to reduce data scans.
Why rejected
JSON is not columnar.
Athena must parse the whole JSON document.
Even if only one attribute is needed:
entire records are read
larger storage
slower queries
Dynamic filtering is mainly useful for joins, not simple log analytics.
Key rejection factors
❌ JSON is row-based.
❌ Worse than ORC/Parquet for analytics.
❌ Dynamic filtering doesn't solve the main bottleneck.
---
When would JSON be appropriate?
Use JSON when
schema changes frequently
semi-structured data
nested documents
ingest simplicity matters more than query speed
Not when fastest Athena queries are required.
---
C) Convert the CSV logs to Avro. Partition by date in Amazon S3. Use Athena with projection-based partitioning.
Why rejected
Avro is also row-oriented.
Unlike ORC or Parquet,
Athena still reads entire rows.
Projection-based partitioning is useful when you have huge numbers of partitions and want to avoid maintaining partition metadata.
However,
The bottleneck here is query performance on columns, not partition metadata.
Key rejection factors
❌ Avro is row-based.
❌ Reads unnecessary columns.
❌ Partition projection mainly reduces metadata overhead.
It does not provide the biggest query spee...
Author: Lina Zhang · Last updated Jul 10, 2026
A media streaming company is moving its application to AWS. The company wants to avoid data quality issues in user engagement analytics. The company needs to be able to reprocess several days of historical data without duplicates an...
The key requirements are:
1. Reprocess several days of historical data
2. No duplicate records (avoid data quality issues)
3. Do not interrupt current real-time processing
Let's evaluate each requirement first.
| Requirement | Best AWS Feature |
| --------------------------------------------- | ------------------------------------------------------ |
| Replay several days of data | Kinesis Data Streams Extended Retention |
| Prevent duplicates during replay | Idempotent consumers |
| Continue real-time processing while replaying | Separate processing paths |
| Store consumer checkpoints | DynamoDB (commonly used with Kinesis applications) |
Now evaluate each option.
---
Option A
> Configure Kinesis Data Streams with extended retention. Implement idempotent consumers with DynamoDB checkpointing. Use separate processing paths for replay data and real-time data.
Why this is correct
1. Extended retention
By default, Kinesis retains data for 24 hours (can be configured up to 365 days).
The question says:
> reprocess several days of historical data
Standard retention may not be enough.
Extended retention is specifically designed for replaying historical records.
✔ Requirement satisfied.
---
2. Idempotent consumers
Replaying historical data means the same event may be seen again.
Without idempotency,
```
User A watched Movie X
Real-time processing
↓
Replay
↓
Analytics counts twice
```
Idempotent processing ensures
```
Already processed?
Yes
↓
Ignore duplicate
```
This satisfies
> avoid data quality issues
---
3. DynamoDB checkpointing
Kinesis applications commonly store consumer state/checkpoints in DynamoDB.
Advantages:
very low latency
scalable
serverless
designed for frequent checkpoint updates
AWS Kinesis Client Library (KCL) traditionally stores lease/checkpoint information in DynamoDB.
Good fit.
---
4. Separate processing paths
Question says
> without interrupting current real-time processing
Separate replay path means
```
Historical Replay
│
▼
Replay Consumer
Real-time Stream
│
▼
Live Consumer
```
Neither blocks the other.
Replay can run independently.
This exactly matches the requirement.
✔ Best design.
---
Option B
> Standard retention + RDS checkpointing + separate processing paths
Good
✔ Separate processing paths
---
Problem 1
Standard retention
Question says
> several days
Standard retention is typically the default 24 hours (even though configurable retention exists, exam questions usually distinguish "extended retention" explicitly for multi-day replay).
Historical replay requirement is not fully satisfied.
---
Problem 2
RDS checkpointing
Checkpoint updates happe...
Author: Liam · Last updated Jul 10, 2026
A global ecommerce company occasionally receives customer data files in its Amazon S3 data lake. The company needs to automatically detect new data and mask sensitive data before making the data available to the company's an...
The key phrases in the question are:
Occasionally receives customer data files → Batch file uploads, not streaming
Amazon S3 data lake → Data stays in S3
Automatically detect new data
Mask sensitive data
Least operational overhead → Prefer managed/serverless AWS services
Let's evaluate each option.
---
Option A
> Configure Amazon S3 Event Notifications to detect the new data and trigger an AWS Glue job. Use Amazon Macie to detect and mask the sensitive data. Store the processed data in Amazon Redshift.
Why it looks attractive
S3 Event Notifications are a good way to detect new objects.
AWS Glue is good for ETL.
Why it is incorrect
The major issue is Amazon Macie.
Amazon Macie does NOT mask or transform data.
Macie can:
Discover sensitive data in S3
Classify data (PII, financial data, credentials, etc.)
Generate findings
Macie cannot
Modify files
Mask columns
Replace sensitive values
The question explicitly asks to mask sensitive data.
Another issue:
The company already has an S3 data lake, but this option stores processed data in Amazon Redshift, which isn't requested.
When Macie is used
Use Macie when you need:
PII discovery
Security auditing
Compliance
Data classification
Not for ETL or masking.
Rejected because Macie cannot perform masking.
---
Option B
> Use Amazon MSK to detect incoming data. Use Amazon EMR workflows to detect and mask sensitive data. Store the processed data in Amazon S3.
Why it is incorrect
The workload is:
> "occasionally receives customer data files"
This is batch file processing, not streaming.
Amazon MSK is designed for:
Real-time event streaming
Kafka workloads
Continuous ingestion
Using Kafka just to detect new S3 files is excessive.
Amazon EMR also requires:
Cluster management
Hadoop/Spark ecosystem
Much higher operational overhead than Glue.
When MSK is appropriate
Use MSK when:
Millions of streaming events
Clickstream analytics
IoT
Real-time logs
When EMR is appropriate
Use EMR when:
Big Spark jobs
Hadoop ecosystem
Custom distributed processing
Large-scale machine learning
Not ideal for simple S3 file masking.
Rejected because it uses streaming technologies and EMR, which create unnecessary operational overhead.
---
Option C
> Use Amazon Kinesis Data Streams to capture new data. Use Amazon Comprehend to detect and mask the sensitive data. Store the processed data in DynamoDB.
Why it is incorrect
Several problems exist.
Problem 1
Kinesis Data Streams is for real-time streaming.
The question is about files arriving in S3.
No need for Kinesis.
---
Problem 2
Amazon Comprehend is an NLP service.
It performs:
Entity recognition
Sentiment analysis
Key phrases
Language detection
It does not perform generic data masking.
---
Problem 3
Why DynamoDB?
The company has an S3 data lake.
Moving processed files into DynamoDB makes no architectural sense.
When Comprehend is used
Use Comprehend for:
NLP
Medical text
Document classification
Entity extraction
Not ETL masking.
Rejected because every major service is inappro...
Author: Lucas · Last updated Jul 10, 2026
A company uses Amazon SageMaker AI for its machine learning (ML) workflows. The company is organized into several project groups that use sensitive data. The company needs to give the project groups the ability to discover available datasets across different AWS accounts. The solution must maintain access controls...
The key requirements are:
1. Several project groups using sensitive data
2. Discover available datasets across different AWS accounts
3. Maintain access controls
4. Track all data access for compliance
5. Least operational overhead
Let's evaluate each option against these requirements.
---
Option A) Use Amazon SageMaker Assets to publish, discover, and request access to datasets through the asset catalog with approval workflows that track data access.
✅ Why this is correct
This is exactly what Amazon SageMaker Assets (Amazon SageMaker Catalog / asset catalog capability) is designed for.
It provides:
Dataset publishing
Dataset discovery
Cross-account discovery
Metadata catalog
Request access workflow
Approval workflow
Governance
Auditing
Instead of manually managing permissions for every account and dataset, users:
1. Search datasets
2. Request access
3. Data owner approves/rejects
4. Access is tracked
This satisfies:
| Requirement | Supported? |
| -------------------------- | ---------- |
| Discover datasets | ✅ |
| Cross-account | ✅ |
| Sensitive data | ✅ |
| Approval workflow | ✅ |
| Track access | ✅ |
| Least operational overhead | ✅ |
This is a managed governance solution.
Key exam clue
Words like
discover datasets
publish datasets
request access
approval workflow
governance
compliance
almost always indicate SageMaker Assets / Catalog.
---
Option B) Set up Amazon SageMaker Feature Store with cross-account access policies to automatically share data between AWS accounts without requiring approval workflows.
Why this is wrong
Feature Store is designed for:
ML features
Online/offline feature storage
Feature reuse
Consistent features for training and inference
It is NOT a dataset catalog.
It is not intended for:
discovering datasets
approval workflows
governed dataset sharing
Another major issue:
The question explicitly mentions
> maintain access controls
and
> compliance
Option B says
> automatically share data
without approval workflows.
That violates governance.
Feature Store is used when
Use Feature Store when:
storing engineered features
sharing ML features
preventing training/serving skew
online inference
Not for enterprise data governance.
---
Option C) Set up IAM roles for each project group with permissions to access all datasets across all AWS accounts. Use AWS CloudTrail to record data access activity.
Why this is wrong
This satisfies only one requirement:
✔ CloudTrail records API activity.
But several problems remain.
Problem 1
No dataset discovery.
Users cannot browse datasets.
Question specifically asks:
> discover available datasets
IAM cannot provide catalog capability.
---
Problem 2
Permissions become difficult.
Managing IAM roles across many AWS accounts creates high operational overhead.
Question asks:
> least operational overhead
This is the opposite.
---
Problem 3
No approval workflow.
Anyone with IAM per...
Author: Lina Zhang · Last updated Jul 10, 2026
A company has an application that is deployed on AWS. The application uses Amazon Simple Notification Service (Amazon SNS) with multiple topics. The company's security team needs to be able to audit all Publish and PublishBatch API actions for all the SNS topics. The company's application team and security team must also be able to query the audit data. The company has alread...
The key to this question is identifying:
What type of CloudTrail event is `SNS Publish`?
What service is already configured?
What solution has the least operational overhead?
---
Step 1: Identify the API type
The APIs mentioned are:
`Publish`
`PublishBatch`
These are Amazon SNS data plane APIs, not management APIs.
AWS CloudTrail categorizes events into:
| Event Type | Records | Examples |
| --------------------- | ------------------------ | -------------------------------------------- |
| Management events | Control plane operations | CreateTopic, DeleteTopic, SetTopicAttributes |
| Data events | Data plane operations | SNS Publish, S3 GetObject, Lambda Invoke |
Since the requirement is to audit Publish and PublishBatch, these are data events.
Key exam keyword:
> Publish = Data Event
---
Step 2: Existing environment
The question says:
> The company has already established an event data store in CloudTrail Lake to collect all events.
This is very important.
They already have:
CloudTrail Lake
Event Data Store
So introducing Athena and Glue would only increase operational work.
---
Option A
> Enable management events for the SNS topics.
>
> Create Glue table.
>
> Query using Athena.
Why rejected
There are two problems.
Problem 1
Management events do not include:
Publish
PublishBatch
Management events only include operations like:
CreateTopic
DeleteTopic
Subscribe
So it doesn't satisfy the requirement.
Problem 2
The company already has CloudTrail Lake.
Creating
Glue catalog
Athena tables
adds unnecessary operational overhead.
Key factor
❌ Wrong event type.
❌ Extra services.
---
Option B
> Enable management events.
>
> Query CloudTrail Lake.
Again:
Management events do not capture Publish.
CloudTrail Lake querying is good, but the wrong events are collected.
Key factor
Correct querying service.
Wrong event category.
❌ Rejected.
---
Option C
> Enable data events.
>
> Query using CloudTrail Lake.
This exactly matches every requirement.
Why?
Requirement:
Audit
Publish
PublishBatch
These are data events.
Requirement:
Security team can query
Application team can query
CloudTrail Lake already supports SQL queries directly.
Requirement:
Least operational overhead
Nothing additional is required.
No:
Athena
Glue
S3 setup
Everything already exists.
Key factors
...
Author: FlamePhoenix2025 · Last updated Jul 10, 2026
A company needs to store semi-structured transactional data for an application in a database. The database must be serverless. The application writes the data infrequently, but it reads the data frequently. The application must retrieve the dat...
The correct answer is:
> ✅ D) Store the data in an Amazon DynamoDB table. Configure a DynamoDB Accelerator (DAX) cache.
Let's solve it the way AWS exam questions are designed—by identifying the key factors first.
Step 1: Identify the key requirements
| Requirement | Important Keywords | What it suggests |
| ---------------------------------- | ------------------- | ------------------------------------------------- |
| Semi-structured transactional data | Key-value/JSON | DynamoDB is designed for this |
| Database must be serverless | Serverless | DynamoDB |
| Writes infrequently | Low write workload | DAX is fine because cache isn't invalidated often |
| Reads frequently | Read-heavy workload | Cache is beneficial |
| Millisecond retrieval | Very low latency | DynamoDB + DAX |
The biggest clues are:
Serverless database
Semi-structured data
Read-heavy application
Milliseconds latency
---
Option A: Store the data in Amazon S3 Standard bucket. Enable S3 Transfer Acceleration.
Why rejected
S3 is object storage, not a database.
Problems:
Cannot efficiently query transactional records.
Retrieval is object-based.
Doesn't support database-style access.
S3 Transfer Acceleration improves upload/download over long distances, not read latency within applications.
Key exam factor
Transfer Acceleration solves:
> Client far away → upload/download faster.
It does NOT make S3 behave like a database.
When to use
Use S3 when:
backups
images
videos
logs
documents
data lake
static website
Not for OLTP applications.
---
Option B: Store the data in an Amazon S3 Apache Iceberg table. Enable S3 Transfer Acceleration.
Why rejected
Apache Iceberg is designed for
analytics
data lakes
huge datasets
SQL analytics
Not transactional applications requiring millisecond lookups.
Again,
Transfer Acceleration is irrelevant.
Key exam factor
Apache Iceberg =
> Data lake analytics
Not
> Online application database
When to use
Use Iceberg for
Athena
EMR
Spark
Redshift
large analytical datasets
ACID tables in data lakes
---
Option C: Store the data in Amazon RDS for MySQL cluster. Configure RDS Optimized Reads.
Why rejected
There are multiple issues.
Requirement says:
> Database must be serverless.
Traditional RDS cluster is not serverless.
AWS specifically says
RDS instance
cluster
These require provisioning.
(Only Aurora Serverless v2 is serverless, but that isn't the option.)
---
Also,
Semi-structured data fits DynamoDB much better.
---
RDS Optimized Reads
helps
faster local temporary storage
query performance
analytics
sorting
joins
It does not outperform DynamoDB+DAX for key-value millisecond reads.
When to use
Choose RDS ...
Author: Sofia · Last updated Jul 10, 2026
A company needs a solution that restricts access to Amazon S3 data and encrypts the data by using AWS managed keys. The solution must manage database credentials that an AWS Lambda function uses and mus...
Key requirements breakdown
The solution must:
1. Restrict access to Amazon S3 data
2. Encrypt data using AWS managed keys
3. Securely manage Lambda database credentials
4. Automatically rotate credentials
5. Prefer AWS managed services (secure + low operational overhead)
---
✅ Correct Option: B
Why Option B is correct
Option B components:
IAM policies for S3 access control
SSE-KMS for encryption
AWS Secrets Manager for credentials + automatic rotation via Lambda
Key reasoning
1. Access control → IAM policies
IAM is the recommended modern standard for S3 access control
More granular and scalable than bucket policies or ACLs
2. Encryption requirement → AWS managed keys
SSE-KMS uses AWS-managed KMS keys (AWS KMS) in the managed mode
Provides:
Encryption at rest
Access control via KMS policies
Audit logging via CloudTrail
✔ Matches requirement: “AWS managed keys”
---
3. Credential management + automatic rotation
AWS Secrets Manager is purpose-built for:
Secure storage of secrets (DB credentials)
Built-in automatic rotation
Native Lambda integration for rotation logic
✔ This is the key differentiator in the question
---
❌ Why other options are incorrect
---
❌ Option A
Uses SSE-S3 (Amazon S3 managed keys) → OK for encryption requirement
Uses L...
Author: Michael · Last updated Jul 10, 2026
A university is developing an educational application that analyzes student essays. The application provides personalized feedback with accurate citations to the university's textbooks. The application needs to process essays in multiple languages. Application responses must include direct references to specific sections in the cour...
This is a Retrieval-Augmented Generation (RAG) with citations + multilingual output problem, and the key constraint is least operational overhead.
---
✅ Correct Answer: B
B) Create a knowledge base in Amazon Bedrock Knowledge Bases with the university's textbooks. Configure a multilingual model to generate responses with source citations.
Why this is correct
Amazon Bedrock Knowledge Bases is a fully managed solution that:
Automatically ingests and chunks textbook content
Creates embeddings and manages vector storage internally
Provides built-in retrieval + citation grounding
Works seamlessly with Amazon Bedrock models
Supports multilingual generation via foundation models
Minimizes infrastructure, pipelines, and orchestration work
Key reason it wins (exam logic)
Lowest operational overhead
Native citations support (critical requirement)
No need to manage vector DB, pipelines, or Lambda orchestration
Designed specifically for “chat with documents” use cases
---
❌ Why other options are wrong
A) OpenSearch Serverless + embeddings + Lambda + Bedrock
Amazon OpenSearch Serverless + Lambda + custom orchestration
Problems:
You must build and maintain:
embedding pipeline
chunking strategy
retrieval logic
prompt assembly
Lambda adds orchestration overhead
More flexible, but not least operational effort
When it is used:
Highly customized sea...
Author: Rahul · Last updated Jul 10, 2026
A media company uploads large video files to Amazon S3 for processing. After processing, the company needs to keep the original files for 90 days in case the files require reprocessing. After 90 days, the company can delete the files to reduce storage costs. The company stores the processed videos in a ...
The key requirement is simple: keep original uploaded objects for exactly 90 days, then delete them automatically in the most cost-effective way, with no need for archival beyond that period or additional data protection features.
Correct approach
The most cost-effective lifecycle configuration is to:
Store objects in S3 Standard for the first 90 days (active processing window)
Automatically expire (delete) objects after 90 days using an S3 Lifecycle rule
This directly matches the requirement without adding unnecessary storage tiers or features.
---
Why Option C is correct
C) Store the files in S3 Standard for 90 days. Implement S3 Lifecycle management to expire the files.
Meets the exact retention requirement (90 days)
Uses no extra storage transitions, so it is cost-optimal
Uses Lifecycle expiration only, which is the simplest and cheapest control
No unnecessary features (versioning, Glacier, Object Lock)
When to use this pattern
Use this when:
Data is needed for a fixed short retention period
No archival or compliance retention is required
You only need temporary storage + automatic deletion
---
Why other options are incorrect
A) Standard → Glacier Flexible Retrieval → Expire
Glacier transition is unnecessary complexity and cost
Glacier is used when you need long-term archival storage (months/years)
Here, data is only needed for 90 days, so archival is i...
Author: Noah · Last updated Jul 10, 2026
A data engineer is building a serverless. multi-step extract, transform, and load (ETL) pipeline. The pipeline extracts data from an Amazon S3 data lake and transforms the data by using AWS Glue ETL jobs. The pipeline then loads the results into an Amazon Redshift database. The data...
We need a serverless orchestration solution for a multi-step ETL pipeline:
Source: Amazon S3 data lake
Transform: AWS Glue ETL jobs
Target: Amazon Redshift
Requirement: orchestrate multi-step workflow with dependencies + error handling
Key AWS idea: orchestration should be serverless, workflow-aware, dependency-driven, and support retries/branching.
---
✅ Correct Options
A) AWS Step Functions orchestrating AWS Glue jobs
✔ Correct
Why this works:
AWS Step Functions is a serverless workflow orchestration service
Designed for multi-step workflows with dependencies
Can directly invoke AWS Glue jobs
Provides:
retries and backoff
error handling (Catch/Retry states)
sequential + parallel execution
state tracking and visibility
When to use:
Complex ETL pipelines (extract → transform → load)
When you need robust control flow and failure handling
When integrating multiple AWS services (Glue, Lambda, Redshift, etc.)
✔ This directly matches the requirement.
---
B) AWS Glue Workflows
✔ Correct
Why this works:
AWS Glue Workflows are built specifically for orchestrating Glue ETL jobs
Supports:
job dependencies (DAG-based execution)
triggers (on success/failure)
visual workflow monitoring in Glue console
When to use:
Pure Glue-centric ETL pipelines
When orchestration is limited to Glue jobs only
Simpler pipelines compared to Step Functions
✔ Since the pipeline is mainly Glue-based ETL, this is a valid serverless orchestration option.
---
❌ Incorrect Options
C) EC2 instance with cron jobs
✖ Incorrect
...
Author: Ming88 · Last updated Jul 10, 2026
A company needs to generate a one-time performance report by joining data that is stored in Amazon DynamoDB. Amazon RDS. Amazon Redshift. and Amazon S3. The company wants to avoid unnecessary data moveme...
Correct Answer: D) Use Amazon Athena Federated Query to perform one-time joins and analysis across DynamoDB, Amazon RDS, Amazon Redshift, and Amazon S3.
---
✅ Why Option D is correct
The requirement is:
One-time performance report (not a long-term data warehouse redesign)
Data exists across DynamoDB, Amazon RDS, Amazon Redshift, and Amazon S3
Must avoid unnecessary data movement
Must minimize query execution time
Key AWS feature: Amazon Athena Federated Query
Amazon Athena with Federated Query allows:
Direct querying across multiple data sources
Joins between heterogeneous systems (DynamoDB, RDS, Redshift, S3)
No need to permanently move or replicate data
Uses Lambda connectors to access external sources
Why it fits best:
No ETL pipeline required
No bulk data copying
Executes queries “in place”
Ideal for ad-hoc / one-time analytics
Reduces operational overhead and latency of data staging
---
❌ Why other options are wrong
---
❌ A) Move everything into S3 + Redshift Spectrum
What it does:
Uses DynamoDB Streams + DMS + Redshift export
Centralizes everything into Amazon S3
Queries using Redshift Spectrum
Problems:
Heavy data movement and duplication
Requires ETL pipelines and storage staging
Not suitable for one-time reporting
High setup time and operational complexity
When A is used:
Building a long-term data lake architecture
Enterprise analytics with repeated ...
Author: Oliver · Last updated Jul 10, 2026
A company processes a CSV file that contains millions of transaction records every day. The file is stored in Amazon S3. Each transaction must be validated before updating a database. The company needs a solution that will process the data in parallel. The solution must use error handling that stops the entire proc...
The key requirements are:
Process millions of CSV records stored in Amazon S3
Must run in parallel
Each record requires validation before DB update
Must fail the entire workflow if >15% of records fail validation
Prefer least operational overhead
---
✅ Correct Choice: B) Use AWS Step Functions Distributed Map state with the ToleratedFailurePercentage field set to 15%
Why this works
AWS Step Functions provides a serverless orchestration engine, and the Distributed Map state is specifically designed for:
High-scale parallel processing of large datasets (millions of items)
Reading input directly from Amazon S3
Processing each record independently
Built-in error tolerance controls
Most importantly:
The `ToleratedFailurePercentage = 15%` feature exactly matches the requirement
→ If more than 15% of records fail validation, the entire workflow fails automatically
No custom tracking logic is needed
Fully managed → lowest operational overhead
When to use this
Use Step Functions Distributed Map when:
You have large datasets in S3 (JSON/CSV converted to JSON records)
You need serverless parallel processing
You want built-in failure thresholds or retry policies
You want minimal infrastructure management
---
❌ Why other options are incorrect
A) AWS Batch + custom error tracking
AWS Batch can process data in parallel using jobs and arrays.
Problems:
You must manually implement:
record splitting
failure co...
Author: Victoria · Last updated Jul 10, 2026
A company needs to collect logs for an Amazon RDS for MySQL database and make the logs available for audits. The logs must track each user that modifies data in the database or makes c...
Correct Answer: D
To meet the requirement—tracking each user who modifies data in Amazon RDS for MySQL and capturing instance-level changes for audit purposes—you need both database-level auditing and control-plane (API) auditing.
---
✅ Why Option D is Correct
D) Enable and configure native Amazon RDS database audit logging. Enable Amazon CloudWatch Logs. Configure metric filters and alarms. Configure AWS CloudTrail audit logging.
Key reasoning factors:
1. Database-level user activity (critical requirement)
Native RDS MySQL audit logging (or general/audit plugin depending on configuration) captures:
SQL queries (INSERT, UPDATE, DELETE)
User connections and authentication events
This is the only option that can track which DB user modified data inside the database
2. Instance-level changes
AWS CloudTrail captures:
RDS instance modifications (parameter groups, scaling, snapshots, security changes)
Any AWS API calls affecting the DB instance
3. Log storage and monitoring
Amazon CloudWatch Logs is used to:
Store database audit logs centrally
Create metric filters and alarms for suspicious activity
Why this works best:
This option provides end-to-end auditability:
Inside the database (SQL-level actions)
At the AWS infrastructure level (API-level changes)
Centralized logging for audits and compliance
---
❌ Why Other Options Are Incorrect
A) CloudWatch Logs + m...
Author: Zara1234 · Last updated Jul 10, 2026
A company is building data processing pipelines by using AWS Glue. The pipelines access data stored in Amazon S3. The company has organized the data into folders with prefixes that represent different classification levels. The company needs to restrict AWS Glue jobs to access only specific prefixes based on the data classification. The company mus...
The correct answer is B.
Why B is correct
This requirement has two independent controls:
1. S3 prefix-level restriction (data classification)
AWS Glue jobs need access only to specific folders (prefixes) in S3.
This is correctly handled using S3 object ARNs with wildcards, such as:
`arn:aws:s3:::bucket-name/confidential/`
`arn:aws:s3:::bucket-name/public/`
This is the standard IAM approach for restricting access to “folder-like” prefixes in S3.
2. Time-based access control (business hours)
IAM supports the condition key `aws:CurrentTime`.
It can be combined with:
`DateGreaterThan`
`DateLessThan`
This allows enforcement of a window like 09:00–17:00.
So option B correctly combines:
Proper S3 resource scoping (prefix-based ARNs)
Correct IAM time condition mechanism (`aws:CurrentTime`)
---
Why the other options are wrong
❌ A
Uses `$util.time`
This is not an IAM condition key
It belongs to AWS AppSync/VTL templates, not IAM policies
Therefore it cannot enforce S3 or Glue access control
Use case (valid elsewhere):
AppSync request/response mapping templates (not IAM)
---
❌ C
Uses `s3:prefix` incorrectly
...
Author: Sofia2021 · Last updated Jul 10, 2026
A company stores historical customer data in an Amazon Redshift table. A column named Email contains null entries and values that are not email addresses. The quality of the Email column is critical for multiple downstream processes. A data engineer must create an AWS Glue Data Quality rule that fails when the percentage of ...
We need a rule that validates email format and enforces a minimum proportion (≥ 90%) of valid values in the column. In AWS Glue Data Quality (part of AWS Glue), this is typically done using a ColumnValues match condition with a threshold on the proportion of matching rows.
---
Key requirement breakdown
Data source: Customer table in Amazon Redshift
Column: `Email`
Contains:
NULLs
Invalid email formats
Requirement:
At least 90% of values must be valid email addresses
Rule must fail if valid percentage < 0.9
So we need:
A pattern match condition (email regex-like check)
A threshold on match ratio ≥ 0.9
---
Option analysis
A) Uniqueness "Email" matches "[%@%.%]" with threshold > 0.9
❌ Incorrect concept
Uniqueness checks whether values are distinct, not whether they match a pattern.
Even if threshold is high, it does not validate email format.
Use case: detecting duplicate keys or ensuring primary key-like behavior.
---
B) ColumnValues "Email=E2=80=9D matches "[%@%.%]" with threshold > 0.1
❌ Multiple issues:
Threshold 0.1 is too low (would allow 90% invalid data)
Even if syntax seems intended for matching, the rule would pass almost always
...
Author: Aarav2020 · Last updated Jul 10, 2026
A company stores sensitive transaction data in an Amazon S3 bucket. A data engineer must implement controls to prevent accidental ...
Correct Answer: A) Enable versioning on the S3 bucket and configure MFA delete
---
Key Requirement Analysis
The question asks for a solution to prevent accidental deletions in an Amazon S3 bucket storing sensitive transaction data.
Key words:
Prevent accidental deletions
Sensitive data
Strong control mechanism (not just monitoring or delay-based recovery)
So we need a mechanism that:
1. Prevents permanent data loss
2. Adds an approval/verification layer for deletion
3. Works at the S3 storage level
---
✅ Why Option A is Correct: Versioning + MFA Delete
🔹 Amazon S3 Versioning
Keeps multiple versions of an object
If someone deletes an object, S3 does NOT permanently remove it
Instead, it adds a delete marker
Previous versions remain recoverable
🔹 MFA Delete
Requires multi-factor authentication for:
Permanently deleting an object version
Suspending versioning
Adds a strong human verification layer
✔ Why this fits the requirement
Prevents accidental permanent deletion
Provides recoverability even if deletion happens
MFA ensures extra protection against unintended or malicious deletions
👉 This is the only option that directly prevents irreversible deletion
---
❌ Why Other Options Are Incorrect
B) Deny creation of S3 delete markers via bucket policy
❌ Invalid approach because:
S3 does not support explicitly denying delete marker creation via IAM/bucket policies
Delete markers a...
Author: SilverBear · Last updated Jul 10, 2026
A company's application needs to search and analyze data in near real time. The application must handle up to 1,000 requests each second with low query latency. The company wants a solution that individual data teams can own and configure to meet ...
The requirements emphasize near real-time search and analytics, low-latency query performance at ~1,000 requests/second, and team-level ownership for independent configuration and cost/performance tuning.
Let’s evaluate each option against these key factors: latency, workload type (search vs batch vs transactional), scalability, and operational model.
---
A) Amazon S3 + Amazon Athena
Amazon S3 + Amazon Athena
This design is based on a data lake + SQL-on-files model.
Strengths:
Low cost storage (S3)
Serverless ad-hoc querying (Athena)
Good for historical analysis and batch analytics
Why it fails here:
Athena is not designed for sub-second or high-QPS (1000 req/s) query serving
Query performance depends on scanning S3 data → higher latency
Not suitable for real-time search workloads
Poor fit for interactive, high-concurrency applications
Best used for:
Data lake analytics
Compliance queries
Occasional BI reporting
---
B) Amazon Kinesis Data Streams + Managed Service for Apache Flink
Amazon Kinesis Data Streams + Amazon Managed Service for Apache Flink
This is a real-time stream processing pipeline.
Strengths:
Excellent for ingesting and processing streaming data in real time
Flink supports stateful stream analytics (aggregations, transformations)
Good for event-driven architectures
Why it fails here:
This stack is primarily for processing data, not serving interactive search queries
Does not provide a native low-latency query engine for 1000 req/s search requests
You would still need an external serving/indexing layer (like OpenSearch or a database)
Best used for:
Real-time ETL pipelines
Fraud detection streams
Event aggregation before storing in another system
---
C) Amazon OpenSearch Service clusters
Amazon OpenSearch Service
This is...
Author: Kai · Last updated Jul 10, 2026
A global finance company needs to implement near real-time cross-Region synchronization of trading data between trading centers in the us-east-1 Region, the eu-west-2 Region, and the ap-northeast-1 Region. The company must ensure that data is encrypted in transit. The solution must ensure data ordering and consistency and must support cross-Region disaster recov...
Key requirements from the scenario
The solution must:
Replicate trading data across 3 Regions (us-east-1, eu-west-2, ap-northeast-1)
Be near real-time (< 500 ms latency)
Ensure data ordering and consistency
Provide cross-Region disaster recovery
Ensure encryption in transit
Have least operational effort
In AWS exam terms, the strongest signal here is:
👉 “cross-Region Kafka replication with minimal operational overhead + ordering + DR”
---
✅ Correct option: B
B) Use Amazon MSK Replicator for cross-Region replication
Amazon Managed Streaming for Apache Kafka (Amazon MSK) MSK Replicator is a fully managed feature designed specifically for cross-Region Kafka replication.
Why this is correct
MSK Replicator:
Fully managed → minimal operational effort (key requirement)
Supports cross-Region replication between MSK clusters
Maintains message ordering within partitions (Kafka-native guarantee)
Provides near real-time replication suitable for sub-second latency targets (when properly sized)
Supports disaster recovery architectures (active-passive or active-active)
Uses TLS encryption in transit
Integrates with IAM authentication
Why it fits best
This is essentially the only option that is:
Purpose-built for Kafka cross-Region replication
Managed by AWS (not self-managed connectors/tools)
Designed for DR + low-latency streaming replication
---
❌ Why the other options are wrong
---
A) Kafka Connect with custom connectors
Requires custom development and maintenance
High...
Author: Zain · Last updated Jul 10, 2026
A data engineer at a large company needs to create centralized datasets that are optimized for Amazon Redshift performance. The company has multiple downstream teams that use their own AWS accounts and dedicated Amazon Redshift clusters with RA3 nodes. All downstream teams need access to the centraliz...
The correct answer is C) Set up Amazon Redshift data sharing between the Amazon Redshift producer clusters and the consumer clusters to provide access to the centralized datasets.
Why C is correct
Amazon Redshift data sharing allows a producer cluster to share live data with multiple consumer clusters across AWS accounts without copying or moving the data.
Key factors:
Immediate access: Consumers see shared data almost instantly (no ETL or file movement).
No data duplication: Data remains in the producer cluster, reducing storage overhead.
Performance preservation: Consumers query shared data using their own RA3 clusters, preserving compute isolation and performance.
Cross-account support: Designed specifically for multi-account architectures like the one described.
Zero ETL pipeline maintenance: No scheduled jobs or data replication needed.
When to use this:
Multiple Redshift clusters need real-time access to the same dataset.
You want central governance + distributed query access.
You want to avoid S3-based external querying or data duplication.
---
Why other options are incorrect
A) UNLOAD to S3 + AWS Glue + Lake Formation + Redshift Spectrum
This introduces a data lake architecture, not a pure Redshift-native solution.
Requires data movement to S3, which adds latency.
Amazon Redshift Spectrum queries S3 data, which is typical...
Author: Chloe · Last updated Jul 10, 2026
A company is setting up a new Amazon SageMaker Unified Studio domain. Each of the company's business units needs isolated control over its own assets, projects, and metadata. Specific datasets must be shareable with other business units upon approval. The company a...
The requirements in this scenario are:
Strong isolation per business unit (separate control over assets, projects, metadata)
Controlled cross-unit data sharing (only upon approval)
Centralized authentication and identity mapping
Governance without breaking domain ownership boundaries
In Amazon SageMaker Unified Studio, this maps closely to domain units with governed sharing workflows + centralized identity via IAM Identity Center.
---
Key evaluation factors
1. Isolation of business units
Each business unit must operate independently in terms of:
projects
datasets/assets
metadata governance
This points to domain unit-based separation, not loosely shared environments.
---
2. Controlled sharing requirement
The key requirement is not just isolation, but:
> “datasets must be shareable with other business units upon approval”
So the correct model must support:
request-based sharing
approval workflows
explicit access grants
---
3. Centralized authentication
AWS best practice for SageMaker Unified Studio is:
AWS IAM Identity Center for centralized authentication
user identity mapping into domain units/projects
---
Option analysis
❌ Option A
Uses API keys for authentication → not recommended for enterprise identity in AWS (weak governance, no SSO integration)
Mentions fine-grained permissions and sharing, which is good
But authentication model is incorrect and insecure for this requirement
👉 Rejected due to incorrect identity approach (API keys)
---
❌ Option B
Uses IAM...
Author: Aarav2020 · Last updated Jul 10, 2026
A global company currently uses Amazon Redshift to store data and Amazon Quick Suite (previously known as Amazon QuickSight) to generate reports.
A team of business analysts have varying levels of technical expertise. Some analysts lack SQL knowledge. All the analysts need to create new reports frequently. The company wants to use natural progra...
The key requirement in this scenario is natural language querying for dashboard and report creation with minimal operational effort, especially for business analysts who may not know SQL. The existing stack already uses Amazon Redshift and Amazon QuickSight, so the solution should enhance QuickSight rather than introduce new tools or heavy integration overhead.
✅ Correct Option: B) Enable Amazon Q in Quick Suite. Generate Quick Suite dashboards and reports.
This is the best choice because Amazon Q in QuickSight allows users to:
Ask questions in natural language (no SQL required)
Automatically generate visuals, dashboards, and insights
Support self-service analytics for non-technical users
Minimize operational overhead (fully managed AWS feature)
This directly meets the requirement for analysts with mixed technical skills to create reports frequently using conversational queries.
---
❌ Why other options are incorrect
A) QuickSight dashboards with zero-ETL access to Redshift
Zero-ETL access improves data connectivity, not usability
Still requires users to manually build vi...
Author: Jack · Last updated Jul 10, 2026
A global ecommerce company processes customer transactions, inventory updates, and user activity logs across multiple AWS services. The company needs a scalable, fully managed, and event-driven orchestration solution to coordinate complex extract, transform, and load (ETL) workflows. The solution must use AWS Glue and Amazon EMR to process data. The data will be stored in Amazon Red...
The requirements describe a complex, multi-step ETL orchestration system that must be:
Fully managed
Event-driven
Able to manage dependencies between tasks
Support automated retries
Provide pipeline monitoring and visibility
Coordinate processing across AWS Glue and Amazon EMR, with data stored in Amazon S3 and Amazon Redshift
---
✅ Correct Option: C — Amazon MWAA (Apache Airflow)
Why C is correct
Amazon Managed Workflows for Apache Airflow (MWAA) provides exactly what is needed for enterprise-grade ETL orchestration:
Directed Acyclic Graphs (DAGs) → Native support for modeling complex dependencies between ETL steps
Dependency management → Tasks can be chained, parallelized, and conditionally executed
Retries and failure handling → Built-in task-level retry policies
Monitoring and observability → Airflow UI provides rich DAG and task monitoring
Native integrations → Strong support for AWS Glue and Amazon EMR via operators and hooks
👉 This makes MWAA ideal for complex, long-running, multi-system ETL pipelines.
---
❌ Why other options are incorrect
A — AWS Step Functions (Express Workflow)
AWS Step Functions is a strong orchestration tool, but:
Express workflows are optimized for high-throughput, short-duration, stateless workflows
They provide less detailed execution history and debugging visibility compared to Standard workflows or Airflow
While Step Functions supports retries and orchestration, it is less natural for large-scale ETL DAG-style dependencies
EMR/Glue in...
Author: James · Last updated Jul 10, 2026
A company needs to implement real-time analytics for a retail shopping platform. The company wants to capture clickstream data, process the data, and load the data into Amazon Redshift for analysis. The solution must handle hundreds of megabytes of d...
The requirement is real-time clickstream analytics at very high throughput (hundreds of MB/s) with minimum query latency in Amazon Redshift, so the key design focus is:
Streaming ingestion (not batch or micro-batch)
Direct integration with Amazon Redshift for near real-time availability
Minimal intermediate storage and processing hops
---
✅ Correct Answer: C
C) Use Amazon Kinesis Data Streams to capture the data. Use Amazon Redshift streaming ingestion to load data directly into materialized views.
Why this is correct
True real-time ingestion path
Kinesis Data Streams is built for massive-scale streaming (hundreds of MB/s and beyond).
Lowest latency into Redshift
Redshift streaming ingestion into materialized views eliminates intermediate storage (no S3 staging).
Continuous ingestion
Data flows directly into Redshift as it arrives, enabling near-instant query availability.
Best for analytics use case
Materialized views can be queried immediately for dashboards and BI tools.
👉 This is the only option that provides native, low-latency streaming into Redshift at scale.
---
❌ Why the other options are incorrect
A) Amazon Kinesis Data Firehose → S3 → COPY into Redshift
Firehose buffers data (typically seconds to minutes) → not true real-time
COPY is batch-based ...
