MLA-C01 — AWS Certified Machine Learning Engineer – Associate Cheat Sheet

    flowchart LR
	    A[Data sources] --> B[Ingest and store]
	    B --> C[Clean, label, transform]
	    C --> D[Feature engineering]
	    D --> E[Train or tune model]
	    E --> F[Evaluate]
	    F --> G{Meets criteria?}
	    G -- No --> C
	    G -- Yes --> H[Register and approve]
	    H --> I[Deploy: real-time, async, batch, serverless]
	    I --> J[Monitor: data, quality, bias, latency, errors]
	    J --> K{Drift or degradation?}
	    K -- Yes --> L[Retrain pipeline]
	    L --> E
	    K -- No --> I

This page supports IT Mastery practice with original practice questions. It is not affiliated with AWS.

1. Do topic drills for data preparation, model development, deployment, monitoring, and security.
2. Review every detailed explanation, including questions you answered correctly.
3. Tag missed questions by decision error, not just by service name.
4. Re-drill weak areas until you can explain why the wrong options are wrong.
5. Use mock exams only after you can consistently handle scenario tradeoffs.

Good review notes after a missed question should look like:

• “I chose real-time endpoint, but payload was large and processing was long; async inference was better.”
• “I optimized accuracy, but class imbalance made recall/F1 more appropriate.”
• “I selected IAM permissions, but the real issue was KMS key access.”
• “I chose retraining, but the immediate issue was training-serving skew.”

Data split and leakage traps

Data quality checklist

Feature Store concepts

Data storage and formats

Common trap: choosing a training algorithm or deployment service before fixing the data issue. If the scenario says the model performs well in validation but poorly in production, suspect leakage, skew, drift, nonrepresentative validation data, or feature mismatch.

Data splitting and leakage

Know the difference between random splitting and time-aware splitting.

Data leakage examples:

• Using a feature that is only known after the prediction time.
• Fitting scalers, imputers, encoders, or feature selectors on the full dataset before the split.
• Including target-derived columns.
• Using test data during hyperparameter tuning.
• Training on records that overlap with the evaluation set.

Feature engineering decision rules

Data preparation services: quick choices

Training job anatomy

Recognize these knobs in scenario and configuration questions:

TrainingJob:
  AlgorithmSpecification:
    TrainingImage: <ECR image or built-in algorithm>
    TrainingInputMode: File | FastFile | Pipe
  RoleArn: <SageMaker execution role>
  InputDataConfig:
    - ChannelName: train
      DataSource: s3://bucket/prefix/train/
    - ChannelName: validation
      DataSource: s3://bucket/prefix/validation/
  OutputDataConfig:
    S3OutputPath: s3://bucket/prefix/model-artifacts/
    KmsKeyId: <optional KMS key>
  ResourceConfig:
    InstanceType: <training instance type>
    InstanceCount: <count>
    VolumeKmsKeyId: <optional KMS key>
  HyperParameters:
    objective: binary:logistic
  VpcConfig:
    Subnets: [private-subnet]
    SecurityGroupIds: [sg-id]
  StoppingCondition:
    MaxRuntimeInSeconds: <limit>

Training input modes and data access

Container and algorithm choices

Built-in algorithm selection cues

Hyperparameter tuning

Training job anatomy

A SageMaker training job usually needs:

• Training container image, either built-in or custom.
• Input data location, often S3.
• Output model artifact location, often S3.
• IAM execution role.
• Instance type and count.
• Hyperparameters.
• Optional VPC configuration.
• Optional checkpointing.
• Optional debugger/profiler/metrics.

Built-in algorithms vs custom containers

Custom container traps:

• Image must be in Amazon ECR or otherwise accessible as required.
• SageMaker role needs permission to pull the image and read/write S3.
• Training code must read from expected input channels and write model artifacts correctly.
• Private VPC training needs network access to S3/ECR/CloudWatch, often through VPC endpoints or controlled egress.

Distributed training and acceleration

Do not assume “bigger instance” is always the best answer. The exam may prefer the option that addresses the actual bottleneck: data loading, algorithm configuration, storage format, networking, or metric choice.

Metric selection table

Evaluation traps

Deployment controls

SageMaker inference container contract

Common container issues: wrong content type, missing dependencies, slow model load, model artifact path mismatch, container not listening correctly, memory exhaustion, or IAM denial when pulling ECR image or reading S3 artifact.

Pick the right inference pattern

Deployment traps

Real-time endpoint concepts

For SageMaker real-time inference, know:

• Model: points to model artifacts and inference image.
• Endpoint configuration: defines production variants and instance choices.
• Endpoint: live HTTPS inference target.
• Production variant: model/instance group with traffic weight.
• Auto scaling: adjusts capacity based on metrics such as invocation load.
• Data capture: stores requests and responses for monitoring.

Prompt, RAG, fine-tuning, or training?

SageMaker Pipelines pattern

Process raw data
  -> Train model
  -> Evaluate metrics
  -> If metric passes threshold:
         Register model package
         Optionally deploy to staging
     Else:
         Stop and record failure

CI/CD and governance distinctions

Network and encryption controls

Security traps

IAM fundamentals for MLA-C01

Common trap: giving an IAM role S3 permission but forgetting the KMS key policy or KMS permissions for encrypted data.

Encryption and private networking

Private VPC trap: putting SageMaker training in a private subnet can break access to S3, ECR, and CloudWatch unless network paths are configured. The secure answer must still allow required service access.

Data protection and responsible ML

Expect scenarios involving:

• Sensitive data in training datasets.
• Encryption requirements.
• Access control for notebooks, S3, model artifacts, and endpoints.
• Audit trails for model deployment.
• Bias or explainability checks with SageMaker Clarify.
• Minimizing exposure of secrets and credentials.

Do not choose an option that solves model accuracy while ignoring stated security constraints.

Troubleshooting decision table

Final quick checklist before practice

Before starting a mock exam for AWS Certified Machine Learning Engineer – Associate (MLA-C01), confirm you can quickly answer:

• Which AWS service prepares, trains, deploys, monitors, and orchestrates each ML step?
• Which inference option matches each latency and traffic pattern?
• Which metric matches each business risk?
• How do you detect data drift, model quality degradation, bias, and infrastructure issues?
• How do IAM, KMS, VPC endpoints, CloudWatch, and CloudTrail fit into ML workloads?
• How do SageMaker Pipelines, Model Registry, and CI/CD support repeatable MLOps?
• What are the common causes of production model failure beyond endpoint availability?

Next step: start with MLA-C01 topic drills in the question bank, then use the detailed explanations to turn each missed scenario into a clear AWS service-selection rule.

Metric traps:

• Accuracy can be misleading with imbalanced data.
• Precision matters when false positives are expensive.
• Recall matters when false negatives are expensive.
• F1 balances precision and recall.
• ROC-AUC may look strong even when rare-positive performance is weak; PR-AUC may be more informative for severe imbalance.
• RMSE penalizes large errors more than MAE.

Classification metrics refresher

Bias, variance, and overfitting

Hyperparameter tuning

SageMaker automatic model tuning is high-yield for scenarios where the model type is chosen but performance needs improvement.

Remember:

• Define an objective metric that matches business and exam constraints.
• Set realistic hyperparameter ranges.
• Use validation data, not test data, for tuning.
• Use early stopping when supported to reduce cost.
• Keep a final untouched test set for unbiased evaluation.

Common trap: optimizing the wrong metric. If the scenario emphasizes missed fraud, missed disease, or missed safety issues, recall-oriented metrics often matter more than accuracy.

MLOps review checklist

A production-ready ML workflow should answer:

1. Where did the training data come from?
2. Which code version created the model?
3. Which hyperparameters were used?
4. Which metrics approved the model?
5. Who or what approved deployment?
6. How is the model deployed and rolled back?
7. What monitoring detects drift or degradation?
8. What triggers retraining?
9. How are secrets, keys, and network paths secured?
10. How are logs and audit events retained?

Model Registry decision points

Use SageMaker Model Registry when the scenario requires:

• Tracking model versions.
• Model package approval before deployment.
• Promotion from development to staging to production.
• Lineage and governance around model artifacts.
• CI/CD integration for model deployment.

Common trap: storing a model artifact in S3 is not the same as managing the model lifecycle. S3 can store artifacts, but Model Registry provides versioning, approval, and lifecycle metadata.

Drift concepts

High-yield rule: if a question mentions production performance decline but infrastructure is healthy, look for drift, skew, missing monitoring baseline, or retraining workflow.

Retraining triggers

Retraining may be triggered by:

• Scheduled interval.
• Data drift threshold.
• Model quality threshold.
• New labeled data availability.
• Business event or seasonal change.
• Manual approval after monitoring alert.

Do not retrain blindly if the problem is bad input data, broken preprocessing, missing features, or a deployment bug. Fix the cause first.

Training

• If performance is poor on both train and validation, address underfitting.
• If training is strong and validation is weak, address overfitting.
• If validation is strong and production is weak, investigate drift, skew, leakage, or bad split.
• If training may be interrupted for cost savings, use Managed Spot Training with checkpoints.
• If custom dependencies are required, consider custom containers, but check ECR/IAM/networking.

Deployment

• Need real-time synchronous predictions: SageMaker real-time endpoint.
• Need intermittent traffic without managing instances: serverless inference.
• Need large payload or long-running inference: asynchronous inference.
• Need offline scoring: batch transform.
• Need gradual rollout: production variants, canary, blue/green.
• Need compare new model without affecting responses: shadow testing.

Monitoring and operations

• Need input distribution checks: data quality monitoring.
• Need prediction performance checks: model quality monitoring with ground truth.
• Need bias/explainability: SageMaker Clarify.
• Need API/infrastructure metrics: CloudWatch.
• Need audit of AWS API activity: CloudTrail.
• Need automatic retraining: monitoring trigger plus pipeline orchestration.

Monitoring selection table

Security selection table