# AWS Certified Machine Learning Engineer - Associate (MLA-C02 (beta)) Free Practice Exam and Practice Test

MLA-C02 (beta) · ASSOCIATE. Page: https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate

> Prepare for the AWS Certified Machine Learning Engineer - Associate exam with our practice exam simulator. Realistic questions with detailed explanations help you find your knowledge gaps and assess your readiness to build and run ML workloads on AWS.

Exam version MLA-C02: beta, beta start Sep 29, 2026. All exam dates: https://blowstack.com/tools/cloud-certifications/aws

## Exam at a glance

- Question bank: 861 practice questions
- Questions updated: 2026-10-29
- Free MLA-C02 (beta) practice exam (20 questions weighted by domain, in the exam simulator on this page, no sign-up): https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate
- MLA-C02 (beta) exam simulator (full-length or custom exams with explanations and a pass probability indicator): https://app.blowstack.com/practice-exams/configurator/aws-certified-machine-learning-engineer-associate
- Questions: 65
- Duration: 130 min
- Passing score: 72%
- Domains: 4
- Interactive MLA-C02 (beta) course (391 lessons built around exercises, no videos): https://blowstack.com/courses/aws-certified-machine-learning-engineer-associate
- Official MLA-C02 (beta) exam guide (the AWS document listing every domain, task and service in scope): https://docs.aws.amazon.com/aws-certification/latest/machine-learning-engineer-associate-02/machine-learning-engineer-associate-02.html

## MLA-C02 (beta) example questions

One example question per domain from the MLA-C02 (beta) question bank, with the correct answer and its explanation.

### Data Preparation for ML and AI

**Question:**

A retailer stores transaction records in Amazon RDS for MySQL. An ML team needs an initial copy of the records in Amazon S3 and an ongoing feed of committed inserts, updates, and deletes for feature preparation. After the initial load, the feed must preserve successive changes to the same record, even when those changes occur between extraction runs. The application permanently deletes some records and cannot be modified to produce change events. Which solution meets these requirements with the least custom development?

**Correct answer:** Enable the required row-based binary logging and configure sufficient log retention on the database. Use an AWS DMS full-load-and-CDC task with the database as the source and Amazon S3 as the target.

**Explanation:** AWS DMS can perform the initial table load and then capture committed inserts, updates, and deletes from MySQL binary logs. Its S3 target can store ongoing change records, including operation indicators. This avoids building custom change-capture logic or modifying the application.

### ML Model and Foundation Model (FM) Development

**Question:**

A machine learning engineer runs a TensorFlow training job on an Amazon EC2 GPU instance using an AWS Deep Learning Container. Each epoch contains 200 batches, and the optimizer performs one update per batch. The engineer intends to halve the learning rate every 5 epochs during a 20-epoch run. The training script uses tf.keras.optimizers.schedules.ExponentialDecay(initial_learning_rate=0.001, decay_steps=5, decay_rate=0.5, staircase=False). Training loss improves during the first few batches but then stops improving. Logs show that the learning rate becomes nearly zero during the first epoch, while gradients remain finite and nonzero. Which change best addresses the convergence issue while implementing the intended decay interval?

**Correct answer:** Set decay_steps=1000 and retain the initial learning rate and decay rate.

**Explanation:** TensorFlow ExponentialDecay measures decay_steps in optimizer updates, not epochs. With 200 updates per epoch, 5 epochs correspond to 1,000 updates. This change makes the learning rate halve over each intended 5-epoch interval instead of decaying almost to zero during the first epoch.

### Deployment and Orchestration of ML and AI Workflows

**Question:**

A media company must run a trained video-classification model against 1,200 independent input shards in Amazon S3 each weekend. Each shard requires one NVIDIA GPU and approximately 75 minutes of processing. Results are needed the next day, not interactively. The existing container runs a command-line inference program that reads a shard and writes predictions to Amazon S3; it does not implement an HTTP inference server. The company cannot modify the container and wants AWS to provision and scale the compute capacity, with no running compute instances between workloads. Which solution meets these requirements?

**Correct answer:** Create an AWS Batch managed EC2 compute environment with GPU-capable instance types and minimum vCPUs set to zero. Associate it with a job queue, define a job that requests one GPU, and submit an array job whose children each process one shard.

**Explanation:** AWS Batch can run the existing command-line container without an inference server. A managed EC2 compute environment provisions GPU-capable capacity for queued jobs and can scale down to zero instances when idle. Each array child can use its array index to select an independent input shard and write predictions to S3.

### Operating, Monitoring, and Securing ML and AI Solutions

**Question:**

A company is selecting an Amazon EC2 instance configuration for a synchronous image-classification API. Traffic alternates between sparse requests and sustained bursts. The API must return a complete response within 100 milliseconds for at least 99% of requests during both traffic patterns.

An ML engineer tests four configurations using representative requests. Each configuration meets the required throughput and model accuracy. The client-observed latency includes network transport, preprocessing, batch waiting, model execution, and response delivery. The table shows the higher p99 latency observed across the sparse-traffic and burst-traffic tests. Prices are illustrative.

| Configuration | Hourly cost per instance | p99 model execution latency | p99 client-observed latency |
|---|---:|---:|---:|
| Compute-optimized CPU, no batching | $0.60 | 85 ms | 125 ms |
| Inference accelerator, batches of up to 32 requests | $0.85 | 18 ms | 145 ms |
| Small GPU instance, no batching | $1.20 | 42 ms | 78 ms |
| Large GPU instance, no batching | $2.40 | 24 ms | 58 ms |

The company will use the same fixed instance count for every configuration. It must select one of the tested configurations without further serving changes. Which choice meets the response-time requirement at the lowest instance cost?

**Correct answer:** Select the small GPU configuration because its client-observed p99 latency meets the deadline and its hourly cost is the lowest among compliant configurations.

**Explanation:** The small GPU configuration has a client-observed p99 latency of 78 milliseconds across both traffic patterns, meeting the 100-millisecond requirement. Only the two GPU configurations meet that requirement, and the small GPU configuration costs less. With the same instance count, it also provides the lowest compliant fleet cost.

## Free MLA-C02 (beta) cheat sheets

- [Domain 1: Data Preparation for ML and AI](https://blowstack.com/cheat-sheets/aws-certified-machine-learning-engineer-associate/mla-c02 (beta)-domain-1.pdf) (28% of the exam, PDF)
- [Domain 2: ML Model and Foundation Model (FM) Development](https://blowstack.com/cheat-sheets/aws-certified-machine-learning-engineer-associate/mla-c02 (beta)-domain-2.pdf) (24% of the exam, PDF)
- [Domain 3: Deployment and Orchestration of ML and AI Workflows](https://blowstack.com/cheat-sheets/aws-certified-machine-learning-engineer-associate/mla-c02 (beta)-domain-3.pdf) (24% of the exam, PDF)
- [Domain 4: Operating, Monitoring, and Securing ML and AI Solutions](https://blowstack.com/cheat-sheets/aws-certified-machine-learning-engineer-associate/mla-c02 (beta)-domain-4.pdf) (24% of the exam, PDF)

## Exam domains

The MLA-C02 (beta) questions are grouped into 4 domains divided into 12 tasks.

### Data Preparation for ML and AI (28% of the exam)

- Collect and store data
- Perform data transformation, feature engineering, and pre-processing
- Validate data quality and manage bias

### ML Model and Foundation Model (FM) Development (24% of the exam)

- Choose appropriate modeling approaches for ML and AI solutions
- Train, fine-tune, and customize models for ML and AI solutions
- Analyze and evaluate the performance of ML and AI systems

### Deployment and Orchestration of ML and AI Workflows (24% of the exam)

- Manage deployment infrastructure for ML and AI model types
- Provision and configure resources for ML and AI workloads based on existing architecture and requirements
- Implement automated orchestration and continuous integration and continuous delivery (CI/CD) pipelines for MLOps and AI workloads

### Operating, Monitoring, and Securing ML and AI Solutions (24% of the exam)

- Monitor ML and AI model inference and performance
- Optimize and manage ML and AI infrastructure costs and performance
- Secure ML and AI workloads and model endpoints

## Exam mode and practice mode

| | Exam mode | Practice mode |
|---|---|---|
| Questions count | 65 | 1 - 75 |
| Time limit | 130 minutes | Optional, 10 - 200 minutes |
| Exam scope | 4 domains with the official questions ratio | Selected domains with the official questions ratio |
| Correct answers | After exam submission | After exam submission or after each answer |
| Question types | Single answer and multiple answer | Single answer, multiple answer or all types |
| Question hints | Never | Optional |
| Question domain | Revealed after exam submission | Revealed after submission or during the exam |
| Scoring | 15 of 65 questions do not count towards the result | Official AWS method or mathematical mean |

See all simulator features on the AWS Exam Simulator page: https://blowstack.com/practice-exams

## Technologies and concepts

- **A/B Testing**: A/B testing compares a baseline with an alternative under similar conditions to determine whether a change improves outcomes. For foundation model applications, it helps engineers evaluate changes to models, prompts, or retrieval configurations using real-world task success, human feedback, safety, latency, and cost rather than relying only on benchmark scores.
- **Access Control**: Access control turns security requirements into enforceable permissions for people, applications, and cloud services. It limits unauthorized activity while preserving legitimate operations, including the ability to deliver logs, run health checks, and investigate incidents.
- **AI Agents**: In foundation model applications, an AI agent combines a model with instructions, context, and tools to complete tasks that may require several decisions and interactions with external systems. Agents matter because they can move beyond generating answers to performing business work, but their access, reliability, cost, and degree of autonomy require explicit controls.
- **AI Guardrails**: Guardrails help AI applications produce appropriate responses, protect sensitive information, and avoid unauthorized actions. They combine prompt engineering with independently enforced checks, permissions, and operational monitoring because model instructions alone cannot reliably enforce every requirement.
- **Algorithmic Bias**: Algorithmic bias can arise from training data, labels, model objectives, prompts, retrieval sources, and the way an AI system is deployed. It matters because a technically accurate system can still discriminate, expose users to harm, create legal risk, and undermine customer trust.
- **Amazon EC2 instance types**: An instance type represents a resource profile, allowing engineers to match a virtual machine to an application's performance and compatibility requirements. Understanding these profiles helps avoid bottlenecks, reduce unnecessary spending, and distinguish hardware selection from purchasing options such as On-Demand or Spot.
- **Anomaly Detection**: Anomaly detection compares observed activity with an established baseline, statistical model, or expected pattern to identify unusual behavior. In cloud security, it helps engineers detect potentially compromised identities, unexpected network activity, and abnormal resource usage that fixed rules alone might miss. An anomaly is evidence for investigation, not proof of an attack.
- **Apache Parquet**: Parquet groups values by column, allowing compatible readers to load selected fields and skip irrelevant data rather than scan every record in full. Its typed schema, encodings, and compression make it useful for cloud data lakes and machine learning preparation, especially when workloads repeatedly analyze subsets of large datasets.
- **Approximate Nearest Neighbor Search**: Approximate nearest neighbor (ANN) search retrieves likely nearest matches from large vector collections without guaranteeing that every true nearest neighbor is returned. It enables scalable semantic retrieval for foundation models, recommendation systems, and similarity applications, but requires measuring and tuning recall, latency, memory consumption, and cost.
- **Asynchronous Inference**: Request submission and result delivery are separate operations, usually connected through a queue, background workers, and durable result storage. This pattern supports long-running predictions and uneven workloads when applications can tolerate delayed results, but it requires explicit handling of job status, failures, and capacity.
- **Attribute-Based Access Control**: ABAC expresses access rules using attributes such as project, department, environment, or data classification instead of maintaining separate permissions for every identity and resource. In cloud environments, trusted identity attributes and resource tags can make permissions scale with changing teams and infrastructure, provided attribute assignment and modification are tightly controlled.
- **Audit Logging**: Audit logging creates an evidence trail showing who or what performed an action, when it occurred, which resource was affected, and what the outcome was. In cloud environments, effective auditing requires selecting complementary log sources and protecting their delivery, retention, and accessibility across accounts, Regions, and workloads.
- **AWS SDKs**: An SDK turns application code into requests to cloud services, handling common tasks such as request signing, serialization, credential lookup, and response parsing. Engineers choose SDKs when service operations belong inside an application or custom automation, rather than in a graphical console, shell command, or infrastructure template.
- **Batch Inference**: Batch inference processes accumulated inputs on a schedule or when data becomes available, then stores the results for later use. It is useful when throughput and cost efficiency matter more than immediate responses, such as nightly customer scoring, document classification, or generating recommendations in advance.
- **Batch Size**: Batch size controls how training data is grouped to calculate gradients and update model parameters. It affects accelerator memory, throughput, gradient variability, and the number of updates per epoch, making it an important hyperparameter for both conventional machine learning and foundation model fine-tuning.
- **Bayesian Optimization**: Bayesian optimization learns how configuration choices relate to an objective and balances testing promising settings against exploring uncertain ones. In machine learning, it can reduce the number of costly training runs needed to find effective hyperparameters, although results depend on the search space, evaluation quality, and available budget.
- **Benchmark Datasets**: A benchmark dataset provides a consistent basis for evaluating foundation models using test inputs, reference answers where appropriate, and a defined scoring procedure. It helps engineers compare candidate models, detect regressions, and assess suitability for an application, but its value depends on how well the test cases represent real workloads.
- **BERTScore**: BERTScore compares the meaning represented by individual tokens rather than relying only on matching words or phrases. It is useful for evaluating foundation model outputs that can express an acceptable answer in different ways, but it does not independently establish factual correctness, safety, or instruction compliance.
- **Bias and Fairness**: Bias can enter an AI system through its data, labels, design choices, or operating environment, potentially creating unjustified differences in outcomes. Fairness means evaluating and addressing those differences using criteria appropriate to the application, affected people, and applicable requirements.
- **Bias-Variance Tradeoff**: Models can be inaccurate because they are too simple to capture important patterns or because they fit training-specific details that do not generalize. Managing this balance helps engineers reduce underfitting and overfitting, while responsible AI development also requires checking whether errors disproportionately affect particular demographic groups.
- **Binning**: Binning is a feature engineering technique that groups values such as ages, transaction amounts, or response times into defined ranges. It can simplify relationships, reduce sensitivity to small fluctuations, and improve interpretability, but it also discards information and requires consistent boundaries across training and inference.
- **BLEU**: Bilingual Evaluation Understudy (BLEU) was developed for machine translation and is also used to evaluate foundation-model outputs when reference wording is a meaningful quality signal. It provides a reproducible measure of lexical overlap, but it does not directly establish factual accuracy, semantic equivalence, or usefulness.
- **Blue-Green Deployment**: Two independently deployable environments allow engineers to validate a replacement release while the existing release continues serving users. Switching traffic rather than modifying the live environment reduces deployment disruption and can enable fast rollback, provided data and dependencies remain compatible.
- **Broadcast Joins**: A broadcast join avoids repartitioning the larger dataset by distributing the smaller dataset to the workers processing it. This can reduce network shuffle and mitigate join-key skew, but the replicated input must fit safely within each worker's available memory.
- **Caching**: A cache serves repeated requests without always accessing the original data source or recomputing a result. In cloud architectures, caching can reduce latency, origin load, and data transfer, but it requires deliberate decisions about freshness, capacity, security, and failure behavior.
- **Canary Deployment**: A canary deployment runs the current and candidate versions concurrently, exposing only a limited share of real requests or users to the candidate. Engineers use production metrics and explicit acceptance criteria to decide whether to promote the candidate or redirect traffic to the stable version, reducing the impact of faulty releases.
- **Capacity Planning**: Capacity planning translates expected traffic, data growth, and processing requirements into measurable resource needs. In the cloud, it combines forecasting, benchmarking, scaling policies, service quota management, and failure testing because elastic infrastructure is neither unlimited nor instantaneous.
- **Catastrophic Forgetting**: Updates that improve a model on new examples can overwrite parameter configurations that supported earlier knowledge or skills. This matters during incremental training and foundation-model fine-tuning because better performance on a new domain can conceal regressions in existing production capabilities.
- **Champion/Challenger Testing**: The champion is the approved baseline, while challengers are newly trained models or alternative configurations evaluated against it. This approach makes retraining safer by requiring evidence of improvement before replacement, rather than assuming that a newer model is better.
- **Checkpointing**: A checkpoint records enough information to recover a task without restarting all of its work, such as source positions, intermediate calculations, or an agent's workflow state. It reduces recovery time and repeated computation, but reliable recovery also depends on retained inputs, compatible state, and safe handling of repeated side effects.
- **CI/CD**: Continuous integration validates frequently merged code changes through automated builds and tests, while continuous delivery or continuous deployment automates the path toward production. Together, these practices shorten feedback cycles, make releases more repeatable, and reduce the risks associated with large, manually executed changes.
- **Class Imbalance**: Unequal class frequencies can cause a classifier to favor common outcomes while missing rare but important ones, such as fraud or equipment failures. Responsible AI development requires examining class distributions alongside data quality, inclusivity, and subgroup coverage, then selecting training and evaluation methods that reflect real-world risks.
- **Class Resampling**: Class resampling addresses unequal class representation by removing examples, repeating examples, or generating additional training examples. It can improve learning for rare outcomes in numeric, text, and image datasets, but it must preserve label validity and avoid contaminating evaluation data.
- **Columnar Storage**: Columnar storage places values from the same field together, reducing unnecessary data reads when queries inspect a small subset of columns across many records. It underpins analytical databases and file formats such as Apache Parquet and Apache ORC, often improving query performance and lowering storage and scan costs compared with row-oriented representations.
- **Comma-Separated Values**: CSV provides a widely supported way to exchange flat datasets between applications, cloud storage, analytics engines, and machine learning pipelines. Its simplicity makes ingestion and export straightforward, but reliable processing requires explicit agreements about schema, quoting, missing values, and encoding.
- **Commitment Discounts**: Cloud providers offer lower rates when customers commit to eligible resource usage or spending, commonly for one or three years. These discounts can reduce the cost of predictable workloads, but unused commitments can offset or eliminate the savings.
- **Configuration Drift**: Configuration drift occurs when running infrastructure, operating systems, or applications no longer match their intended configuration, often because of manual changes, competing automation, or incomplete deployments. Detecting and managing drift helps engineers preserve security controls, reproduce environments, and investigate unexpected changes before they cause incidents.
- **Containers**: Containers provide a repeatable way to build, distribute, and run software across development and cloud environments. They improve deployment consistency and resource utilization, but require explicit controls for image security, runtime isolation, networking, identity, and persistent data.
- **Context Window**: The context window limits how much instruction, conversation history, retrieved information, and generated output a model can handle together. Engineers use this limit when selecting foundation models and designing prompts, retrieval pipelines, and conversation management so requests fit without sacrificing relevant information or exceeding cost and latency targets.
- **Continued Pre-Training**: Continued pre-training builds on a foundation model rather than training a new model from scratch, typically using unlabeled documents from a target domain or a newer corpus. It can improve familiarity with specialized language and concepts, but requires careful data preparation, compute budgeting, and evaluation to avoid degrading existing capabilities.
- **Conversation Memory**: Conversation memory lets a generative AI application carry forward relevant messages, user preferences, decisions, and task progress instead of treating every request as unrelated. It is part of context engineering: selecting and organizing the information a foundation model needs for its next response while controlling cost, privacy, and accuracy.
- **Cosine Similarity**: Cosine similarity compares numerical representations such as text and image embeddings using the angle between their vectors. It supports semantic search, recommendation, and retrieval workflows by ranking representations according to directional similarity rather than raw vector length.
- **Cost Allocation**: Cost allocation turns a cloud bill into an accountable view of who consumed resources and which business activities incurred costs. Engineers apply account boundaries, resource metadata, and allocation rules to support budgeting, showback, chargeback, and informed architecture decisions.
- **Cost-Benefit Analysis**: For cloud and AI/ML projects, cost-benefit analysis evaluates whether measurable improvements justify development, infrastructure, operational, and error-related costs compared with simpler alternatives. It helps engineers recognize when predictions provide useful business value and when deterministic software, established rules, or human judgment are more appropriate.
- **Credential Management**: Credentials include passwords, access keys, session tokens, and other material used to prove an identity. Managing their lifecycle reduces credential theft, limits the impact of compromise, and keeps applications working when credentials change or expire.
- **Credential Rotation**: Passwords, access keys, tokens, and application secrets can be exposed through compromised systems, accidental disclosure, or excessive distribution. Rotation limits how long a persistent credential remains usable, but it must coordinate changes across the identity system, secret storage, and consuming applications to avoid outages.
- **Cross-Account Access**: Cloud accounts create administrative and security boundaries, but shared services, deployment pipelines, and operational teams often need controlled access across them. Cross-account access establishes that authorization without requiring shared credentials or moving resources into the same account.
- **Cross-Validation**: Cross-validation reduces dependence on a single train–validation split and helps compare models, preprocessing choices, and hyperparameters. Its reliability depends on preventing information leakage and choosing splits that represent how predictions will be made in production.
- **Data Anonymization**: Data anonymization reduces the risk of identifying people from datasets, including through combinations of attributes or linkage with external information. In cloud analytics and AI systems, it helps protect sensitive training data, prompts, retrieved documents, and outputs, but requires more than simply removing names.
- **Data Augmentation**: Data augmentation increases the variety of training data so models can learn useful patterns rather than memorize particular examples. It can improve robustness and help address underrepresented classes or groups, but only when the generated examples are realistic, correctly labeled, and evaluated against independent data.
- **Data Curation**: For foundation model fine-tuning, data curation turns raw source material into governed, representative examples that teach the desired behavior. It matters because incorrect labels, sensitive information, duplicated examples, and coverage gaps can undermine model quality even when the training process is technically correct.
- **Data Deduplication**: Duplicate records commonly arise from ingestion retries, overlapping extracts, source-system replication, and merging datasets. Deduplication improves analytical accuracy and machine learning data quality, but it requires explicit rules to distinguish redundant copies from legitimate repeated observations.
- **Data Drift**: A model deployed for inference may receive data that differs from the data used to train or validate it, even when the input schema remains unchanged. Monitoring these differences helps engineers identify changing populations, upstream processing errors, and other conditions that warrant investigation before prediction quality deteriorates.
- **Data Integrity**: Data integrity combines controls that prevent improper changes with checks that detect corruption, invalid transformations, and tampering. In cloud and AI systems, it helps ensure that training data, inference inputs, and outputs remain trustworthy and traceable rather than merely accessible or confidential.
- **Data Labeling**: Labels connect input data to the outcomes or interpretations a model should learn, such as a transaction's fraud status or the location of an object in an image. Reliable labeling helps define the learning task, improves training and evaluation quality, and makes model errors easier to investigate.
- **Data Loss Prevention**: Data Loss Prevention combines data classification, inspection, access restrictions, and enforcement at the points where information is stored, processed, or transmitted. In cloud and generative AI applications, it helps prevent confidential records, credentials, and proprietary content from escaping through prompts, retrieved context, model responses, logs, or external tools.
- **Data Masking**: Data masking reduces unnecessary exposure of confidential information in logs, messages, query results, and nonproduction datasets. It complements encryption and access control by limiting which sensitive values users and downstream systems can actually see.
- **Data Poisoning**: Attackers can poison training datasets, fine-tuning examples, feedback records, or external knowledge sources consumed by AI applications. Preventing poisoning requires controls over data provenance, modification permissions, validation, and evaluation because well-written prompts alone cannot establish that the underlying information is trustworthy.
- **Data Profiling**: Data profiling establishes what data actually contains before engineers transform, integrate, or use it for analytics, machine learning, or foundation model applications. Its findings guide cleansing decisions, validation rules, and monitoring thresholds, reducing the risk that inconsistent or unsuitable data reaches downstream consumers.
- **Data Provenance**: Data provenance connects a dataset to its sources, collection conditions, permissions, processing steps, and downstream uses. In AI systems, it helps engineers assess whether training and evaluation data are appropriate, investigate quality or bias issues, reproduce results, and explain the evidence behind model development.
- **Data Quality**: Data quality determines whether engineers can rely on data for analytics, application behavior, and AI training or inference. In secure data engineering, quality assessments work alongside privacy protections, access controls, and integrity checks to reduce unreliable outputs, unauthorized changes, and inappropriate use of sensitive information.
- **Data Representativeness**: Representative data provides appropriate coverage of the populations and situations an AI system will encounter, including relevant minority groups and uncommon but important cases. It supports reliable evaluation and responsible development by reducing coverage gaps that can hide poor performance or unequal outcomes.
- **Data Residency**: Data residency connects the physical location of data to legal, contractual, and organizational requirements. Cloud architectures must account for primary databases, replicas, backups, logs, and downstream systems because choosing a deployment Region alone does not establish compliance.
- **Data Shuffling**: Data often arrives sorted by time, source, class, or customer, and that ordering can distort dataset splits or training batches. Shuffling helps distribute existing examples more evenly, but it does not correct missing populations, class imbalance, biased labels, or other underlying representation problems.
- **Determinism**: Determinism concerns repeatability, not whether an answer comes from explicit rules or a learned model, and not whether that answer is correct. When choosing between conventional software and AI/ML, distinguish repeatable execution from guaranteed compliance with a specification: a model can repeatedly produce the same prediction without satisfying a requirement for an exact calculation or mandatory business rule.
- **Distributed Tracing**: A distributed trace connects individual operations across services into a single view of a request's execution. It helps engineers troubleshoot cloud applications whose behavior cannot be understood from one server's logs or metrics alone.
- **Distributed Training**: Distributed training divides training computation, model state, or both across cooperating workers so that models can train faster or exceed the memory capacity of one device. Effective implementations balance computation against communication and data-loading overhead while preserving correct optimization, reliable recovery, and reproducible job configuration.
- **Document Chunking**: In retrieval-augmented generation (RAG), document chunking determines which passages are embedded, searched, and supplied to a language model as supporting evidence. Effective chunking balances retrieval precision, contextual completeness, model token limits, and operational cost while preserving metadata needed for filtering and citations.
- **Early Stopping**: Early stopping uses evaluation results to decide when to stop updating a model, commonly after a validation metric fails to improve for a configured interval. It can reduce training time and cloud compute costs while limiting overfitting, provided the stopping rule and validation data reflect the intended workload.
- **Effective Permissions**: Assigned permissions do not necessarily equal usable access: authorization combines grants with organizational controls, resource policies, session restrictions, and request context. Understanding the resulting permissions helps engineers design least-privilege access and diagnose why an apparently allowed operation fails.
- **Elasticity**: Elasticity aligns available capacity with actual demand, adding resources during busy periods and releasing them when demand falls. In the cloud, automated provisioning and usage-based pricing can reduce idle capacity and avoid purchasing infrastructure for occasional peaks, while helping applications maintain performance.
- **Embeddings**: An embedding model maps inputs such as text or images into a vector space where related inputs are intended to have similar representations. Embeddings support semantic search, recommendations, clustering, and retrieval-augmented generation by helping applications find relevant information beyond exact keyword matches.
- **Ensemble Learning**: An ensemble uses complementary models and an aggregation strategy to improve predictive accuracy, robustness, or coverage across tasks. In cloud applications, engineers balance those benefits against inference cost, latency, and operational complexity, sometimes combining ensembles with selective routing or escalation to larger models.
- **Epochs**: The epoch count is a hyperparameter that determines how many times a model processes its training data while learning. Engineers adjust it alongside batch size, training steps, and learning rate to balance model quality, generalization, training time, and cloud compute cost.
- **Event Correlation**: Individual logs and alerts often describe only fragments of an incident or operational failure. Event correlation combines those fragments into a contextual sequence, helping engineers detect suspicious behavior, investigate causes, and reduce duplicate or low-value alerts.
- **Event Streaming**: Producers append events to a stream, while consumers read and process those events independently, often within seconds or less. This decouples event generation from downstream processing and supports incident detection, operational analytics, and automated responses without requiring producers to know every consumer.
- **Event-Driven Architecture**: An event records something that has happened, such as an order being placed, a file being uploaded, or a monitoring threshold being crossed. By separating event producers from consumers, this architecture lets cloud applications process work independently, absorb traffic spikes, and deliver notifications without requiring every component to respond at the same time.
- **Event-Time Processing**: Distributed streams often contain delayed, duplicated, or out-of-order records, so arrival order does not reliably represent the order of real-world activity. Event-time processing uses event timestamps, windows, and explicit lateness policies to produce meaningful time-based results, including streaming features for machine learning.
- **Experiment Tracking**: Experiment tracking connects each model result to the data, code, parameters, and execution environment that produced it. It supports repeatable development, informed model selection, and traceability as models move toward production and are later retrained.
- **Explicit Deny Precedence**: In a deny-overrides authorization model, a request fails whenever an applicable policy explicitly denies it, even if another policy allows it. This enables enforceable security guardrails, but troubleshooting requires identifying the denying statement and its evaluation context rather than simply adding permissions.
- **Failover**: Failover uses redundant resources, health detection, and a mechanism for transferring work to reduce interruptions when components fail. In cloud architectures, distributing those resources across multiple Availability Zones helps maintain availability when an instance or an entire zone becomes unavailable.
- **Feature Engineering**: Features are the measurable attributes a model uses to make predictions, such as transaction amount, account age, or recent purchase frequency. Feature engineering converts available data into suitable model inputs, improving predictive usefulness while controlling leakage, complexity, and production processing costs.
- **Fine-Tuning**: Fine-tuning reuses the capabilities of an existing model rather than learning everything from scratch. It can improve task accuracy, response style, and output consistency, but introduces training, evaluation, deployment, and maintenance costs that must be compared with prompting and retrieval-based approaches.
- **Foundation Models**: Foundation models provide reusable capabilities for working with language, images, audio, and other data through prompting, retrieval, or additional training. Choosing between a foundation model and traditional task-specific machine learning depends on the workload, available data, explainability requirements, regulatory obligations, and operational constraints.
- **Gradient Clipping**: Gradient clipping modifies gradients that exceed a chosen threshold before an optimizer uses them to update model parameters. It helps control exploding gradients and improve training stability, especially in recurrent networks, deep networks, and foundation model fine-tuning, but it does not resolve every cause of poor convergence.
- **Horizontal Scaling**: Instead of making one machine larger, horizontal scaling distributes work across multiple resources. It helps applications handle changing demand and can improve resilience, while requiring suitable workload distribution and state management. When automated to match demand, it provides elasticity.
- **Human-in-the-Loop**: Human-in-the-Loop combines AI’s ability to process information at scale with people’s ability to interpret context, resolve ambiguity, and exercise judgment. It supports assisted decision-making and responsible automation by giving people meaningful opportunities to correct outputs, challenge decisions, and improve system behavior.
- **Human-in-the-Loop Evaluation**: Human-in-the-loop evaluation combines structured human judgment with repeatable testing to measure how well foundation models meet application requirements. It complements automated metrics by assessing qualities such as usefulness, factual correctness, safety, and appropriateness that a single numerical benchmark may not adequately capture.
- **Hybrid Search**: Keyword search finds explicit terms, identifiers, and phrases, while vector search finds content with similar meaning even when wording differs. Combining these signals can improve retrieval for enterprise search and retrieval-augmented generation, especially when queries mix exact technical details with natural-language intent.
- **Hyperparameter Tuning**: Hyperparameters control how a machine learning model is structured or trained, unlike model parameters such as weights that are learned from data. Tuning compares training runs with different settings to find a suitable configuration while balancing predictive quality, training cost, and operational requirements.
- **Hypothesis Testing**: In production machine learning, hypothesis testing helps determine whether an observed difference between models reflects a real effect rather than sampling variation. Combined with randomized A/B testing, it supports evidence-based deployment decisions while accounting for uncertainty, business impact, and operational risk.
- **Idempotency**: Idempotency makes retries safe when requests time out, events arrive more than once, or automation restarts after a failure. In incident response, it prevents repeated remediation attempts from creating duplicate resources, reversing containment, or causing additional disruption.
- **Immutable Infrastructure**: Changes to operating systems, application dependencies, and security configuration are built into tested machine or container images and deployed as replacements. This reduces configuration drift and makes recovery more repeatable, provided that persistent data, secrets, and incident evidence are managed separately.
- **Incremental Processing**: Incremental processing preserves useful results from previous runs and applies subsequent changes using tracked processing state. It reduces repeated scanning, transformation, and embedding work, but requires reliable change detection, replay-safe writes, and explicit handling of updates and deletions.
- **Inference Latency**: Inference latency determines how quickly an AI-powered application responds and whether it meets user expectations or processing deadlines. For generative AI, input length, generated output length, model choice, and available serving capacity affect latency, while token-based pricing links much of that work to inference cost.
- **Infrastructure as code (IaC)**: IaC turns infrastructure definitions into repeatable deployment processes that can be reviewed, tested, and automated. It helps engineers create consistent environments, reduce manual errors, and apply security standards across accounts while maintaining a traceable history of changes.
- **Instruction Tuning**: Instruction tuning adapts a foundation model’s behavior using examples of tasks and acceptable answers, often including supporting context or conversation history. It helps engineers improve instruction following, response structure, and task consistency without training a model from scratch.
- **Inter-Rater Agreement**: Human evaluations are useful only when their interpretation is sufficiently consistent for the intended decision. Inter-rater agreement helps engineers assess the reliability of annotation and evaluation workflows, improve scoring rubrics, and identify uncertainty before using human judgments to train or evaluate ML models and foundation models.
- **Interpretability-Performance Tradeoff**: Models that are easy to understand may sacrifice predictive capability on some tasks, while more complex models can require additional methods to explain their behavior. This tradeoff is not inevitable: engineers must measure model quality, explanation usefulness, safety, latency, and cost rather than assume that complexity always improves results.
- **Iterative Prompt Refinement**: A prompt is treated as a testable application component rather than a one-time question. Engineers examine outputs, identify failure patterns, and make targeted revisions to improve accuracy, relevance, consistency, and safety without necessarily changing model weights.
- **Joins**: A join connects related data, such as orders and customer profiles, to produce a dataset suitable for analysis or further processing. Correct joins require compatible keys, appropriate matching rules, and an understanding of how unmatched records and duplicate keys affect the result.
- **JSON**: JSON, short for JavaScript Object Notation, is widely used to exchange application data and store semi-structured records such as events, logs, and API responses. In machine learning pipelines, it preserves nested information during ingestion, but its parsing overhead and lack of columnar storage affect whether it is suitable for repeated analytical reads.
- **Knowledge Distillation**: Knowledge distillation transfers learned behavior from a teacher model to a student through training signals such as generated answers or output probabilities. It can reduce inference latency, memory requirements, and serving costs, but the student must be evaluated because it may lose capabilities or inherit the teacher’s errors.
- **Label Quality**: Labels define expected outcomes for supervised learning, human-preference training, and many AI evaluations. Incorrect, ambiguous, outdated, or systematically biased labels can teach models the wrong behavior and make evaluation results misleading, even when the underlying data and training pipeline are technically sound.
- **Learning Rate Schedules**: A learning rate schedule changes the scale of model parameter updates according to training progress or a monitored metric. Choosing and implementing the schedule correctly can reduce unstable loss, avoid unnecessarily slow training, and improve final model quality, but it does not fix every convergence problem.
- **Least privilege**: Least privilege reduces the damage that compromised credentials, software defects, and operational mistakes can cause. In cloud environments, it applies to identity permissions, workload roles, administrative access, network connectivity, and organizational guardrails, and requires ongoing review as requirements change.
- **Lemmatization**: Lemmatization normalizes words such as “cars” to “car” and “running” to “run” when used as a verb, allowing related forms to share a feature. It can reduce vocabulary size and improve matching in text-processing pipelines, but its usefulness depends on the language, domain, and downstream model.
- **LIME**: Local Interpretable Model-Agnostic Explanations (LIME) helps engineers understand which input features influenced a particular model output. It works by perturbing an input, observing the original model’s responses, and fitting a locally weighted surrogate model, making it useful for debugging and reviewing predictions without requiring access to model internals.
- **LLM-as-a-Judge**: An evaluator LLM receives a task, a candidate response, and a scoring rubric, optionally with reference answers or supporting evidence, and returns a score, label, or preference. This approach helps engineers evaluate qualities such as relevance, groundedness, and instruction following at scale, but its judgments require calibration and human oversight.
- **Log Retention**: Log retention determines how long operational, security, and audit records remain available for monitoring, investigation, and compliance. An effective policy balances required history and retrieval speed against storage cost, privacy obligations, and protection from unauthorized alteration or deletion.
- **Metadata Extraction**: Metadata describes a document’s context, structure, provenance, and meaning, such as its title, publication date, section heading, or product identifier. In retrieval-augmented generation (RAG), extracting and preserving these attributes helps systems retrieve relevant chunks, apply trusted filters, and produce traceable citations.
- **Metadata Schemas**: A metadata schema turns descriptive attributes such as authorship, timestamps, domain, and access classification into a predictable contract for applications. In vector search and retrieval-augmented generation, this contract helps systems retrieve relevant, authorized, and contextually appropriate information rather than relying on embedding similarity alone.
- **Min-Max Scaling**: Min-max scaling makes numeric features with different units or magnitudes comparable without changing their ordering or relative spacing within each feature. It can improve distance-based learning and optimization, but it is sensitive to outliers and requires consistent preprocessing between training and inference.
- **Missing Value Imputation**: Imputation addresses incomplete records without necessarily discarding them, using methods such as statistical estimates, domain rules, or predictive models. The chosen method affects distributions, analytical results, and model fairness, so engineers must validate both the replacements and the assumptions behind them.
- **Mixed Precision Training**: Compute-intensive operations use formats such as FP16 or BF16, while operations and state that require greater numerical stability often remain in FP32. On compatible accelerators, this can reduce training time and memory consumption, but the benefits depend on hardware support, workload characteristics, and careful validation.
- **Model Cascading**: A model cascade combines models so that each stage either completes a task, filters candidates, or passes work to another stage. It can reduce inference cost and resource consumption while preserving required quality, but its benefits depend on reliable escalation rules and the proportion of requests that need additional processing.
- **Model Compression**: Model compression makes trained models more practical to deploy by reducing their resource requirements through techniques such as quantization, pruning, and knowledge distillation. It supports responsible model selection by helping engineers balance accuracy, safety, latency, cost, and environmental impact rather than choosing the largest available model by default.
- **Model Context Protocol**: MCP provides a common interface between an AI application's integration layer and external systems, reducing the need for custom connectors for every application–tool combination. In agentic applications, it helps agents discover available capabilities and access relevant information or request actions, while leaving reasoning, orchestration, and authorization enforcement to the surrounding system.
- **Model Distillation**: A student model learns to reproduce a teacher model’s behavior using generated examples, output probabilities, or other training signals. For foundation model applications, distillation can exchange upfront data-generation and training costs for lower ongoing serving costs, provided the student meets the application’s quality requirements.
- **Model Drift**: A model learns patterns from historical data, but those patterns may no longer represent the environment in which it operates. Monitoring for drift helps teams identify changing conditions, investigate performance problems, and decide whether to fix data pipelines, adjust the model, or retrain it.
- **Model Evaluation**: Model evaluation uses representative data, defined metrics, and human judgment to determine whether a model meets technical and business requirements. It supports model selection and release decisions throughout the foundation model lifecycle, helping engineers balance output quality, safety, latency, cost, and environmental impact.
- **Model Explainability**: Explainability helps engineers, reviewers, and affected users understand which inputs and model behaviors contributed to an outcome. It matters when choosing between traditional machine learning and foundation models because regulatory obligations, decision risk, and operational constraints can require explanations that a highly complex model cannot reliably provide.
- **Model Parallelism**: Instead of placing a complete model on every accelerator, model parallelism distributes its layers, tensors, or other components across devices. It enables large foundation models to run when one device lacks sufficient memory, but introduces communication overhead and requires coordinated resource allocation.
- **Multi-Agent Orchestration**: Multiple specialized agents can collaborate on work that requires different responsibilities, data sources, or decision steps. Orchestration defines how tasks are assigned, how agents communicate, and how the application controls state, failures, permissions, and completion.
- **N-Gram Overlap**: N-gram overlap is a lexical comparison technique used to evaluate generated text against expected outputs. It underpins metrics such as BLEU and ROUGE-N, providing inexpensive, repeatable signals for translation and summarization while requiring complementary checks for meaning, factual accuracy, and usefulness.
- **Network Isolation**: Network isolation creates controlled communication boundaries between workloads, environments, and external networks. During incident response, it helps contain compromised resources, interrupt attacker communications, and protect unaffected systems while engineers investigate, eradicate threats, and restore trusted workloads.
- **Network Segmentation**: Network segmentation separates workloads by trust level, function, environment, or data sensitivity, then permits only the traffic required between them. It reduces exposure and limits lateral movement after a compromise, but effective segmentation requires enforced traffic controls rather than merely separate address ranges.
- **Open-Source Models**: Open-source models let engineers build on existing model implementations and pretrained capabilities instead of developing every component from scratch. They can improve inspectability, customization, and deployment control, but teams must verify which artifacts are available, what the licenses permit, and whether the model meets their quality and responsible AI requirements.
- **ORC File Format**: ORC, short for Optimized Row Columnar, organizes data so analytical engines can read selected columns and skip irrelevant portions of a file. It is useful for cloud data lakes and machine learning preparation pipelines that repeatedly filter, aggregate, and transform large datasets.
- **Output Validation**: Generative AI responses must be treated as untrusted data, even when they come from a trusted model endpoint. Output validation helps prevent unsafe content, sensitive-data disclosure, injection attacks, and unauthorized actions by checking responses at the boundaries where applications consume them.
- **Overfitting**: An overfit model can achieve excellent training results without learning relationships that generalize reliably. Preventing overfitting improves prediction accuracy and supports responsible AI, especially when overall performance hides unreliable predictions for particular demographic groups.
- **Parameter-Efficient Fine-Tuning**: Parameter-efficient fine-tuning (PEFT) reuses a pretrained model's capabilities while limiting how many parameters must be optimized and stored for each customization. It can reduce training memory requirements and task-specific artifact sizes, making foundation model customization more practical when accelerator capacity, budgets, or deployment flexibility are constrained.
- **Pay-as-You-Go Pricing**: Cloud providers meter resources such as compute runtime, stored data, and requests, then charge according to the applicable rates. This helps organizations replace large upfront infrastructure investments with variable operating expenses, while making resource management and cost monitoring essential.
- **Point-in-Time Joins**: A point-in-time join reconstructs the information a model could have used when a prediction was made, rather than attaching today’s latest feature values. This prevents future information from leaking into training and evaluation data and helps make offline results representative of production behavior.
- **Population Stability Index**: Population Stability Index (PSI) compares the proportions of observations in matching bins across a baseline dataset and a current dataset. It supports label-free drift monitoring, helping engineers identify changes that warrant investigation before model performance measurements become available.
- **Precision@k**: Precision@k evaluates how much useful information appears within a retrieval system's highest-ranked results. In retrieval-augmented generation (RAG), it helps engineers assess whether the context supplied to a foundation model contains relevant evidence rather than distracting material.
- **Price-Performance Ratio**: In cloud systems, price-performance comparisons relate spending to outcomes such as successful requests, processing throughput, or model responses that meet quality and latency requirements. For generative AI applications, this means selecting models and inference patterns by their cost per acceptable result rather than by token price or model capability alone.
- **Prompt Templates**: A prompt template defines the repeatable parts of a model request, such as the task, context boundaries, examples, and expected response format, while leaving placeholders for request-specific data. Templates help engineers standardize application behavior, evaluate changes systematically, and reduce duplicated prompt-building logic without retraining the model.
- **Pseudonymization**: Pseudonymization reduces exposure of personal identifiers while preserving useful relationships between records for analytics, testing, and machine learning. Unlike anonymization, it retains a potential path to identification, so pseudonymized data still requires appropriate security controls and generally remains personal data under laws such as the GDPR.
- **Quantization**: Quantization maps higher-precision numerical values to a smaller set of representable values, such as converting floating-point model weights to 8-bit or 4-bit representations. For cloud-hosted foundation models, it can reduce accelerator memory requirements and deployment costs, but its benefits depend on model quality, hardware capabilities, and inference runtime support.
- **Random Search**: Random Search selects combinations of hyperparameter values, trains a model for each combination, and compares the resulting objective metrics. It provides a practical baseline for tuning because trials can run independently, although its effectiveness depends on sensible parameter ranges, sampling distributions, and evaluation budgets.
- **Real-Time Inference**: Real-time inference turns a trained model into a prediction capability available during an application workflow, such as evaluating a payment or generating a chat response. Engineers typically expose it through a managed model API or a self-hosted API, balancing response time, availability, cost, and operational control.
- **Recall@k**: Recall@k evaluates whether a search or retrieval pipeline finds the evidence needed for a query within a limited result budget. In retrieval-augmented generation (RAG), it helps engineers detect missing context, compare retrieval configurations, and balance evidence coverage against latency and context-window cost.
- **Reranking**: An initial retriever efficiently finds potentially relevant documents, and a reranker evaluates that smaller candidate set more closely against the query. In retrieval-augmented generation, this helps place stronger evidence into a limited context window, but it adds processing cost and cannot recover documents that retrieval missed.
- **Resource Efficiency**: Resource efficiency means matching cloud capacity and architecture to useful work rather than provisioning for assumptions or leaving resources idle. It helps engineers improve performance per resource, control costs, and reduce environmental impact while preserving security and reliability requirements.
- **Resource Tagging**: Tags describe business and operational attributes such as ownership, department, cost center, application, and environment without changing a resource’s function. A consistent tagging strategy supports cost allocation and resource management, while policy controls help prevent missing, misleading, or unauthorized tags.
- **Resource Utilization**: Resource utilization shows how workloads consume CPU, memory, storage, network bandwidth, and other capacity. It informs rightsizing: selecting resource types, sizes, and quantities that meet performance and availability requirements without paying for unnecessary capacity.
- **Retrieval-Augmented Generation**: RAG connects a foundation model to information outside its learned parameters, such as enterprise documents, product catalogs, or operational records. It helps applications answer questions using organization-specific or recently updated information without retraining the model, although accuracy still depends on retrieval quality and how the model uses the evidence.
- **Right-Sizing**: Right-sizing uses observed demand and application requirements to choose appropriate compute, memory, storage, and throughput capacity. It reduces waste while preserving performance and reliability, and it requires regular review as workloads change.
- **Role-Based Access Control**: Role-Based Access Control (RBAC) separates permission definitions from individual users or workloads, making access easier to administer and review. In cloud environments, it supports consistent authorization across teams and accounts, but requires carefully scoped roles and controlled assignments to prevent excessive privileges.
- **ROUGE**: ROUGE stands for Recall-Oriented Understudy for Gisting Evaluation and is commonly used to evaluate summaries and other generated text against reference answers. It provides inexpensive, repeatable measurements for comparing foundation models, prompts, or fine-tuned versions, but does not independently establish factual correctness or semantic equivalence.
- **Schema Validation**: A schema acts as a contract between data producers and consumers, making format expectations testable rather than implicit. Validating that contract at ingestion, transformation, and API boundaries catches incompatible data before it disrupts analytics, machine learning, or foundation model applications, but it does not establish factual accuracy or safety.
- **Security Quality Gates**: A security quality gate turns vulnerability findings and security policy checks into an explicit decision to permit, block, or require approval for a change. In cloud delivery pipelines, it helps prevent vulnerable code, dependencies, container images, and infrastructure configurations from reaching production while preserving an auditable exception process.
- **Semantic Search**: Semantic search helps users find relevant information even when their queries use different wording from the source material. It commonly uses machine-learning embeddings and relevance models, making it useful for enterprise search, customer support, and retrieving evidence for generative AI applications.
- **Semantic Similarity**: Semantic similarity evaluates meaning rather than relying only on exact word overlap. Engineers use it to assess generated answers, compare documents, and retrieve relevant information, but a high similarity score does not by itself establish factual correctness or completeness.
- **Semi-Structured Data**: Semi-structured data combines identifiable organization with flexible fields, nesting, and optional attributes, as commonly seen in JSON events and XML documents. It matters because cloud ingestion, analytics, and AI pipelines must preserve that flexibility while validating and transforming records into forms that downstream consumers can use reliably.
- **Shadow Testing**: A shadow deployment runs a candidate model or application alongside the production version, allowing engineers to compare behavior under real workloads without exposing users to candidate responses. It supports safer release decisions by revealing quality regressions, latency problems, errors, and resource requirements before a production traffic shift.
- **SHAP**: SHAP applies Shapley values from cooperative game theory to distribute the difference between a model output and a baseline among input features. Engineers use these attributions to investigate predictions, identify unexpected model behavior, and summarize feature influence across a dataset without confusing explanations with accuracy or causality.
- **SMOTE**: The Synthetic Minority Over-sampling Technique increases the representation of underrepresented classes without simply duplicating existing records. It can help a classifier learn minority-class patterns, but its effectiveness depends on meaningful feature distances, clean labels, and evaluation that prevents data leakage.
- **Stateful and Stateless Filtering**: Stateful filters remember permitted traffic flows and use that context to recognize return traffic, while stateless filters evaluate each packet without remembering earlier exchanges. This distinction determines how engineers configure bidirectional access, troubleshoot blocked responses, and combine workload-level controls with subnet boundaries and inspection firewalls.
- **Static Application Security Testing**: Static Application Security Testing (SAST) identifies potentially vulnerable code paths, insecure programming patterns, and other implementation weaknesses before deployment. Integrating it into development environments and delivery pipelines helps engineers remediate problems early and prevent changes that violate security policy from reaching production.
- **Storage Tiering**: Storage tiering balances storage cost against access latency, retrieval charges, and retention requirements. Cloud platforms implement it through explicit storage-class selection, lifecycle policies, or automatic movement based on access patterns, helping engineers avoid paying premium storage rates for rarely used data.
- **Structured Data**: Structured data commonly appears as records and tables containing values such as customer identifiers, transaction amounts, and timestamps. Its predictable organization makes it useful for querying, validation, analytics, and machine learning, but it does not automatically make the data accurate, labeled, or ready for model training.
- **Subgroup Analysis**: An AI system can perform well on average while producing less accurate, less reliable, or more harmful results for particular populations or operating conditions. Subgroup analysis compares relevant groups using appropriate quality and fairness metrics, helping engineers detect potential bias, investigate label quality, and monitor whether improvements benefit all affected users.
- **Supervised Learning**: A supervised model learns the relationship between input features and known target values, such as transaction details paired with fraud labels or property attributes paired with sale prices. It supports classification and regression, making it useful when historical outcomes are available and engineers need predictions for new cases.
- **Temporary Credentials**: Temporary credentials let people and workloads access cloud resources without distributing permanent access keys. They reduce the lifetime of exposed credentials, support federation and role-based access, and shift credential renewal to identity services and supported client libraries.
- **Threat Modeling**: Threat modeling connects a workload’s architecture, valuable assets, trust boundaries, and likely attackers to concrete security requirements. It helps engineers prioritize preventive controls, collect useful telemetry, and design alerts around plausible attack scenarios rather than enabling security features indiscriminately.
- **Throughput**: Throughput measures the rate at which storage, networks, applications, and data pipelines deliver results, commonly expressed as bytes, operations, or records per second. It matters when selecting storage configurations, sizing ingestion and transformation workloads, and determining whether a system can meet processing deadlines without accumulating a backlog.
- **Tokenization**: Tokens can represent whole words, word fragments, punctuation, whitespace, or other character sequences, depending on the model’s tokenizer. Tokenization determines how much content fits into a model request and directly affects token-metered inference costs, processing requirements, and response latency.
- **Tool Calling**: Tool calling connects a generative AI model to capabilities such as database queries, calculations, business APIs, and infrastructure operations. It enables agents to use current information and perform actions, while application code remains responsible for execution, authorization, validation, and error handling.
- **Total Cost of Ownership**: Total Cost of Ownership (TCO) includes direct expenses, such as hardware or cloud usage, and indirect expenses, such as administration, facilities, and migration effort. It helps engineers compare deployment options fairly and determine whether moving a workload to the cloud will reduce overall costs rather than simply change how those costs are billed.
- **Train-Validation-Test Split**: Training data teaches a model, validation data guides development decisions, and test data provides an independent final evaluation. Keeping these roles separate helps engineers detect overfitting, prevent data leakage, and estimate how well a model will generalize to production inputs.
- **Training-Serving Skew**: A model can perform well in offline evaluation but poorly in production when feature definitions, preprocessing, data availability, or input distributions differ between training and serving. Preventing this mismatch requires consistent feature pipelines, historically correct training data, and validation of the actual inputs supplied to deployed models.
- **Trajectory Evaluation**: A trajectory includes actions such as retrieving documents, selecting tools, supplying arguments, handling results, and deciding when to stop. Evaluating this sequence helps engineers detect unsafe actions, incorrect dependencies, unnecessary work, and intermediate failures that a plausible final response can conceal.
- **Transfer Learning**: Instead of training a model from scratch, engineers start with a pretrained model and reuse its learned representations, adapt its parameters, or both. This can reduce training time and data requirements, making it practical to specialize foundation models for business tasks, although success depends on model suitability and training-data quality.
- **Underfitting**: An underfit model typically performs poorly on both training data and unseen data because its assumptions, features, capacity, or training process are inadequate for the task. Recognizing underfitting helps engineers improve predictive accuracy while checking whether errors disproportionately affect particular demographic groups.
- **Unit Testing**: Unit tests check functions, methods, or small modules against explicit expectations using controlled inputs and dependencies. They provide fast feedback during development and help CI/CD pipelines reject regressions before code reaches deployed data, application, or machine learning workflows.
- **Unstructured Data**: Unstructured data contains information that typically requires interpretation or transformation before conventional analytics or machine learning can use it effectively. It matters because documents, conversations, photographs, and recordings provide signals that fixed database fields often do not capture.
- **Unsupervised Learning**: Unsupervised learning uses similarities, differences, and statistical relationships within data to identify useful structure rather than learn from labeled examples. It supports tasks such as customer segmentation, exploratory analysis, and anomaly detection when engineers do not have known outcomes for training.
- **Usage-Based Pricing**: Cloud costs are calculated from billable quantities such as instance runtime, stored data, requests, and data transfer rather than solely from an upfront infrastructure purchase. Understanding these meters helps engineers compare purchasing options, estimate total workload costs, and avoid paying for idle resources or unsuitable commitments.
- **Vector Quantization**: Vector quantization reduces the storage and memory required for embeddings by replacing full-precision vectors, or parts of them, with references to learned representative values. In cloud vector search, it can lower infrastructure costs and improve search efficiency, but engineers must measure the resulting loss in retrieval accuracy and account for indexing and rescoring overhead.
- **Vector Search**: Embedding models represent text, images, audio, or other data as vectors whose relative positions can reflect meaningful relationships. Vector search uses these representations to find related content even when exact words differ, supporting semantic retrieval, recommendations, and retrieval-augmented generation.
- **Version Control**: Version control creates a traceable history for artifacts such as source code, infrastructure definitions, configuration, and AI prompts. It helps engineers collaborate safely, connect deployed behavior to specific revisions, and recover from changes that introduce errors or regressions.
- **Vulnerability Assessment**: A vulnerability assessment determines which weaknesses exist, which resources they affect, and how urgently they need attention. In cloud environments, recurring assessments help engineers address vulnerable dependencies, exposed workloads, and insecure configurations as deployments and threat information change.
- **Windowed Aggregation**: An unbounded stream cannot be summarized as a single final result because new events keep arriving. Windowed aggregation divides that stream into meaningful groups and calculates values such as counts, averages, and maximums, making recent behavior available for monitoring, feature engineering, and inference.
- **Workload Identity**: Workload identity lets software prove who it is and receive permissions appropriate to its function and execution environment. Cloud implementations commonly combine runtime identity, federation, and short-lived credentials to reduce reliance on stored secrets while supporting least privilege and auditable access.
- **Workload Predictability**: Predictability helps engineers decide how much compute usage they can safely commit to and how much should remain flexible. Matching purchasing options to measured demand reduces costs without confusing predictable usage with interruption tolerance or guaranteed capacity.

## Services on the exam

The 72 AWS services the MLA-C02 (beta) exam covers.

[Amazon Athena](https://blowstack.com/tools/cloud-services-hub/amazon-athena), [Amazon Augmented AI (Amazon A2I)](https://blowstack.com/tools/cloud-services-hub/amazon-augmented-ai-(amazon-a2i)), [Amazon Aurora](https://blowstack.com/tools/cloud-services-hub/amazon-aurora), [Amazon Bedrock](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock), [Amazon Bedrock AgentCore](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock-agentcore), [Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch), [Amazon CodeGuru](https://blowstack.com/tools/cloud-services-hub/amazon-codeguru), [Amazon Comprehend](https://blowstack.com/tools/cloud-services-hub/amazon-comprehend), [Amazon Data Firehose](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-firehose), [Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb), [Amazon EC2](https://blowstack.com/tools/cloud-services-hub/amazon-ec2), [Amazon EC2 Auto Scaling](https://blowstack.com/tools/cloud-services-hub/amazon-ec2-auto-scaling), [Amazon Elastic Block Store (Amazon EBS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-block-store-(amazon-ebs)), [Amazon Elastic Container Registry (Amazon ECR)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-registry-(amazon-ecr)), [Amazon Elastic Container Service (Amazon ECS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-service-(amazon-ecs)), [Amazon Elastic File System (Amazon EFS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-file-system-(amazon-efs)), [Amazon Elastic Kubernetes Service (Amazon EKS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-kubernetes-service-(amazon-eks)), [Amazon ElastiCache](https://blowstack.com/tools/cloud-services-hub/amazon-elasticache), [Amazon EMR](https://blowstack.com/tools/cloud-services-hub/amazon-emr), [Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge), [Amazon FSx](https://blowstack.com/tools/cloud-services-hub/amazon-fsx-(for-all-types)), [Amazon GuardDuty](https://blowstack.com/tools/cloud-services-hub/amazon-guardduty), [Amazon Inspector](https://blowstack.com/tools/cloud-services-hub/amazon-inspector), [Amazon Kinesis Data Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-streams), [Amazon Kinesis Video Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-video-streams), [Amazon Macie](https://blowstack.com/tools/cloud-services-hub/amazon-macie), [Amazon Managed Grafana](https://blowstack.com/tools/cloud-services-hub/amazon-managed-grafana), [Amazon Managed Service for Apache Flink](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-apache-flink), [Amazon Managed Service for Prometheus](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-prometheus), [Amazon Managed Streaming for Apache Kafka](https://blowstack.com/tools/cloud-services-hub/amazon-managed-streaming-for-apache-kafka), [Amazon OpenSearch Service](https://blowstack.com/tools/cloud-services-hub/amazon-opensearch-service), [Amazon RDS](https://blowstack.com/tools/cloud-services-hub/amazon-rds), [Amazon Rekognition](https://blowstack.com/tools/cloud-services-hub/amazon-rekognition), [Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3), [Amazon SageMaker](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker), [Amazon SageMaker Data Wrangler](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker-data-wrangler), [Amazon SageMaker Ground Truth](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker-ground-truth), [Amazon Textract](https://blowstack.com/tools/cloud-services-hub/amazon-textract), [Amazon Transcribe](https://blowstack.com/tools/cloud-services-hub/amazon-transcribe), [Amazon Translate](https://blowstack.com/tools/cloud-services-hub/amazon-translate), [Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc), [AWS Auto Scaling](https://blowstack.com/tools/cloud-services-hub/aws-auto-scaling), [AWS Batch](https://blowstack.com/tools/cloud-services-hub/aws-batch), [AWS Billing and Cost Management](https://blowstack.com/tools/cloud-services-hub/aws-billing-and-cost-management), [AWS Budgets](https://blowstack.com/tools/cloud-services-hub/aws-budgets), [AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation), [AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail), [AWS CodeBuild](https://blowstack.com/tools/cloud-services-hub/aws-codebuild), [AWS CodeCommit](https://blowstack.com/tools/cloud-services-hub/aws-codecommit), [AWS CodeConnections](https://blowstack.com/tools/cloud-services-hub/aws-codeconnections), [AWS CodeDeploy](https://blowstack.com/tools/cloud-services-hub/aws-codedeploy), [AWS CodePipeline](https://blowstack.com/tools/cloud-services-hub/aws-codepipeline), [AWS Command Line Interface (AWS CLI)](https://blowstack.com/tools/cloud-services-hub/aws-command-line-interface-(aws-cli)), [AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config), [AWS Cost and Usage Report](https://blowstack.com/tools/cloud-services-hub/aws-cost-and-usage-report), [AWS Cost Explorer](https://blowstack.com/tools/cloud-services-hub/aws-cost-explorer), [AWS DataSync](https://blowstack.com/tools/cloud-services-hub/aws-datasync), [AWS Deep Learning Containers](https://blowstack.com/tools/cloud-services-hub/aws-deep-learning-containers), [AWS Glue](https://blowstack.com/tools/cloud-services-hub/aws-glue), [AWS Glue DataBrew](https://blowstack.com/tools/cloud-services-hub/aws-glue-databrew), [AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam)), [AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms)), [AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda), [AWS Marketplace](https://blowstack.com/tools/cloud-services-hub/aws-marketplace), [AWS Pricing Calculator](https://blowstack.com/tools/cloud-services-hub/aws-pricing-calculator), [AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink), [AWS Security Hub](https://blowstack.com/tools/cloud-services-hub/aws-security-hub), [AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts)), [AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions), [AWS Tools and SDKs](https://blowstack.com/tools/cloud-services-hub/aws-tools-and-sdks), [AWS X-Ray](https://blowstack.com/tools/cloud-services-hub/aws-x-ray), [TensorFlow on AWS](https://blowstack.com/tools/cloud-services-hub/tensorflow-on-aws)

## Concepts on the exam

The 187 cloud concepts the MLA-C02 (beta) exam covers, each explained with the AWS services for it: https://blowstack.com/tools/cloud-concepts-hub?certification=aws-certified-machine-learning-engineer-associate

## Other practice exams

- [SAP-C03 AWS Certified Solutions Architect - Professional](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional)
- [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional)
- [DEA-C01 AWS Certified Data Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate)
- [AIF-C01 AWS Certified AI Practitioner](https://blowstack.com/practice-exams/aws-certified-ai-practitioner)
- [SAA-C03 AWS Certified Solutions Architect - Associate](https://blowstack.com/practice-exams/aws-certified-solutions-architect-associate)
- [CLF-C02 AWS Certified Cloud Practitioner](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner)
- [SCS-C03 AWS Certified Security - Specialty](https://blowstack.com/practice-exams/aws-certified-security-specialty)
- [AIB-C01 (beta) AWS Certified AI Business Strategist](https://blowstack.com/practice-exams/aws-certified-ai-business-strategist)
- [AIP-C01 AWS Certified Generative AI Developer - Professional](https://blowstack.com/practice-exams/aws-certified-generative-ai-developer-professional)
- [SOA-C03 AWS Certified CloudOps Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-cloudops-engineer-associate)
- [ANS-C01 AWS Certified Advanced Networking - Specialty](https://blowstack.com/practice-exams/aws-certified-advanced-networking-specialty)
- [DVA-C02 AWS Certified Developer - Associate](https://blowstack.com/practice-exams/aws-certified-developer-associate)
