Skip to content

Microsoft Azure Data Scientist Associate (DP-100) - Fact Sheet

Quick Reference

Exam Code: DP-100 Duration: 180 minutes (3 hours) Questions: 40-60 questions Passing Score: 700/1000 Cost: $165 USD Validity: 1 year (annual renewal required) Delivery: Pearson VUE Difficulty: ⭐⭐⭐⭐⭐ (Advanced ML and MLOps focus with hands-on labs)

Exam Domain Breakdown

Domain Weight Key Focus
Design and prepare a machine learning solution 20-25% Workspace setup, compute, datastores, security
Explore data and train models 35-40% Data prep, feature engineering, training, AutoML
Prepare models for deployment 20-25% Model evaluation, interpretation, responsible AI, registration
Deploy and retrain models 20-25% Deployment targets, monitoring, MLOps pipelines

Key Services by Domain

Design and Prepare a Machine Learning Solution (20-25%)

Azure Machine Learning Workspace - Central hub for ML development and deployment - Resource management: Compute, datastores, datasets, models - Collaborative environment with RBAC integration - Managed identity support for secure access - Integration with Azure DevOps and GitHub - 📖 Azure ML Workspace Overview - Workspace fundamentals - 📖 Create Workspace - Workspace creation and management - 📖 Workspace Security - Enterprise security features - 📖 Managed Identity - Identity-based authentication - 📖 Workspace Organization - Resource quotas and limits

Compute Resources - Compute instances: Development environments with Jupyter, VS Code - Compute clusters: Auto-scaling training workloads (0 to N nodes) - Inference clusters: AKS for production deployments - Attached compute: Use existing VMs or Azure Databricks - Serverless compute: On-demand compute without management - 📖 Compute Targets Overview - Compute options comparison - 📖 Compute Instances - Development compute - 📖 Compute Clusters - Training clusters - 📖 Kubernetes Compute - AKS and Arc-enabled Kubernetes - 📖 Serverless Compute - Managed compute

Datastores and Datasets - Datastores: Connections to Azure storage (Blob, Files, Data Lake, SQL) - Datasets: Versioned data references (FileDataset, TabularDataset) - Data access: Credential-based or identity-based authentication - Data labeling: Built-in labeling projects for ML - Data drift monitoring: Track data distribution changes - 📖 Datastores Overview - Data storage concepts - 📖 Register Datastores - Connect to storage - 📖 Create Datasets - Dataset creation - 📖 Dataset Versions - Version management - 📖 Data Labeling - Annotation projects

Development Environments - Azure ML Studio: Web-based integrated development environment - Jupyter notebooks: Interactive Python development - VS Code integration: Local development with remote compute - Azure ML SDK v2: Python SDK for programmatic access - Azure ML CLI v2: Command-line interface for automation - 📖 Azure ML Studio - Studio overview - 📖 Notebooks in Studio - Integrated notebooks - 📖 VS Code Extension - Local development - 📖 Azure ML SDK v2 - Python SDK reference - 📖 Azure ML CLI v2 - CLI reference

Security and Networking - Virtual network integration: Secure workspace access - Private endpoints: Private connectivity to Azure resources - Managed identities: Credential-free authentication - Customer-managed keys: Encryption with your own keys - Azure Policy integration: Enforce compliance standards - 📖 Network Isolation - VNet integration - 📖 Private Endpoints - Private connectivity - 📖 Managed Identity Setup - Identity configuration - 📖 Customer Managed Keys - Encryption keys - 📖 Azure Policy for ML - Governance

Explore Data and Train Models (35-40%)

Data Exploration and Preparation - Data profiling: Statistical analysis and visualization - Missing data handling: Imputation, removal, interpolation - Outlier detection: Statistical and ML-based methods - Feature engineering: Create, transform, select features - Data normalization: Scaling, standardization, encoding - 📖 Data Preparation - Data prep overview - 📖 Feature Engineering - Feature transformation - 📖 Handle Missing Data - Missing value strategies - 📖 Data Wrangling - Designer transforms

Training with Azure ML SDK - ScriptRunConfig: Define training job configuration - Environments: Manage dependencies (Docker, conda, pip) - Training scripts: Custom Python training code - Experiment tracking: MLflow integration for logging - Run history: Track metrics, parameters, artifacts - 📖 Train Models SDK - Training fundamentals - 📖 Configure Training Runs - Training configuration - 📖 Environment Management - Dependency management - 📖 MLflow Tracking - Experiment tracking - 📖 Track Experiments - Metrics and logging

Automated Machine Learning (AutoML) - Classification: Binary and multi-class prediction - Regression: Continuous value prediction - Time series forecasting: Sequential data prediction - Featurization: Automatic feature engineering - Algorithm selection: Test multiple algorithms automatically - Ensemble models: Combine multiple models - 📖 AutoML Overview - AutoML fundamentals - 📖 AutoML Classification - Classification tasks - 📖 AutoML Regression - Regression tasks - 📖 Time Series Forecasting - Forecasting configuration - 📖 AutoML Featurization - Feature engineering - 📖 AutoML Models - Algorithm selection

Hyperparameter Tuning - Sampling methods: Grid, random, Bayesian optimization - Early termination policies: Bandit, median stopping, truncation - Primary metric: Optimize specific performance metric - Concurrent runs: Parallel hyperparameter search - Sweep jobs: Define search space and strategy - 📖 Hyperparameter Tuning - Tuning fundamentals - 📖 Sampling Methods - Search strategies - 📖 Early Termination - Stop unpromising runs - 📖 Sweep Job Configuration - Sweep setup

Distributed Training - Data parallelism: Split data across multiple nodes - Model parallelism: Split model across devices - Horovod: Distributed deep learning framework - PyTorch distributed: Native PyTorch distribution - TensorFlow distributed: Multi-worker strategies - 📖 Distributed Training - Distribution strategies - 📖 Distributed PyTorch - PyTorch distribution - 📖 Distributed TensorFlow - TensorFlow distribution - 📖 Horovod Training - GPU distribution

Designer (Low-Code ML) - Drag-and-drop interface: Visual pipeline building - Built-in components: Data prep, training, evaluation - Custom components: Python/R script modules - Pipeline parameterization: Reusable pipelines - Real-time and batch inference: Deployment options - 📖 Azure ML Designer - Visual ML tool - 📖 Designer Components - Component reference - 📖 Custom Components - Create components - 📖 Designer Pipelines - Build pipelines

Prepare Models for Deployment (20-25%)

Model Evaluation - Classification metrics: Accuracy, precision, recall, F1, AUC - Regression metrics: RMSE, MAE, R-squared - Confusion matrix: True/false positives/negatives - ROC curves: Receiver operating characteristic - Residual analysis: Error distribution analysis - 📖 Model Evaluation - Evaluation metrics - 📖 Classification Metrics - Classification evaluation - 📖 Regression Metrics - Regression evaluation - 📖 Confusion Matrix - Classification matrix

Model Interpretation and Explainability - Model explainability: Understand predictions - Global importance: Overall feature contributions - Local importance: Individual prediction explanations - SHAP values: Game theory-based explanations - InterpretML: Microsoft's interpretability library - 📖 Model Interpretability - Explainability overview - 📖 InterpretML - Interpretation methods - 📖 SHAP Explanations - SHAP integration - 📖 Feature Importance - Feature contributions

Responsible AI - Fairness assessment: Identify and mitigate bias - Error analysis: Understand model failures - Model transparency: Explain model behavior - Fairlearn: Bias detection and mitigation toolkit - Responsible AI dashboard: Unified debugging tool - 📖 Responsible AI - Responsible AI overview - 📖 Fairness Assessment - Fairness evaluation - 📖 Error Analysis - Error investigation - 📖 Fairlearn Integration - Fairness toolkit - 📖 Responsible AI Dashboard - Unified dashboard - 📖 Model Debugging - Debugging tools

Model Registration - Model registry: Centralized model repository - Model versioning: Track model iterations - Model metadata: Tags, properties, descriptions - Model packaging: Include dependencies and code - Model lineage: Track training data and code - 📖 Model Registry - Registry overview - 📖 Register Models - Model registration - 📖 Model Versioning - Version control - 📖 MLflow Models - MLflow format - 📖 Model Metadata - Tags and properties

Model Packaging and Inference - Scoring script: Define input/output and inference logic - Environment specification: Dependency configuration - Model files: Serialized model artifacts - Entry script: Init and run functions - ONNX models: Interoperable model format - 📖 Model Deployment - Deployment overview - 📖 Scoring Scripts - Entry script guide - 📖 Inference Configuration - Deployment config - 📖 ONNX Models - ONNX overview

Deploy and Retrain Models (20-25%)

Online Endpoints (Real-time Inference) - Managed online endpoints: Serverless real-time inference - Kubernetes online endpoints: Deploy to AKS - Blue-green deployment: Zero-downtime updates - Traffic splitting: A/B testing and gradual rollout - Authentication: Key-based and token-based - 📖 Online Endpoints - Endpoint types - 📖 Managed Endpoints - Serverless deployment - 📖 Kubernetes Endpoints - AKS deployment - 📖 Blue-Green Deployment - Safe rollouts - 📖 Endpoint Authentication - Security

Batch Endpoints (Batch Inference) - Batch scoring: Process large datasets - Parallel processing: Scale across compute cluster - Schedule-based execution: Automated batch jobs - Pipeline batch inference: Multi-step processing - Output configuration: Write results to storage - 📖 Batch Endpoints - Batch inference overview - 📖 Create Batch Endpoints - Batch deployment - 📖 Batch Scoring - Parallel scoring - 📖 Schedule Batch Jobs - Job scheduling

Azure Container Instances (ACI) - Development/testing deployments: Low-cost testing - CPU-based inference: Lightweight workloads - No orchestration: Simple container hosting - Public or private endpoints: Flexible networking - Fast deployment: Quick testing iterations - 📖 Deploy to ACI - ACI deployment - 📖 ACI Configuration - ACI settings

Azure Kubernetes Service (AKS) - Production deployments: High-scale production workloads - Auto-scaling: Scale based on metrics - GPU support: Deep learning inference - Load balancing: Distribute requests - Multi-model serving: Host multiple models - 📖 Deploy to AKS - AKS deployment - 📖 AKS Cluster Setup - Cluster configuration - 📖 AKS Autoscaling - Scale settings - 📖 GPU Inference - GPU deployment

Model Monitoring - Data drift detection: Monitor input data changes - Model performance monitoring: Track prediction quality - Application Insights integration: Telemetry and logging - Custom logging: Application-specific metrics - Alerting: Automated notifications on issues - 📖 Model Monitoring - Monitoring overview - 📖 Data Drift - Data drift detection - 📖 Model Data Collection - Collect inference data - 📖 Application Insights - APM integration - 📖 Monitor Performance - Endpoint monitoring

Model Retraining - Scheduled retraining: Periodic model updates - Trigger-based retraining: Data drift or performance triggers - Automated pipelines: End-to-end retraining workflow - A/B testing: Compare old and new models - Champion/challenger pattern: Gradual model replacement - 📖 Retraining Models - Retraining strategies - 📖 Pipeline Schedules - Automated scheduling - 📖 Event-driven Retraining - Event triggers

MLOps and Automation

Azure ML Pipelines - Pipeline components: Reusable pipeline steps - Pipeline parameters: Parameterize workflows - Pipeline publishing: Share and reuse pipelines - Pipeline endpoints: Versioned pipeline execution - Pipeline schedules: Automated execution - 📖 Azure ML Pipelines - Pipeline fundamentals - 📖 Create Pipelines - Build pipelines - 📖 Pipeline Components - Component overview - 📖 Pipeline Parameters - Parameterization - 📖 Publish Pipelines - Pipeline deployment - 📖 Schedule Pipelines - Scheduling

CI/CD Integration - GitHub Actions: Automate ML workflows - Azure DevOps: ML pipeline automation - Azure Pipelines: Build and release automation - Model validation: Automated testing - Deployment gates: Approval workflows - 📖 MLOps Overview - MLOps fundamentals - 📖 GitHub Actions - GitHub integration - 📖 Azure DevOps - DevOps integration - 📖 CI/CD Pipelines - Automation patterns

Environment Management - Curated environments: Pre-configured Microsoft environments - Custom environments: Docker-based custom images - Conda environments: Python package management - Requirements.txt: Pip dependency specification - Environment versioning: Track environment changes - 📖 Environments - Environment overview - 📖 Curated Environments - Pre-built environments - 📖 Custom Environments - Build custom images - 📖 Dockerfile Environments - Docker integration

Model Governance - Model versioning: Track model evolution - Model approval workflow: Governance process - Model lineage: Track data and code lineage - Audit logging: Track model operations - Access control: RBAC for models - 📖 Model Management - Model lifecycle - 📖 Model Catalog - Catalog overview - 📖 Model Lineage - Track lineage

Azure ML Python SDK v2

Workspace and Compute

Connect to Workspace 

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="<subscription>",
    resource_group_name="<resource-group>",
    workspace_name="<workspace>"
)

Create Compute Cluster 

from azure.ai.ml.entities import AmlCompute

compute = AmlCompute(
    name="cpu-cluster",
    type="amlcompute",
    size="STANDARD_DS3_V2",
    min_instances=0,
    max_instances=4,
    idle_time_before_scale_down=120
)
ml_client.compute.begin_create_or_update(compute)

Data and Datasets

Create Data Asset 

from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes

data_asset = Data(
    name="my-dataset",
    path="./data",
    type=AssetTypes.URI_FOLDER,
    description="Training data"
)
ml_client.data.create_or_update(data_asset)

Create Datastore 

from azure.ai.ml.entities import AzureBlobDatastore
from azure.ai.ml.entities import AccountKeyConfiguration

blob_datastore = AzureBlobDatastore(
    name="blob_datastore",
    account_name="<account-name>",
    container_name="<container>",
    credentials=AccountKeyConfiguration(account_key="<key>")
)
ml_client.datastores.create_or_update(blob_datastore)

Training Jobs

Submit Training Job 

from azure.ai.ml import command

job = command(
    code="./src",
    command="python train.py --learning-rate ${{inputs.lr}}",
    inputs={"lr": 0.01},
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    compute="cpu-cluster",
    experiment_name="my-experiment"
)
ml_client.jobs.create_or_update(job)

AutoML Classification 

from azure.ai.ml import automl

classification_job = automl.classification(
    training_data=my_training_data,
    target_column_name="label",
    primary_metric="accuracy",
    compute="cpu-cluster",
    experiment_name="automl-classification"
)
ml_client.jobs.create_or_update(classification_job)

Model Registration and Deployment

Register Model 

from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes

model = Model(
    path="./model",
    type=AssetTypes.MLFLOW_MODEL,
    name="my-model",
    description="Model description"
)
ml_client.models.create_or_update(model)

Deploy Online Endpoint 

from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment

endpoint = ManagedOnlineEndpoint(
    name="my-endpoint",
    description="Production endpoint",
    auth_mode="key"
)
ml_client.online_endpoints.begin_create_or_update(endpoint)

deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name="my-endpoint",
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1
)
ml_client.online_deployments.begin_create_or_update(deployment)

Azure ML CLI v2

Workspace and Compute

Connect to Workspace 

az login
az account set --subscription <subscription-id>
az configure --defaults workspace=<workspace> group=<resource-group>

Create Compute 

az ml compute create --name cpu-cluster --type amlcompute --size STANDARD_DS3_V2 --min-instances 0 --max-instances 4
az ml compute list
az ml compute show --name cpu-cluster

Create Compute Instance 

az ml compute create --name my-compute-instance --type computeinstance --size STANDARD_DS3_V2

Data and Jobs

Create Data Asset 

az ml data create --name my-data --type uri_folder --path ./data
az ml data list
az ml data show --name my-data --version 1

Submit Training Job 

az ml job create --file job.yml
az ml job list --experiment-name my-experiment
az ml job show --name <job-name>
az ml job download --name <job-name> --outputs

Job YAML Example 

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: python train.py --epochs ${{inputs.epochs}}
code: ./src
environment: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
compute: cpu-cluster
inputs:
  epochs: 10

Model and Deployment

Register Model 

az ml model create --name my-model --path ./model --type mlflow_model
az ml model list
az ml model show --name my-model --version 1

Create Online Endpoint 

az ml online-endpoint create --name my-endpoint --auth-mode key
az ml online-deployment create --file deployment.yml --endpoint-name my-endpoint
az ml online-endpoint update --name my-endpoint --traffic "blue=100"

Deployment YAML Example 

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my-endpoint
model: azureml:my-model@latest
instance_type: Standard_DS3_v2
instance_count: 1

Invoke Endpoint 

az ml online-endpoint invoke --name my-endpoint --request-file request.json
az ml online-endpoint get-logs --name my-endpoint --deployment blue

Common Data Science Scenarios

Scenario 1: End-to-End Classification Pipeline

Requirements: Build, train, evaluate, and deploy classification model Solution: 1. Create Azure ML workspace and compute cluster 2. Upload and register training data as data asset 3. Create training script with scikit-learn 4. Define environment with required dependencies 5. Submit training job and track with MLflow 6. Evaluate model performance (accuracy, precision, recall) 7. Register best model in model registry 8. Create online endpoint for real-time predictions 9. Deploy model and test inference 10. Monitor endpoint performance and data drift

Scenario 2: AutoML Time Series Forecasting

Requirements: Predict future values using historical time series data Solution: 1. Prepare time series dataset with timestamp and target columns 2. Register dataset in Azure ML workspace 3. Configure AutoML forecasting job with parameters: - Time column name and target column - Forecast horizon (prediction window) - Frequency (hourly, daily, monthly) - Enable cross-validation 4. Review AutoML results and explanations 5. Select best model based on normalized RMSE 6. Deploy model to managed endpoint 7. Test with sample data for predictions 8. Schedule batch inference for regular forecasts

Scenario 3: Distributed Deep Learning Training

Requirements: Train large neural network across multiple GPUs Solution: 1. Create GPU compute cluster (Standard_NC6s_v3) 2. Prepare training script with PyTorch 3. Use distributed training with PyTorch DistributedDataParallel 4. Configure training job with multiple nodes 5. Track metrics with MLflow 6. Use learning rate finder for optimal hyperparameters 7. Implement early stopping for efficiency 8. Save checkpoints regularly 9. Register final model 10. Deploy to AKS with GPU support for inference

Scenario 4: MLOps Pipeline with CI/CD

Requirements: Automated ML workflow from training to deployment Solution: 1. Create Azure ML pipeline with components: - Data preparation component - Training component - Model evaluation component - Model registration component 2. Publish pipeline to pipeline endpoint 3. Create GitHub Actions workflow: - Trigger on code commit - Run data validation tests - Execute training pipeline - Validate model performance thresholds - Register model if metrics pass 4. Set up Azure DevOps release pipeline: - Deploy to staging endpoint - Run integration tests - Require manual approval - Deploy to production with traffic splitting 5. Configure monitoring and alerting 6. Schedule pipeline for retraining

Scenario 5: Responsible AI Implementation

Requirements: Ensure model fairness and explainability Solution: 1. Train classification model on sensitive data 2. Generate Responsible AI dashboard with components: - Model overview and predictions - Error analysis to identify failure patterns - Fairness assessment across demographic groups - Model interpretability with SHAP values - Counterfactual analysis for what-if scenarios 3. Identify fairness issues (disparate impact) 4. Retrain model with Fairlearn mitigation techniques 5. Document model cards with fairness metrics 6. Deploy with monitoring for fairness degradation 7. Create scorecard for stakeholders

Python Libraries for Data Science

Core ML Libraries

scikit-learn - Classification, regression, clustering algorithms - Model evaluation and metrics - Data preprocessing and feature engineering - Pipeline creation for workflows - 📖 scikit-learn Documentation - Official docs

pandas - Data manipulation and analysis - DataFrame operations - Data cleaning and transformation - Time series functionality - 📖 pandas Documentation - Official docs

NumPy - Numerical computing - Array operations - Mathematical functions - Linear algebra - 📖 NumPy Documentation - Official docs

Deep Learning Frameworks

PyTorch - Neural network construction - Automatic differentiation - GPU acceleration - Distributed training - 📖 PyTorch with Azure ML - Azure integration

TensorFlow/Keras - Deep learning models - Neural network layers - Model training and evaluation - Production deployment - 📖 TensorFlow with Azure ML - Azure integration

Visualization

matplotlib - Static plots and charts - Customizable visualizations - Publication-quality figures - 📖 matplotlib Documentation - Official docs

seaborn - Statistical data visualization - Attractive default styles - Complex visualizations simplified - 📖 seaborn Documentation - Official docs

Azure ML Specific

azureml-core (SDK v1 - Still supported) - Workspace management - Experiment tracking - Model registration and deployment - 📖 SDK v1 Reference - SDK v1 docs

azure-ai-ml (SDK v2 - Current) - Modern Pythonic API - Improved type hints - Enhanced error messages - 📖 SDK v2 Migration - Migration guide

MLflow - Experiment tracking - Model packaging - Model registry integration - 📖 MLflow Integration - MLflow in Azure ML

Exam Tips

Hands-On Focus

  • DP-100 heavily emphasizes practical implementation
  • Must know Python SDK and CLI commands
  • Understand Azure ML Studio navigation
  • Practice building end-to-end ML solutions
  • Know how to debug failed training runs

Common Exam Scenarios

  • Configure AutoML for different problem types
  • Implement hyperparameter tuning with sweep jobs
  • Deploy models to different compute targets
  • Monitor model performance and data drift
  • Create and schedule ML pipelines
  • Implement responsible AI practices
  • Register and version models
  • Configure compute for different workloads
  • Troubleshoot deployment failures
  • Implement MLOps workflows

Question Keywords

  • "Most cost-effective" → Use compute clusters with auto-scaling, serverless compute, spot instances
  • "Production deployment" → AKS with managed endpoints, blue-green deployment, monitoring
  • "Real-time inference" → Managed online endpoints, low latency compute
  • "Batch scoring" → Batch endpoints, parallel processing, scheduled execution
  • "Explainability" → InterpretML, SHAP values, Responsible AI dashboard
  • "Fairness" → Fairlearn, fairness metrics, bias mitigation
  • "Automated" → AutoML, pipelines, scheduled retraining
  • "Secure" → Private endpoints, managed identity, VNet integration
  • "Track experiments" → MLflow, run history, metrics logging
  • "Distributed training" → Multi-node clusters, PyTorch/TensorFlow distributed

SDK v1 vs SDK v2

  • Exam primarily focuses on SDK v2 (azure-ai-ml package)
  • SDK v1 (azureml-core) still appears in some questions
  • Know the differences in syntax and approach
  • SDK v2 uses job submission pattern (command, automl)
  • SDK v1 uses ScriptRunConfig and Estimators
  • 📖 SDK Comparison - Key differences

AutoML Configuration

Know when to use AutoML vs custom training: - Use AutoML: Quick baseline, limited time, standard ML tasks - Use custom training: Custom loss functions, specific architectures, novel algorithms - AutoML task types: Classification, regression, forecasting, NLP, computer vision - AutoML parameters: Primary metric, timeout, iterations, cross-validation

Compute Selection

  • Compute instance: Development, Jupyter notebooks, VS Code
  • Compute cluster: Training jobs, hyperparameter tuning, batch inference
  • Serverless compute: On-demand training without cluster management
  • AKS: Production deployments, high-scale inference, GPU support
  • ACI: Development/testing deployments (not for production)

Model Deployment Best Practices

  • Always use managed online endpoints for production
  • Implement blue-green deployments for zero downtime
  • Use traffic splitting for gradual rollout
  • Enable Application Insights for monitoring
  • Configure auto-scaling for variable load
  • Test thoroughly in staging before production
  • Implement proper authentication (key or token)

Responsible AI Requirements

  • Understand model fairness assessment
  • Know how to use Fairlearn for bias mitigation
  • Implement error analysis to identify weak spots
  • Generate model explanations with InterpretML
  • Create model cards for documentation
  • Use Responsible AI dashboard for comprehensive analysis

Essential Documentation

Core Resources

Hands-On Resources

Video and Interactive Resources

Final Checklist

Knowledge Requirements

  • Create and configure Azure ML workspaces
  • Manage compute resources (instances, clusters, AKS)
  • Work with datastores and datasets
  • Perform data exploration and feature engineering
  • Train models with Azure ML SDK and AutoML
  • Implement hyperparameter tuning with sweep jobs
  • Evaluate models with appropriate metrics
  • Implement model explainability and fairness assessment
  • Register and version models in model registry
  • Deploy models to online and batch endpoints
  • Monitor model performance and data drift
  • Create and schedule ML pipelines
  • Implement MLOps workflows with CI/CD
  • Use MLflow for experiment tracking
  • Understand Responsible AI principles

Skills Requirements

  • Python programming with Azure ML SDK v2
  • Azure ML CLI v2 commands
  • Azure ML Studio navigation
  • Jupyter notebook development
  • scikit-learn, pandas, NumPy proficiency
  • PyTorch or TensorFlow basics
  • Git version control
  • YAML configuration files
  • Docker container basics
  • REST API testing

Preparation Milestones

  • 6+ months ML and Azure experience (recommended)
  • Completed Microsoft Learn DP-100 learning path
  • Hands-on practice with all core Azure ML features
  • Built end-to-end ML solutions (data to deployment)
  • Practice tests completed (75%+ score)
  • Understand all exam objectives thoroughly
  • Reviewed Microsoft documentation
  • Practiced SDK v2 and CLI v2 commands
  • Implemented MLOps pipelines
  • Worked with real-world datasets

Pro Tip: DP-100 requires strong practical ML experience with Azure ML. You MUST have hands-on experience building, training, and deploying ML models. Focus on the Python SDK v2, AutoML, and deployment strategies. The exam includes scenario-based questions requiring deep understanding of ML workflows. Practice in a real Azure ML workspace every day!

Link Count: This fact sheet contains 120 embedded documentation links covering all major DP-100 exam domains.

Good luck with your DP-100 certification!