Databricks

Databricks ML Associate: Complete Guide to MLflow & AutoML

2026-03-26
Updated: 2026-10-15
NicheeLab Editorial Team
Table of contents
  1. Exam Overview
  2. The 4 Exam Domains and Their Weights
  3. Domain 1: Databricks Machine Learning (38%)
  4. Domain 2: ML Workflows (19%)
  5. Domain 3: Model Development (31%)
  6. Domain 4: Model Deployment (12%)
  7. MLflow High-Frequency Patterns
  8. AutoML Question Patterns
  9. Overlap and Differences vs. DEA (Data Engineer Associate)
  10. Study Roadmap (2-3 Months)
  11. Try a Sample Question
  12. Frequently Asked Questions

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.

Exam Overview

ItemDetails
Official NameDatabricks Certified Machine Learning Associate
Questions48 scored (multiple choice or multiple selection)
Duration90 minutes
Passing ScoreNot published (set through statistical analysis, subject to change)
Fee$200 (excluding tax)
LanguageEnglish, Japanese, Brazilian Portuguese, Korean
PrerequisitesNone (6+ months of hands-on experience recommended)
Validity2 years
DeliveryOnline 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.

The 4 Exam Domains and Their Weights

DomainWeightKey Topics
Databricks Machine Learning38% (~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 Development31% (~15 questions)Algorithm selection, imbalanced data, estimators vs transformers, training pipelines, hyperparameter tuning (Hyperopt), cross-validation, evaluation metrics, bias-variance trade-off
Model Deployment12% (~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.

Domain 1: Databricks Machine Learning (38%)

AutoML

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 artifact

What 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.

Feature Store

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).

  • Feature tables are stored on Delta Lake; Time Travel lets you reproduce point-in-time features.
  • Create: FeatureEngineeringClient.create_table() creates the table, then you write data to it (this is the answer to the exam guide's sample question).
  • Training: FeatureEngineeringClient.create_training_set() joins the features.
  • Inference: FeatureEngineeringClient.score_batch() automatically looks up the latest features.
  • Publishing to an online feature table (online store) makes the same features available with low latency for real-time inference. The difference between online and offline feature tables is also an exam objective.

MLflow Tracking

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"]).

Model Registry

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.

AspectLegacy Workspace RegistryUnity Catalog Registry
Stage ManagementNone → Staging → Production → ArchivedAliases (e.g., champion / challenger; user-defined)
ScopeSingle workspaceAccount level (shared across workspaces)
Permission ModelWorkspace-level ACLsUnity Catalog 3-level permissions (catalog.schema.model)
LineageLimitedAutomatic 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"
)

Domain 2: ML Workflows (19%)

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 Statistics, Outliers, and Visualization

  • Summary statistics: use .summary() on a Spark DataFrame (count, mean, stddev, min, quartiles, max) or dbutils.data.summarize().
  • Outliers: remove values more than a set number of standard deviations from the mean (3 is common), or values more than 1.5 × IQR (Q3 − Q1) outside the quartiles.
  • Visualization and comparison: bar charts for categorical features, histograms or box plots for continuous ones. Compare two continuous features with correlation or a scatter plot, and two categorical features with a cross-tab or a chi-square test.

Imputation, Encoding, and Log Transformation

  • Missing values: the mean is sensitive to outliers, so the median suits skewed distributions and the mode suits categorical features. Check the distribution before choosing (the exam guide's sample question rewards exactly this).
  • One-hot encoding: needed for models such as linear models that cannot treat categories as ordered numbers. It can be a poor fit for features with very many categories or for tree-based models.
  • Log transformation: use it for right-skewed features or targets. If you log-transform the target, exponentiate the predictions back to the original scale before computing evaluation metrics.
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"])

Domain 3: Model Development (31%)

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.

ConceptRoleExamples
TransformerDataFrame → DataFrame (adds/transforms columns)VectorAssembler, StringIndexer (fitted), Tokenizer
EstimatorDataFrame → produces a Model (Transformer)LogisticRegression, RandomForestClassifier, StringIndexer (unfitted)
PipelineSequential chain of Transformers/EstimatorsBundles preprocessing → feature transform → training into one object
CrossValidatorHyperparameter tuning via cross-validationGrid 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.bestModel

The 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.

Hyperparameter Tuning and How Many Models Get Trained

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.

Domain 4: Model Deployment (12%)

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.

Inference Patterns

  • Real-time inference: create an endpoint with Model Serving and infer over REST API
  • Batch inference: mlflow.pyfunc.spark_udf() applied to a Spark DataFrame
  • Streaming inference: Structured Streaming + spark_udf() applied to real-time data
  • Delta Live Tables (now Lakeflow Pipelines): apply the model as a Spark UDF inside a pipeline. In the exam guide's sample question, this is the answer when compute must resize automatically as event volume fluctuates.
# 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"))
)

Batch Inference with pandas (Pandas UDF)

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"))

Deploying to Endpoints and Splitting Traffic

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 High-Frequency Patterns

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.

APIArgumentsPurpose
mlflow.start_run()run_name, nestedStart a Run (use as a context manager)
mlflow.log_param()key, valueLog a single hyperparameter
mlflow.log_metric()key, value, stepLog a single metric (use step to track epochs)
mlflow.log_artifact()local_pathSave a local file as an artifact
mlflow.sklearn.log_model()model, artifact_pathSave 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_bySearch runs and identify the best one
mlflow.register_model()model_uri, nameRegister to the Model Registry
mlflow.pyfunc.spark_udf()spark, model_uriUse as a Spark UDF for batch inference

AutoML Question Patterns

ThemeWhat is Tested
Supported TasksThree tasks: Classification, Regression, and Forecasting (time series). Clustering is not supported.
How to RunUI (launched from the Experiments screen) and API (automl.classify(), etc.) — two options
OutputsMLflow Experiment, a Run for each Trial, an editable source notebook, and the best model
Data PreprocessingMissing-value imputation, one-hot encoding, and feature selection are performed automatically
CustomizationEdit the generated notebook to tune preprocessing or the model and rerun as your own Run

Overlap and Differences vs. DEA (Data Engineer Associate)

TopicDEAML Associate
Delta Lake basicsCentral to ingestion, transformation, and table management (Auto Loader, COPY INTO, Liquid Clustering, etc.)Basic level, in the feature-table context
Spark DataFrameCentered on ETL operations (filter, join, aggregate)Feature engineering operations for ML
Unity CatalogTable and view permission managementRegistering and managing models and feature tables (including the comparison with the workspace registry)
MLflowNot in the exam guideTracking/Registry/Serving tested in detail
Spark MLNot testedEstimators/transformers, training pipelines, and cross-validation are tested
AutoMLNot testedHow 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 JobsTested in detailNot 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.

Study Roadmap (2-3 Months)

Phase 1: Build the Foundation (Weeks 1-3)

  • Complete the official MLflow tutorial (free course on Databricks Academy).
  • On Free Edition (the successor to Community Edition), run the full flow: create an Experiment → record a Run → register to the Model Registry.
  • Review Transformer/Estimator/Evaluator concepts of Spark ML Pipeline in the official documentation.
  • Shore up basic operations in scikit-learn, Pandas, and NumPy if you are not confident.

Phase 2: Hands-on Practice (Weeks 4-7)

  • Practice summary statistics, outlier removal, imputation, and one-hot encoding on a Spark DataFrame.
  • Run AutoML from both UI and API and learn the structure of the generated notebook.
  • Implement hyperparameter tuning with CrossValidator + ParamGridBuilder.
  • Register a feature table to the Feature Store and build training data with create_training_set().
  • Build a batch inference pipeline using Pandas UDFs.
  • Practice the end-to-end flow: set an alias in Unity Catalog Model Registry → deploy to Model Serving.

Phase 3: Exam Prep (Weeks 8-12)

  • Work through the sample questions in the Exam Guide and a question bank at least twice, and identify your weak domains (Databricks does not offer official practice exams).
  • Memorize the MLflow API table (log_param/log_metric/log_artifact/log_model).
  • Sort out the difference between legacy Model Registry stage transitions and Unity Catalog aliases.
  • Review how to count the models trained by grid search with cross-validation, and how to choose evaluation metrics (F1, Log Loss, ROC/AUC, RMSE, MAE, R-squared).
  • The real exam is 48 questions in 90 minutes (just under 2 minutes each), so practice under a timer to get used to that pace.

Try a Sample Question

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___

  1. A: pipeline, B: param_grid, C: bestModel
  2. A: lr, B: param_grid, C: bestModel
  3. A: pipeline, B: param_grid, C: best_params
  4. A: pipeline, B: [0.01, 0.1], C: bestModel

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.

Frequently Asked Questions

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

Check what you learned with practice questions

Practice with certification-focused question sets

Try free questions
Author

NicheeLab Editorial Team

NicheeLab editorial team focused on data engineering and cloud certification learning. Content is structured around practical study needs and official exam domains.


Related articles
Databricks

Databricks Certifications: All 8 Exams, Difficulty & Study Plan (2026)

Complete guide to all 8 Databricks certifications — Data Eng...

Databricks

Databricks Exam Difficulty Ranking: 7 Certs Compared (2026)

Seven Databricks certifications ranked by difficulty, with s...

Databricks

Databricks Study Guide: Fastest Pass Route & Time Estimates (2026)

How to pass Databricks certifications efficiently. Official ...

Databricks

Databricks Data Engineer Associate: Complete Guide (2026)

Domain-by-domain breakdown of the Databricks Certified Data ...

Databricks

Databricks Data Engineer Professional: Complete Guide (2026)

Tactics for the Databricks Certified Data Engineer Professio...

Browse all Databricks articles (110)
© 2026 NicheeLab All rights reserved.