AIF-C01 — AWS Certified AI Practitioner Quick Reference

Last revised: June 29, 2026

Compact AWS Certified AI Practitioner (AIF-C01) reference for AI/ML concepts, AWS services, generative AI, security, governance, and exam decision points.

Exam focus at a glance

This independent Quick Reference supports preparation for the AWS Certified AI Practitioner (AIF-C01) exam from AWS. Use it to quickly connect AI/ML concepts, AWS service choices, responsible AI, and security/governance decisions.

What to recognize quickly	Exam-prep cue
AI vs ML vs deep learning vs generative AI	AI is the broad field; ML learns from data; deep learning uses neural networks; generative AI creates new content using foundation models.
Managed AI service vs custom ML model	Use managed AI services for common tasks; use Amazon SageMaker when you need custom training, tuning, deployment, or MLOps.
Amazon Bedrock vs Amazon SageMaker	Bedrock is for building with foundation models and generative AI APIs; SageMaker is for building, training, tuning, deploying, and monitoring ML models.
Prompt engineering vs RAG vs fine-tuning	Prompting changes instructions; RAG adds retrieved knowledge; fine-tuning changes model behavior for a task or style.
Responsible AI risks	Bias, hallucination, toxicity, data leakage, explainability gaps, and misuse.
Security responsibilities	AWS secures the cloud infrastructure; customers secure identities, data, prompts, access, model use, monitoring, and compliance configuration.
Evaluation metrics	Match metric to problem type: precision/recall/F1 for classification, RMSE/MAE for regression, grounding/toxicity/human review for generative AI.

Core AI, ML, and generative AI vocabulary

Term	Compact meaning	High-yield distinction
Artificial intelligence	Systems that perform tasks associated with human intelligence	Broad umbrella: includes ML, rules, optimization, NLP, vision, robotics
Machine learning	Models learn patterns from data	Not explicitly programmed rules for every case
Deep learning	ML using multi-layer neural networks	Common for language, images, speech, complex patterns
Foundation model	Large model trained on broad data and adaptable to many tasks	Base for generative AI, chat, summarization, embeddings, code, image tasks
Large language model	Foundation model focused on language	Generates, summarizes, classifies, extracts, reasons over text
Multimodal model	Works with more than one modality	Text plus images, audio, video, or documents
Token	Unit of text processed by a model	Cost, latency, and context capacity are affected by token usage
Embedding	Numeric vector representing semantic meaning	Used for similarity search, clustering, recommendations, and RAG
Prompt	Input instructions and context sent to a model	Better prompts can improve output without retraining
Inference	Using a trained model to make predictions or generate output	Different from training or fine-tuning
RAG	Retrieval-Augmented Generation	Retrieves trusted context before generation; useful for private/current facts
Fine-tuning	Additional training on labeled or curated examples	Best for task behavior, style, or format; not ideal for constantly changing facts
Hallucination	Plausible but incorrect model output	Mitigate with grounding, retrieval, validation, guardrails, and human review
Bias	Systematic unfairness or skew in data/model output	Can come from data, labels, sampling, features, or feedback loops
Feature	Input variable used by a model	Feature quality strongly affects ML performance
Label	Known target value for supervised learning	Example: fraud/not fraud, price, category
Ground truth	Trusted correct answer or label	Needed for training and evaluation
Training set	Data used to fit model parameters	Should not include validation/test leakage
Validation set	Data used to tune model choices	Helps select features, hyperparameters, thresholds
Test set	Held-out data for final evaluation	Should represent real future data
Overfitting	Performs well on training data but poorly on new data	Often too complex, too little data, or leakage
Underfitting	Model too simple to capture patterns	Poor training and validation performance
Drift	Data or relationship changes over time	Requires monitoring and possible retraining
MLOps	Operational practices for ML lifecycle	Includes versioning, deployment, monitoring, rollback, governance

AWS AI service selection matrix

Need	Primary AWS service to consider	Choose when	Common trap
Build generative AI app with foundation models	Amazon Bedrock	You need managed access to FMs, chat, summarization, RAG, agents, embeddings, or guardrails	Confusing Bedrock with full custom ML training infrastructure
Build, train, tune, deploy, and monitor custom ML	Amazon SageMaker	You need notebooks, training jobs, model registry, endpoints, batch inference, monitoring, or MLOps	Choosing Bedrock when the scenario requires custom training pipelines
No-code/low-code ML for business users	Amazon SageMaker Canvas	Users need predictions without writing code	Assuming every ML scenario requires writing training code
Enterprise assistant over business data	Amazon Q Business	You need a managed workplace assistant connected to enterprise content	Using Bedrock directly when the requirement is a ready business assistant
Developer coding assistant	Amazon Q Developer	You need code suggestions, explanations, or development assistance	Confusing developer productivity assistant with a general ML platform
Text sentiment, entities, key phrases, language detection	Amazon Comprehend	You need managed NLP extraction/classification	Using a foundation model for simple standard NLP when a specialized service fits
Speech to text	Amazon Transcribe	Convert audio into text	Confusing with Amazon Polly, which creates speech from text
Text to speech	Amazon Polly	Generate natural-sounding speech from text	Confusing with Transcribe
Translate text	Amazon Translate	Machine translation across languages	Using custom LLM prompts when a managed translation service is enough
Chatbot/contact center conversational interface	Amazon Lex	Build voice/text conversational bots	Confusing with Bedrock chat; Lex manages intents, slots, and bot flow
Enterprise search	Amazon Kendra	Search across enterprise documents with relevance and connectors	Confusing with generic vector search or log/search analytics
Search, analytics, vector similarity	Amazon OpenSearch Service	Need search indexes, log analytics, vector search, similarity retrieval	Choosing Kendra when you need lower-level search/vector control
Extract text, tables, forms from documents	Amazon Textract	OCR plus structured document extraction	Confusing with Rekognition image/video labels
Image/video labels, faces, moderation	Amazon Rekognition	Computer vision for images/video	Using Textract for object/face detection
Personalized recommendations	Amazon Personalize	Recommendations without building the full ML stack	Assuming recommendation systems always require SageMaker
Human data labeling	Amazon SageMaker Ground Truth	Need labeled datasets with workflows and human review	Treating unlabeled raw data as ready for supervised learning
Data catalog and ETL	AWS Glue	Prepare/catalog data for analytics or ML	Confusing data preparation with model training
Object storage for datasets/artifacts	Amazon S3	Store raw data, training data, model artifacts, logs	Not automatically a catalog, access governance, or model registry
Data lake permissions	AWS Lake Formation	Govern data lake access and permissions	Assuming S3 bucket policies alone cover all lake governance needs
Data discovery/governance collaboration	Amazon DataZone	Share, catalog, discover, and govern data across teams	Confusing with model monitoring or AI guardrails

Fast decision path: managed AI, generative AI, or custom ML

    flowchart TD
	    A[AI requirement] --> B{Common prebuilt task?}
	    B -->|Speech, OCR, vision, translation, NLP| C[Use specialized AWS AI service]
	    B -->|No| D{Need generated language, chat, summarization, embeddings, agents?}
	    D -->|Yes| E{Needs private or current knowledge?}
	    E -->|Yes| F[Amazon Bedrock + RAG / Knowledge Bases]
	    E -->|No| G[Amazon Bedrock prompt, FM, or agent]
	    D -->|No| H{Need custom predictive model?}
	    H -->|Business user/no code| I[SageMaker Canvas]
	    H -->|Code, training, tuning, MLOps| J[Amazon SageMaker]
	    H -->|No| K[Re-check problem; may be analytics, automation, or search]

Amazon Bedrock and generative AI reference

Bedrock concept	What it does	Exam decision cue
Foundation models	Pretrained models available through a managed service	Choose based on task, modality, quality, latency, cost, context needs, and customization support
Model inference	Send prompt/input and receive output	Core operation for chat, generation, summarization, classification, extraction
Embeddings model	Converts content into vectors	Required for semantic search and many RAG designs
Knowledge Bases for Amazon Bedrock	Managed RAG workflow over enterprise data sources/vector stores	Use when the scenario says ground responses in private documents
Agents for Amazon Bedrock	Orchestrates tasks and can call tools/APIs	Use when the model must take actions or complete multi-step workflows
Guardrails for Amazon Bedrock	Applies safety, topic, content, and policy controls	Use to reduce unsafe, off-topic, or noncompliant outputs; not a replacement for IAM
Model customization	Adapts supported models using your data	Use when prompt/RAG are insufficient for behavior, domain language, or output style
Model evaluation	Compares models and outputs against criteria	Use before selecting or changing models; include quality, safety, latency, and cost
Prompt management	Version and manage prompts	Useful when prompts are application assets requiring repeatability and change control
Inference parameters	Control output style and length	Temperature/top-p affect variability; max tokens affects length/cost/latency

Foundation model selection checklist

Factor	Ask this
Task fit	Is the model strong for chat, summarization, code, extraction, image, or embeddings?
Modality	Does it support required inputs and outputs: text, image, audio, document, code?
Quality	Does it meet accuracy, reasoning, grounding, and formatting requirements?
Latency	Can it respond within user or workflow expectations?
Cost efficiency	Can a smaller or more specialized model meet the requirement?
Context handling	Can the model handle the needed prompt plus retrieved context?
Safety	Are guardrails, moderation, and evaluation adequate for the use case?
Customization	Does the model support the needed fine-tuning or customization method?
Governance	Can access, logging, data handling, and compliance expectations be met?

Prompt engineering quick reference

Pattern or parameter	Use it for	Watch for
Clear task instruction	Tell the model exactly what to do	Vague prompts lead to broad or inconsistent output
Role/context	“Act as a support analyst…”	Role alone does not guarantee correctness
Delimiters	Separate instructions, source text, examples, and output schema	Reduces prompt confusion and injection risk
Few-shot examples	Show desired input/output behavior	Bad examples teach bad behavior
Output schema	Request JSON, table, bullet list, or strict fields	Validate output; models can still produce malformed structures
Grounding context	Provide authoritative content to answer from	Ask model to say when context is insufficient
Step decomposition	Break complex tasks into smaller steps	Do not expose sensitive reasoning if not needed
Low temperature	More consistent, deterministic-style outputs	May reduce creativity
Higher temperature	Brainstorming or varied creative outputs	Can increase inconsistency or hallucination
Top-p	Controls sampling diversity	Do not randomly tune without evaluation
Max tokens	Limits response length	Too low can truncate; too high can increase cost/latency
Stop sequences	End generation at desired markers	Misconfigured stops can cut off valid output
Negative instructions	Tell the model what to avoid	Pair with positive instructions and validation

Prompt safety traps

Trap	Mitigation
Putting secrets in prompts	Do not send credentials, private keys, or unnecessary sensitive data
Trusting user-provided instructions inside documents	Treat retrieved or uploaded content as untrusted data, not system instructions
Assuming prompt wording is a security control	Use IAM, authorization, validation, logging, and guardrails
Relying on “always answer correctly” wording	Use grounding, citations, evaluation, and human review
Overloading prompts with irrelevant context	Retrieve only relevant chunks and keep prompts focused

RAG: Retrieval-Augmented Generation

RAG is high yield for AIF-C01 because it connects generative AI with enterprise data, embeddings, vector search, and hallucination reduction.

RAG step	What happens	AWS-oriented cue
Ingest	Collect documents/data	Amazon S3 and enterprise data sources are common starting points
Prepare	Clean, split, and chunk content	Chunk size affects retrieval quality and prompt cost
Embed	Convert chunks to vectors	Use an embeddings model, often through Amazon Bedrock
Store/index	Save vectors and metadata	Vector-capable stores or managed knowledge base integrations
Retrieve	Find relevant chunks for a query	Similarity search plus filters improves relevance
Augment prompt	Add retrieved context to the prompt	Tell model to answer only from provided context when needed
Generate	Foundation model produces response	Include citations or references when required
Evaluate	Measure grounding and answer quality	Test with real questions and known answers
Monitor	Track failures, drift, latency, cost	Update indexes when source content changes

RAG vs fine-tuning vs prompt-only

Technique	Best when	Not best when
Prompt-only	Task is simple; instructions and examples fit in context	Need large private knowledge base or persistent behavior change
RAG	Need current, proprietary, or citeable facts	Need model to learn a new style deeply or change internal behavior
Fine-tuning	Need consistent task behavior, tone, format, or domain adaptation	Facts change frequently; retrieval would be easier
Continued pretraining	Need broader domain language adaptation for supported models	Small task-specific changes or quick iteration
Full custom ML	Need model architecture/control/training pipeline beyond FM application patterns	A managed FM app already satisfies the use case

Machine learning problem types

Problem type	Goal	Example	Common metric family
Binary classification	Predict one of two classes	Fraud/not fraud	Accuracy, precision, recall, F1, ROC-AUC
Multiclass classification	Predict one of many classes	Ticket category	Accuracy, macro/micro F1
Regression	Predict numeric value	House price, demand	MAE, MSE, RMSE, R-squared
Clustering	Group similar items without labels	Customer segments	Silhouette, business validation
Anomaly detection	Find unusual observations	Suspicious transactions	Precision/recall, false positive rate
Forecasting	Predict future time-based values	Inventory demand	MAE, MAPE, RMSE
Recommendation	Suggest relevant items	Product recommendations	Click-through, ranking metrics, conversion
Natural language processing	Understand/process text	Sentiment, entities	Accuracy/F1 or task-specific metrics
Computer vision	Analyze images/video	Defect detection	Precision/recall, IoU for detection
Reinforcement learning	Learn actions through rewards	Optimization/control	Reward over time, policy performance

Learning approaches

Approach	Uses labeled data?	Output	Exam cue
Supervised learning	Yes	Predict label or value	Classification and regression
Unsupervised learning	No	Discover structure	Clustering, dimensionality reduction, anomaly discovery
Semi-supervised learning	Some	Uses small labeled plus large unlabeled data	Useful when labels are expensive
Reinforcement learning	Uses rewards	Policy/action strategy	Agent learns through interaction
Self-supervised learning	Labels derived from data itself	Representations/foundation models	Common in large-scale pretraining
Transfer learning	Starts from pretrained model	Adapts to new task	Reduces data/training needs
Active learning	Model selects examples needing labels	Efficient labeling	Useful when human labels are costly

Amazon SageMaker lifecycle reference

Lifecycle phase	SageMaker/AWS capability	What to know for the exam
Data storage	Amazon S3	Common storage for datasets, features, artifacts, logs
Data prep	AWS Glue, SageMaker Data Wrangler	Clean, transform, and prepare data
Labeling	SageMaker Ground Truth	Human labeling workflows for supervised ML
Exploration	SageMaker Studio / notebooks	Development environment for data scientists
No-code ML	SageMaker Canvas	Business users can build predictions without coding
Automated ML	SageMaker Autopilot	Automatically builds and compares candidate models
Training	SageMaker training jobs	Managed infrastructure for model training
Tuning	Hyperparameter tuning	Searches for better model settings
Experiment tracking	SageMaker Experiments	Tracks runs, parameters, metrics
Model packaging	Model artifacts and containers	Needed before deployment
Registry/governance	SageMaker Model Registry	Version, approve, and manage models
Real-time inference	SageMaker endpoints	Low-latency online predictions
Batch inference	SageMaker Batch Transform	Offline predictions over batches
Intermittent/serverless inference	SageMaker Serverless Inference	Variable or unpredictable traffic patterns
Long-running/large async requests	SageMaker Asynchronous Inference	Decoupled request/response workloads
Monitoring	SageMaker Model Monitor	Detect data quality and drift issues
Bias/explainability	SageMaker Clarify	Analyze bias and feature attribution/explainability
Pipelines	SageMaker Pipelines	Automate ML workflows and CI/CD-style steps

Evaluation metrics

Confusion matrix terms

Term	Meaning
True positive	Model predicted positive, and actual is positive
False positive	Model predicted positive, but actual is negative
True negative	Model predicted negative, and actual is negative
False negative	Model predicted negative, but actual is positive

Classification metric selection

Metric	Use when	Trap
Accuracy	Classes are balanced and error costs are similar	Misleading with imbalanced classes
Precision	False positives are costly	High precision can miss many real positives
Recall	False negatives are costly	High recall can increase false positives
F1 score	Need balance between precision and recall	Hides whether precision or recall matters more
ROC-AUC	Compare ranking quality across thresholds	Can be less intuitive for severe class imbalance
Confusion matrix	Need error breakdown by class	Not a single optimization metric

\[ \begin{aligned} \text{Precision} &= \frac{TP}{TP + FP} \\ \text{Recall} &= \frac{TP}{TP + FN} \\ \text{F1} &= 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}} \end{aligned} \]

Regression metric selection

Metric	Use when	Trap
MAE	Need average absolute error in original units	Treats all errors linearly
MSE	Want to penalize larger errors more	Squared units are harder to interpret
RMSE	Want original units while penalizing large errors	Sensitive to outliers
R-squared	Need explained variance view	Can be misleading alone

\[ \begin{aligned} \text{MAE} &= \frac{1}{n}\sum_{i=1}^{n} |y_i - \hat{y}_i| \\ \text{MSE} &= \frac{1}{n}\sum_{i=1}^{n} (y_i - \hat{y}_i)^2 \\ \text{RMSE} &= \sqrt{\frac{1}{n}\sum_{i=1}^{n} (y_i - \hat{y}_i)^2} \end{aligned} \]

Generative AI evaluation

Evaluation area	What to check
Relevance	Does the response answer the user’s question?
Groundedness	Is the answer supported by provided context or trusted sources?
Factuality	Are statements correct?
Hallucination rate	How often unsupported or fabricated claims appear
Toxicity/safety	Whether output violates safety or content policies
Bias/fairness	Whether outputs treat groups unfairly
Robustness	Whether output remains acceptable across prompt variations
Format adherence	Whether JSON, tables, or required fields are valid
Latency	Whether response time meets requirements
Cost efficiency	Whether token/model choices are appropriate
Human preference	Human review or pairwise comparison where automated metrics are insufficient

Responsible AI reference

Risk	What it looks like	Mitigation options
Bias	Unequal performance across groups	Representative data, bias testing, SageMaker Clarify, human review
Hallucination	Confident false answer	RAG, citations, grounding checks, refusal rules, human approval
Toxic output	Harmful, unsafe, abusive content	Amazon Bedrock Guardrails, moderation, testing, policy controls
Data leakage	Sensitive data appears in prompts/logs/outputs	Data classification, redaction, IAM, encryption, logging controls
Prompt injection	User or document tries to override instructions	Separate trusted instructions from untrusted content; validate tool calls
Overreliance	Users accept AI output without judgment	Human-in-the-loop for high-impact decisions
Lack of explainability	Cannot justify prediction	Interpretable models, feature attribution, documentation
Model drift	Performance degrades over time	Monitoring, retraining, alerts, evaluation baselines
Data poisoning	Training/retrieval data is manipulated	Source validation, access controls, lineage, review workflows
Inappropriate use	Model used outside intended context	Usage policies, access control, monitoring, user education

Responsible AI principles to connect to scenarios

Principle	Practical exam interpretation
Fairness	Test for disparate impact and biased outcomes
Explainability	Provide understandable reasons or feature influence where needed
Privacy	Minimize, protect, and control sensitive data
Safety	Prevent harmful, toxic, or unsafe outputs/actions
Transparency	Document model purpose, limitations, data, and intended use
Robustness	Validate behavior under varied inputs and edge cases
Accountability	Assign ownership, approvals, monitoring, and escalation paths
Human oversight	Keep humans in control for high-risk or ambiguous decisions

Security and governance for AI workloads on AWS

Control area	AWS services/features	Exam-prep distinction
Identity and authorization	AWS Identity and Access Management, IAM roles, policies	Least privilege controls who can invoke models, access data, deploy endpoints
Central identity	AWS IAM Identity Center	Workforce access management; not a model evaluation tool
Encryption at rest	AWS Key Management Service, service encryption features	Protect datasets, logs, model artifacts, vector stores
Encryption in transit	TLS/service endpoints	Protect data moving between clients and services
Network isolation	VPC design, security groups, private connectivity where supported	Reduce public exposure for data and inference paths
Secrets	AWS Secrets Manager, AWS Systems Manager Parameter Store	Do not hardcode API keys or database credentials
Logging	AWS CloudTrail, Amazon CloudWatch Logs	CloudTrail records API activity; CloudWatch collects metrics/logs/alarms
Monitoring	Amazon CloudWatch, SageMaker Model Monitor	System health plus model/data quality monitoring
Data discovery	Amazon Macie	Find and help protect sensitive data in Amazon S3
Threat detection	Amazon GuardDuty	Detect suspicious activity; not an AI quality tool
Configuration governance	AWS Config	Track resource configuration and compliance rules
Organization guardrails	AWS Organizations, service control policies	Restrict actions across accounts
Data lake governance	AWS Lake Formation	Fine-grained data lake permissions
AI output controls	Amazon Bedrock Guardrails	Safety/content controls; not a substitute for IAM, encryption, or monitoring

Shared responsibility reminder

AWS is responsible for	Customer is responsible for
Security of AWS infrastructure	Data classification and lawful/appropriate use
Managed service infrastructure operations	IAM policies, roles, access boundaries
Physical facilities and core cloud platform	Prompt content, uploaded data, and retrieval sources
Availability of AWS service controls	Configuration of logging, encryption, monitoring, and guardrails
Service security features	Evaluating outputs, handling bias, hallucination, and misuse risks

Data foundations for AI on AWS

Data need	AWS service	Why it matters for AI
Durable object storage	Amazon S3	Common location for raw, curated, training, and inference data
Catalog and ETL	AWS Glue	Makes data discoverable and transformable
Query data in S3	Amazon Athena	Serverless SQL queries for data exploration
Data warehouse	Amazon Redshift	Analytics at scale; can feed ML and business intelligence
Streaming data	Amazon Kinesis, Amazon MSK	Real-time event ingestion for analytics/ML pipelines
Operational relational data	Amazon RDS, Amazon Aurora	Structured application data
Key-value/noSQL data	Amazon DynamoDB	Low-latency application data and metadata
Search/vector retrieval	Amazon OpenSearch Service	Search, log analytics, vector similarity
Data governance	AWS Lake Formation, Amazon DataZone	Permissions, discovery, sharing, governance
Sensitive data discovery	Amazon Macie	Helps identify sensitive data before using it in AI workflows

Deployment and inference patterns

Pattern	Choose when	AWS cue
Real-time inference	User or application needs immediate response	SageMaker endpoint or Bedrock model invocation
Batch inference	Large set of predictions can run offline	SageMaker Batch Transform or batch application workflow
Asynchronous inference	Requests are large or processing takes longer	Decoupled request handling with async pattern
Serverless inference	Traffic is intermittent or unpredictable	Avoid managing always-on capacity where supported
Edge inference	Need local/low-latency processing near devices	Consider edge-capable deployment patterns
API-backed GenAI app	Application calls model through API	Common with Amazon Bedrock, AWS Lambda, Amazon API Gateway
Human-in-the-loop	Decisions need review or labeling	SageMaker Ground Truth or workflow approval patterns
MLOps pipeline	Repeatable build/test/deploy/monitor	SageMaker Pipelines, Model Registry, CI/CD integration

Cost and performance levers

Lever	Why it matters
Choose the right model size	Smaller/specialized models may be faster and cheaper if quality is sufficient
Reduce unnecessary tokens	Shorter prompts and outputs can reduce latency and cost
Use retrieval carefully	More context can improve grounding but increases prompt size
Cache repeated outputs where appropriate	Reduces repeated inference for identical or stable requests
Batch offline work	Often more efficient than real-time calls for noninteractive workloads
Monitor utilization	Avoid idle always-on resources when usage is intermittent
Tune thresholds	Classification threshold changes precision/recall tradeoff without retraining
Evaluate before scaling	Do not scale a poor prompt/model/pipeline before measuring quality
Automate cleanup	Remove unused notebooks, endpoints, artifacts, and logs according to policy
Track business metric	Accuracy alone may not prove business value

High-yield AWS distinctions

Distinction	Choose this when	Not this when
Amazon Bedrock vs SageMaker	Bedrock for managed foundation model apps	SageMaker for full custom ML lifecycle
Amazon Q Business vs Bedrock	Q Business for ready enterprise assistant	Bedrock for custom GenAI application/platform control
Amazon Q Developer vs Bedrock	Q Developer for coding assistance	Bedrock for building your own app
Textract vs Rekognition	Textract extracts document text/forms/tables	Rekognition detects labels, objects, faces, video content
Transcribe vs Polly	Transcribe converts speech to text	Polly converts text to speech
Translate vs Comprehend	Translate changes language	Comprehend analyzes text meaning/entities/sentiment
Kendra vs OpenSearch	Kendra for managed enterprise search relevance	OpenSearch for search infrastructure, logs, vector search control
RAG vs fine-tuning	RAG for current/private factual knowledge	Fine-tuning for behavior, style, or task adaptation
Guardrails vs IAM	Guardrails influence model content/safety	IAM controls who can access what
CloudWatch vs CloudTrail	CloudWatch monitors metrics/logs/alarms	CloudTrail records API activity
Model Monitor vs Clarify	Model Monitor detects drift/data quality issues	Clarify helps with bias and explainability
Accuracy vs F1	Accuracy for balanced classes	F1 for precision/recall balance, especially imbalance
Precision vs recall	Precision reduces false positives	Recall reduces false negatives

Common AIF-C01 scenario cues

If the question says…	Think…
“Summarize internal policy documents accurately”	Amazon Bedrock with RAG/Knowledge Bases; evaluate groundedness
“Reduce hallucinations using company documents”	RAG, citations, retrieval quality, guardrails, human review
“Build a chatbot with intents and slots”	Amazon Lex
“Convert call recordings to text”	Amazon Transcribe
“Generate spoken audio from text”	Amazon Polly
“Extract fields from invoices or forms”	Amazon Textract
“Detect objects or unsafe image content”	Amazon Rekognition
“Analyze sentiment and entities in text”	Amazon Comprehend
“Business user wants no-code predictions”	SageMaker Canvas
“Data scientist needs training jobs and model endpoints”	Amazon SageMaker
“Need human labelers for training data”	SageMaker Ground Truth
“Need to compare model versions and approve deployment”	SageMaker Model Registry
“Need to detect drift after deployment”	SageMaker Model Monitor
“Need to analyze bias or feature attribution”	SageMaker Clarify
“Need a workplace assistant over enterprise data”	Amazon Q Business
“Need code suggestions in IDE”	Amazon Q Developer
“Need log/metric alarms”	Amazon CloudWatch
“Need record of who called what API”	AWS CloudTrail
“Need find sensitive data in S3”	Amazon Macie
“Need restrict accounts from using certain actions”	AWS Organizations service control policies

Data quality and model quality traps

Trap	Why it matters
Training/test leakage	Inflates evaluation; model may fail in production
Imbalanced classes	Accuracy can look high while minority class performance is poor
Nonrepresentative data	Model performs poorly for real users or future conditions
Label noise	Supervised model learns incorrect patterns
Missing values	Can bias results or break pipelines if untreated
Outliers	Can distort regression and distance-based models
Correlation mistaken for causation	ML predictions do not automatically prove cause
Optimizing only technical metrics	Business outcome, risk, fairness, and cost may be unacceptable
Ignoring threshold selection	Same model can behave very differently at different classification thresholds
No monitoring after deployment	Drift, data changes, and degradation go unnoticed

Quick pre-exam checklist

Can you distinguish Amazon Bedrock, Amazon SageMaker, Amazon Q, and specialized AWS AI services?
Can you choose between prompt engineering, RAG, fine-tuning, and custom ML?
Can you match metrics to classification, regression, and generative AI evaluation?
Can you explain precision vs recall and when false positives or false negatives matter?
Can you identify responsible AI controls for bias, hallucination, toxicity, privacy, and explainability?
Can you separate IAM/security controls from model safety guardrails?
Can you identify the role of CloudWatch, CloudTrail, KMS, Macie, Lake Formation, and AWS Organizations in AI governance?
Can you recognize when a scenario needs human review, data labeling, model monitoring, or retraining?

Practical next step

Use this Quick Reference to drill scenario questions: for each prompt, first identify the problem type, then choose the AWS service, then name the key security, governance, evaluation, or responsible AI control that makes the answer complete.

Scenario Guide

Fundamentals of AI and ML