Databricks Certified Machine Learning Associate (ML Associate) validates that you can perform basic machine learning tasks on Databricks. The scope covers Databricks ML features such as AutoML, Unity Catalog, and MLflow, plus data exploration and feature engineering, model training, tuning, and evaluation, and model deployment. It is the Associate-level entry point of Databricks' ML Engineer certifications, with Machine Learning Professional above it.
| Item | Details |
|---|---|
| Official Name | Databricks Certified Machine Learning Associate |
| Questions | 48 scored (multiple choice or multiple selection) |
| Duration | 90 minutes |
| Passing Score | Not published (set through statistical analysis, subject to change) |
| Fee | $200 (excluding tax) |
| Language | English, Japanese, Brazilian Portuguese, Korean |
| Prerequisites | None (6+ months of hands-on experience recommended) |
| Validity | 2 years |
| Delivery | Online proctored (the official English page also lists test centers) |
The Japanese version is available. The Japanese exam guide linked from the Japanese page is the October 28, 2024 edition, but its outline items are the same as the English guide (current as of March 1, 2025). The remaining time is always shown at the top of the screen, and you can flag questions to review later.
| Domain | Weight | Key Topics |
|---|---|---|
| Databricks Machine Learning | 38% (~18 questions) | AutoML, Feature Store in Unity Catalog, MLflow (logging runs, Client API), the Unity Catalog model registry and aliases, ML runtimes |
| ML Workflows (called Data Processing in the exam guide) | 19% (~9 questions) | Summary statistics, outlier removal, visualization, missing-value imputation, one-hot encoding, log transformation |
| Model Development | 31% (~15 questions) | Algorithm selection, imbalanced data, estimators vs transformers, training pipelines, hyperparameter tuning (Hyperopt), cross-validation, evaluation metrics, bias-variance trade-off |
| Model Deployment | 12% (~6 questions) | Batch vs real-time vs streaming inference, deploying to Model Serving, batch inference with pandas, splitting traffic between endpoints |
The question counts are estimates from applying the official weights to 48 questions. Databricks Machine Learning (38%) and Model Development (31%) together make up about 70% of the exam. The former tests Databricks features themselves (AutoML, Feature Store, MLflow, and the model registry), while the latter tests ML fundamentals such as algorithm selection, tuning, and evaluation. The domain the official page calls "ML Workflows" is named "Data Processing" in the exam guide and covers data preparation such as summary statistics, outliers, imputation, and encoding.
Databricks AutoML is an automated machine learning feature that supports three tasks: Classification, Regression, and Forecasting. You can run it from the UI or via API. Under the hood, it automates data preprocessing, feature engineering, hyperparameter tuning, and model selection.
# Run AutoML via the API
from databricks import automl
summary = automl.classify(
dataset=train_df, # Spark DataFrame or Pandas DataFrame
target_col="churn", # Target column name
primary_metric="f1", # Metric to optimize
timeout_minutes=30 # Maximum runtime
)
# Retrieve the best model, Run, and notebook
print(summary.best_trial) # Best Trial object
print(summary.best_trial.model_path) # Path to the model artifactWhat the exam tests is the meaning of the notebook AutoML generates as output. AutoML automatically produces an editable notebook with the source code for each trial, so data scientists can manually tweak preprocessing logic or hyperparameters. In other words, AutoML is designed as a "starting point" providing a baseline model, not as a "black box." Note that the old max_trials parameter is not supported in Databricks Runtime 11.0 ML and above; limit the run with timeout_minutes instead.
Databricks Feature Store is a centralized repository for managing ML features. Feature tables are registered as Delta Tables in Unity Catalog, sharing the same feature definitions between training and serving. Creating feature tables at the account level in Unity Catalog, rather than in a per-workspace feature store, is itself an exam objective, and with Unity Catalog you use FeatureEngineeringClient (Feature Engineering in Unity Catalog).
FeatureEngineeringClient.create_table() creates the table, then you write data to it (this is the answer to the exam guide's sample question).FeatureEngineeringClient.create_training_set() joins the features.FeatureEngineeringClient.score_batch() automatically looks up the latest features.In the Databricks Machine Learning domain, the exam tests basic MLflow Tracking operations (creating an Experiment, recording a Run, saving parameters/metrics/artifacts), identifying the best run with the MLflow Client API, and the information available in the MLflow UI. On Databricks, mlflow.autolog() is enabled by default, and parameters, metrics, and models are automatically logged for major frameworks like scikit-learn, XGBoost, LightGBM, PyTorch, and TensorFlow. Manually logging metrics, artifacts, and models in a Run is also an objective, so learn the explicit API calls below as well.
import mlflow
from mlflow.models import infer_signature
mlflow.set_experiment("/Experiments/fraud_detection")
with mlflow.start_run(run_name="lgbm_baseline") as run:
# Log parameters
mlflow.log_param("model_type", "LightGBM")
mlflow.log_param("num_leaves", 31)
mlflow.log_param("learning_rate", 0.05)
mlflow.log_param("data_version", "delta_v3")
# Training
model = lgb.train(params, train_data, valid_sets=[val_data])
# Log metrics
mlflow.log_metric("auc", 0.934)
mlflow.log_metric("precision", 0.891)
mlflow.log_metric("recall", 0.867)
# Infer signature and log the model
signature = infer_signature(X_train, model.predict(X_train))
mlflow.lightgbm.log_model(model, "model", signature=signature)
# Save supporting artifacts
mlflow.log_artifact("feature_importance.png")
mlflow.log_artifact("confusion_matrix.html")The exam tests the difference between log_param (single string/number), log_params (dict, bulk),log_metric (single number, with optional step), and log_metrics (dict, bulk). Another frequent point: log_artifact takes a file path, while log_model takes a framework-specific model object. To identify the best run, search runs with MlflowClient().search_runs() and sort by a metric (for example, order_by=["metrics.auc DESC"]).
The Model Registry handles model version and lifecycle management. The exam guide includes registering a model in the Unity Catalog registry with the MLflow Client API, the benefits of the Unity Catalog registry over the legacy workspace registry, setting or removing tags on a model, and promoting a challenger model to champion with aliases.
| Aspect | Legacy Workspace Registry | Unity Catalog Registry |
|---|---|---|
| Stage Management | None → Staging → Production → Archived | Aliases (e.g., champion / challenger; user-defined) |
| Scope | Single workspace | Account level (shared across workspaces) |
| Permission Model | Workspace-level ACLs | Unity Catalog 3-level permissions (catalog.schema.model) |
| Lineage | Limited | Automatic tracking from table → model → endpoint |
# Register to the Unity Catalog Model Registry
mlflow.set_registry_uri("databricks-uc")
mlflow.register_model(
model_uri=f"runs:/{run.info.run_id}/model",
name="ml_prod.fraud.lgbm_model" # 3-level name: catalog.schema.model
)
# Set an alias
from mlflow import MlflowClient
client = MlflowClient()
client.set_registered_model_alias(
name="ml_prod.fraud.lgbm_model",
alias="champion",
version=5
)
# Set a tag on a model version (delete_model_version_tag removes it)
client.set_model_version_tag(
name="ml_prod.fraud.lgbm_model",
version=5,
key="validation_status",
value="approved"
)The official page calls this domain "ML Workflows"; the exam guide calls it "Data Processing." It covers exploring and preprocessing data before it goes into a model, with 9 objectives in the guide.
.summary() on a Spark DataFrame (count, mean, stddev, min, quartiles, max) or dbutils.data.summarize().from pyspark.ml.feature import Imputer, StringIndexer, OneHotEncoder
# Summary statistics
train_df.summary().show()
# Impute missing values with the median
imputer = Imputer(strategy="median", inputCols=["income"], outputCols=["income_imputed"])
# One-hot encode a categorical column (index it first, then encode)
indexer = StringIndexer(inputCol="plan", outputCol="plan_idx")
encoder = OneHotEncoder(inputCols=["plan_idx"], outputCols=["plan_ohe"])This domain covers model training, tuning, and evaluation, with 15 objectives in the exam guide. The Pipeline API in Spark MLlib (the pyspark.ml package) ties into the objectives on comparing estimators and transformers, developing a training pipeline, and performing cross-validation. Distinguishing Transformer (transformation: takes data, returns data) from Estimator (estimation: takes data, returns a Model = Transformer) is the most fundamental point.
| Concept | Role | Examples |
|---|---|---|
| Transformer | DataFrame → DataFrame (adds/transforms columns) | VectorAssembler, StringIndexer (fitted), Tokenizer |
| Estimator | DataFrame → produces a Model (Transformer) | LogisticRegression, RandomForestClassifier, StringIndexer (unfitted) |
| Pipeline | Sequential chain of Transformers/Estimators | Bundles preprocessing → feature transform → training into one object |
| CrossValidator | Hyperparameter tuning via cross-validation | Grid search using ParamGridBuilder |
from pyspark.ml import Pipeline
from pyspark.ml.feature import VectorAssembler, StringIndexer, StandardScaler
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder
from pyspark.ml.evaluation import BinaryClassificationEvaluator
# Stage 1: Encode categorical variables
indexer = StringIndexer(inputCol="category", outputCol="category_idx")
# Stage 2: Build the feature vector
assembler = VectorAssembler(
inputCols=["amount", "category_idx", "hour_of_day"],
outputCol="features"
)
# Stage 3: Scaling
scaler = StandardScaler(inputCol="features", outputCol="scaled_features")
# Stage 4: Logistic regression
lr = LogisticRegression(featuresCol="scaled_features", labelCol="label")
# Build the Pipeline
pipeline = Pipeline(stages=[indexer, assembler, scaler, lr])
# Hyperparameter tuning with CrossValidator
param_grid = (ParamGridBuilder()
.addGrid(lr.regParam, [0.01, 0.1, 1.0])
.addGrid(lr.elasticNetParam, [0.0, 0.5, 1.0])
.build())
evaluator = BinaryClassificationEvaluator(
labelCol="label", metricName="areaUnderROC"
)
cv = CrossValidator(
estimator=pipeline,
estimatorParamMaps=param_grid,
evaluator=evaluator,
numFolds=3,
parallelism=4 # Parallelism level (tune for available cluster resources)
)
cv_model = cv.fit(train_df)
best_model = cv_model.bestModelThe parallelism parameter of CrossValidator is a popular exam target. The default is 1 (sequential), but with spare cluster resources you can shorten tuning time by increasing parallelism. Be aware, however, that each fold's training runs as a distributed Spark job — pushing parallelism too high can cause resource contention.
The exam guide covers tuning with Hyperopt's fmin, choosing between random search, grid search, and Bayesian search, and parallelizing single-node models for hyperparameter tuning. In Hyperopt, SparkTrials distributes the trials of a single-node model (such as scikit-learn) across Spark workers.
Counting the models trained by grid search combined with cross-validation is also an explicit objective: multiply the number of parameter combinations by the number of folds. In the exam guide's sample question, a 3 × 2 × 3 grid (18 combinations) with 5-fold cross-validation trains 90 models. For evaluation metrics, the guide names F1, Log Loss, and ROC/AUC for classification and RMSE, MAE, and R-squared for regression. Handling imbalanced data (for example, cost-sensitive learning that assigns a higher misclassification cost to the minority class) and the bias-variance trade-off of model complexity are also in scope.
This domain tests the differences between inference patterns (batch, real-time, streaming) and deployment to Model Serving. The exam guide's 6 objectives include deploying a custom model to an endpoint, batch inference with pandas, streaming inference with Delta Live Tables (now Lakeflow Pipelines), and splitting traffic between endpoints for real-time inference.
mlflow.pyfunc.spark_udf() applied to a Spark DataFrame# Typical batch inference pattern
predict_udf = mlflow.pyfunc.spark_udf(
spark,
model_uri="models:/ml_prod.fraud.lgbm_model@champion"
)
predictions = (spark.table("silver.transactions")
.withColumn("fraud_score", predict_udf("amount", "merchant_category", "hour_of_day"))
)A Pandas UDF (vectorized UDF) runs single-node pandas processing in parallel across Spark. Apache Arrow handles the data transfer, so it processes data faster than a row-at-a-time Python UDF.
import pandas as pd
from pyspark.sql.functions import pandas_udf
from pyspark.sql.types import DoubleType
@pandas_udf(DoubleType())
def predict_batch(features: pd.Series) -> pd.Series:
"""Run Pandas-based inference on each partition"""
model = load_model() # Load from a broadcast variable or MLflow
return pd.Series(model.predict(features.tolist()))
# Runs in parallel across each partition of the Spark DataFrame
predictions = df.withColumn("prediction", predict_batch("features"))With Model Serving, you deploy a model registered in Unity Catalog (including a custom model) to an endpoint and query it over REST API. You can also serve several model versions behind one endpoint and split traffic between them (for example, 90% and 10%).
Distributed deep learning (for example, with TorchDistributor) and the Pandas API on Spark (pyspark.pandas) are not in the current exam guide (as of March 1, 2025). Large-scale distributed training, such as choosing between data and model parallelism or comparing Ray and Spark, appears in the Machine Learning Professional exam guide instead.
MLflow is at the heart of Databricks Machine Learning (38%): the exam guide lists logging runs, the Client API, the Unity Catalog model registry, and aliases, and Model Deployment builds on registered models too. Memorizing the following API patterns accurately is the key to passing.
| API | Arguments | Purpose |
|---|---|---|
mlflow.start_run() | run_name, nested | Start a Run (use as a context manager) |
mlflow.log_param() | key, value | Log a single hyperparameter |
mlflow.log_metric() | key, value, step | Log a single metric (use step to track epochs) |
mlflow.log_artifact() | local_path | Save a local file as an artifact |
mlflow.sklearn.log_model() | model, artifact_path | Save a scikit-learn model (flavor-specific) |
mlflow.autolog() | None (or a config dict) | Automatically log parameters/metrics/models for supported frameworks |
MlflowClient().search_runs() | experiment_ids, filter_string, order_by | Search runs and identify the best one |
mlflow.register_model() | model_uri, name | Register to the Model Registry |
mlflow.pyfunc.spark_udf() | spark, model_uri | Use as a Spark UDF for batch inference |
| Theme | What is Tested |
|---|---|
| Supported Tasks | Three tasks: Classification, Regression, and Forecasting (time series). Clustering is not supported. |
| How to Run | UI (launched from the Experiments screen) and API (automl.classify(), etc.) — two options |
| Outputs | MLflow Experiment, a Run for each Trial, an editable source notebook, and the best model |
| Data Preprocessing | Missing-value imputation, one-hot encoding, and feature selection are performed automatically |
| Customization | Edit the generated notebook to tune preprocessing or the model and rerun as your own Run |
| Topic | DEA | ML Associate |
|---|---|---|
| Delta Lake basics | Central to ingestion, transformation, and table management (Auto Loader, COPY INTO, Liquid Clustering, etc.) | Basic level, in the feature-table context |
| Spark DataFrame | Centered on ETL operations (filter, join, aggregate) | Feature engineering operations for ML |
| Unity Catalog | Table and view permission management | Registering and managing models and feature tables (including the comparison with the workspace registry) |
| MLflow | Not in the exam guide | Tracking/Registry/Serving tested in detail |
| Spark ML | Not tested | Estimators/transformers, training pipelines, and cross-validation are tested |
| AutoML | Not tested | How to run, outputs, and customization are all tested |
| Lakeflow Pipelines (formerly Delta Live Tables) | Tested (the exam guide calls it Lakeflow Spark Declarative Pipelines) | Tested in the streaming-inference context (the exam guide calls it Delta Live Tables) |
| Lakeflow Jobs | Tested in detail | Not in the exam guide |
Candidates who already passed DEA can carry over their Delta Lake, Spark DataFrame, and Unity Catalog fundamentals. On top of that, you need nearly all of ML Associate's four official domains: Databricks Machine Learning (AutoML, Feature Store, MLflow, and the model registry; 38%), ML Workflows (data processing; 19%), Model Development (31%), and Model Deployment (12%). DEA knowledge helps mainly with basic Spark DataFrame and Unity Catalog operations, so even DEA-certified candidates should plan to learn the machine learning parts from scratch, using the roadmap below as a guide.
create_training_set().Model Development
Question 1
An ML engineer wants to build a Spark ML pipeline and perform hyperparameter tuning. Which combination correctly fills in the blanks in the code below? pipeline = Pipeline(stages=[indexer, assembler, lr]) param_grid = ParamGridBuilder().addGrid(lr.regParam, [0.01, 0.1]).build() evaluator = BinaryClassificationEvaluator(labelCol='label') cv = CrossValidator(estimator=___A___, estimatorParamMaps=___B___, evaluator=evaluator, numFolds=3) cv_model = cv.fit(train_df) best = cv_model.___C___
Correct answer: A
Pass the entire Pipeline to CrossValidator's estimator. Passing only lr omits preprocessing (indexer, assembler), so training runs without the necessary data transformations and fails. estimatorParamMaps takes the parameter-grid list built by ParamGridBuilder. Retrieve the best model via the bestModel property (camelCase in Python). best_params is a scikit-learn API and is not used in Spark ML.
Can I study for ML Associate and Data Engineer Associate at the same time?
Delta Lake, Spark DataFrame, and Unity Catalog basics are used on both exams, but all four official domains of ML Associate are about machine learning tasks (Databricks Machine Learning 38%, ML Workflows 19%, Model Development 31%, Model Deployment 12%). MLflow, AutoML, Feature Store, model training/tuning/evaluation, and deployment are not in the DEA exam guide, so you have to study them separately. You can study both in parallel, but taking one exam at a time (DEA → ML Associate) makes the scope easier to manage.
How much Python code appears on the ML Associate exam?
The official page says all machine learning code on this exam is in Python, and data manipulation code that isn't specific to ML may be given in SQL. Databricks does not publish how many of the 48 questions include code. The exam guide lists objectives such as manually logging metrics, artifacts, and models in an MLflow Run, comparing estimators and transformers, developing a training pipeline, performing cross-validation, and tuning hyperparameters with Hyperopt's fmin, so you need to be able to read code and reason about it. The exam is multiple choice, so you never write code, but you must know API argument names and return types precisely.
What is the difference between ML Professional and ML Associate?
Associate asks whether you can perform basic machine learning tasks on Databricks: AutoML, Feature Store, MLflow and the Unity Catalog model registry, data preprocessing, model training and evaluation, and basic deployment. Professional asks you to design, implement, and manage enterprise-scale ML solutions: scalable SparkML pipelines, distributed training and hyperparameter tuning (Optuna, Ray), testing, environment management with Declarative Automation Bundles, automated retraining, drift detection with Lakehouse Monitoring (now called data profiling), and deployment strategies such as blue-green and canary. Passing Associate is not a prerequisite, but Associate-level knowledge is assumed.
Related Databricks Certification Articles
Machine Learning Professional: Complete Guide
MLP — production ML system design
Generative AI Engineer Associate: Complete Guide
GenAI cert that shares some topics with MLA (MLflow, Model Serving)
Databricks Exam Difficulty Ranking
Databricks exams ranked with study-time estimates
Databricks Certifications Overview
Scope, format, and language options at a glance
Practice with certification-focused question sets
Try free questionsNicheeLab Editorial Team
NicheeLab editorial team focused on data engineering and cloud certification learning. Content is structured around practical study needs and official exam domains.
Databricks Certifications: All 8 Exams, Difficulty & Study Plan (2026)
Complete guide to all 8 Databricks certifications — Data Eng...
Databricks Exam Difficulty Ranking: 7 Certs Compared (2026)
Seven Databricks certifications ranked by difficulty, with s...
Databricks Study Guide: Fastest Pass Route & Time Estimates (2026)
How to pass Databricks certifications efficiently. Official ...
Databricks Data Engineer Associate: Complete Guide (2026)
Domain-by-domain breakdown of the Databricks Certified Data ...
Databricks Data Engineer Professional: Complete Guide (2026)
Tactics for the Databricks Certified Data Engineer Professio...