Overview
Databricks Machine Learning is the platform section of the exam and carries 38% of the score, the biggest share of the four. Its 18 objectives fall into five groups. MLOps and runtimes ask why teams separate development, staging and production, and what Databricks Runtime for Machine Learning preinstalls. AutoML covers how it trains candidate models across algorithms and why its generated notebooks help. Feature engineering covers creating feature tables in Unity Catalog, writing to them, training and scoring with feature lookups, and how offline and online stores differ. MLflow covers logging runs by hand, finding the best run with the client API and reading the MLflow UI. The registry objectives cover models in Unity Catalog, tags, and promoting a challenger to champion with aliases.
The exam remains active. The guide Databricks links today is a file labelled August 2026, but its content is dated 1 March 2025 and matches the earlier outline.
How it's tested
Questions in this section are mostly short workspace scenarios: a team wants to track experiments, reuse features across workspaces, or move a better model into use without editing code. Many show a fragment that uses the MLflow or Feature Engineering client and ask which call completes it or what it returns. Learn the method names and what each one does.
-
Pick the API call
A task such as finding the lowest-RMSE run or registering a model is described, and you choose the MLflow or Feature Engineering method that performs it.
-
Registry lifecycle
A model version needs to be marked, validated or promoted, and you decide between a tag, an alias or a new registration in Unity Catalog.
-
Platform advantage
You identify the benefit of AutoML, an ML runtime, or account-level feature tables compared with a manual or workspace-scoped approach.
A nightly scoring job loads models:/prod.ml.churn@champion. A retrained version 7 beats the current champion in offline tests. Editing the job to reference version 7 would work but adds a code change for every release. Reassigning the champion alias to version 7 with set_registered_model_alias means the next run resolves the alias to the new version. That pointer move, not a stage transition or tag, is the answer the exam expects.
Objectives 18
Official objectives from the Databricks outline, in outline order.
1.1 Identify the best practices of an MLOps strategyEnvironments, automation and governance across the ML lifecycle.
- What it means
- MLOps applies DevOps and DataOps practice to machine learning so that code, data and models move reliably from development to production. Databricks guidance separates development, staging and production, often as separate catalogs or workspaces governed by Unity Catalog.
- What to understand
- Recommended practices include version-controlling code in Git folders, tracking every experiment in MLflow, registering models in Unity Catalog, automating tests and deployment with jobs or CI/CD, and monitoring models after release. Databricks' default pattern is deploy code: the reviewed training code is promoted through environments and retrains the model in production on production data.
- How it shows up
- Expect a scenario asking which practice most reduces risk when moving a model toward production.
- Common confusion
- Thinking MLOps covers only deployment, when it also spans data, code, testing and monitoring.
1.2 Identify the advantages of using ML runtimesWhat Databricks Runtime for Machine Learning adds.
- What it means
- Databricks Runtime for Machine Learning is a cluster image that adds common ML libraries to the standard runtime, such as scikit-learn, XGBoost, LightGBM, PyTorch, TensorFlow and MLflow, in versions tested to work together.
- What to understand
- The advantage is a ready environment: no manual installs, compatible library versions, GPU variants with drivers, and built-in integration with MLflow, AutoML and feature engineering. It saves setup time and avoids dependency drift between team members. You can still add libraries at notebook or cluster scope. Library lists change between releases, for example Hyperopt is not included after 16.4 LTS ML.
- How it shows up
- A team keeps fixing library conflicts on standard clusters, and the answer is to select an ML runtime.
- Common confusion
- Assuming the standard runtime already ships the full ML library stack.
1.3 Identify how AutoML facilitates model/feature selection.How AutoML searches algorithms and prepares features.
- What it means
- AutoML takes a dataset and a target column, then trains and evaluates many candidate models across several algorithms and hyperparameter settings, recording each trial in an MLflow experiment.
- What to understand
- For model selection, AutoML compares algorithms such as decision trees, random forests, linear or logistic regression, XGBoost and LightGBM, and ranks trials by the primary metric you choose. For features, it handles imputation and encoding, can join columns from existing feature tables, and its data exploration notebook highlights missing values, high cardinality and skew. You then open the best trial or any other.
- How it shows up
- Asked how AutoML helps choose an algorithm, look for trials ranked by an evaluation metric and tracked in MLflow.
- Common confusion
- Believing AutoML returns one opaque model with no record of the alternatives it tried.
1.4 Identify the advantages AutoML brings to the model development processWhy start a project with AutoML.
- What it means
- This objective asks why AutoML is useful in the workflow, beyond how it picks models: speed to a baseline, transparency, and a starting point that experts can refine.
- What to understand
- AutoML is a glass-box tool. Each trial produces an editable notebook containing the full training code, so data scientists can review, change and rerun it. A quick baseline shows what accuracy is realistic before heavy investment, and less experienced users get a reasonable model. Because every trial is logged to MLflow, the chosen model can be registered and served like any hand-built one.
- How it shows up
- A scenario wants a fast, reviewable baseline; generated source notebooks are the clue that points to AutoML.
- Common confusion
- Calling AutoML a black box, when its generated code is the tested advantage.
1.5 Identify the benefits of creating feature store tables at the account level in Unity Catalog in Databricks vs at the workspace levelUnity Catalog feature tables versus the legacy workspace feature store.
- What it means
- Feature tables can live in Unity Catalog, where any Delta table with a primary key can serve as a feature table, instead of in the legacy Workspace Feature Store that belonged to one workspace.
- What to understand
- Unity Catalog feature tables are available to every workspace attached to the metastore, so teams reuse features without copying them. They inherit Unity Catalog governance: grants on catalogs and schemas, lineage from feature tables to models and endpoints, discovery in Catalog Explorer, and audit logs. The workspace feature store lacked cross-workspace sharing and central permissions. New code uses FeatureEngineeringClient rather than the older FeatureStoreClient.
- How it shows up
- Look for requirements such as sharing features across workspaces or tracing which models use a feature.
- Common confusion
- Thinking Unity Catalog feature tables use a special format rather than Delta tables with primary keys.
1.6 Create a feature store table in Unity CatalogCreating feature tables with FeatureEngineeringClient.
- What it means
- This covers creating a feature table in a Unity Catalog catalog and schema with FeatureEngineeringClient from the databricks-feature-engineering package, or by adding a primary key constraint to an existing Delta table.
- What to understand
- fe.create_table takes a three-level name (catalog.schema.table), primary_keys, and either a DataFrame through df or an explicit schema, plus an optional description. Primary key columns must be non-nullable. Time series feature tables add a timestamp key for point-in-time lookups. You need USE CATALOG, USE SCHEMA and CREATE TABLE privileges. Passing df both defines the table and writes its first rows.
- How it shows up
- A code fragment is missing one argument, usually primary_keys or the full three-level table name.
- Common confusion
- Leaving out the primary key, which every Unity Catalog feature table requires.
1.7 Write data to a feature store tableRefreshing feature values with write_table.
- What it means
- After creation, feature values are refreshed by computing a new DataFrame and writing it with fe.write_table, typically from a scheduled job.
- What to understand
- write_table with mode='merge' upserts by primary key: rows whose keys already exist are updated and new keys are inserted, while keys missing from the new DataFrame stay untouched. Merge is the supported mode in the Feature Engineering client and suits incremental refreshes. Because feature tables are ordinary Delta tables, SQL MERGE statements and streaming writes also work.
- How it shows up
- Expect a question on what happens to existing and missing keys when new rows are written in merge mode.
- Common confusion
- Expecting merge to delete rows whose keys are absent from the new DataFrame.
1.8 Train a model with features from a feature store table.Building training sets with feature lookups.
- What it means
- Training with feature tables means declaring which features to join to a label DataFrame with FeatureLookup objects, then letting the client assemble the training set.
- What to understand
- Create FeatureLookup entries with table_name, lookup_key and optional feature_names, then call fe.create_training_set with the label DataFrame, the lookups, the label column and any exclude_columns. load_df() returns the joined DataFrame for fitting. Log the fitted model with fe.log_model and the training_set so that the model carries its feature metadata, which later lets scoring fetch features on its own.
- How it shows up
- Watch for the step that links a model to its features: fe.log_model with training_set, not plain MLflow flavor logging.
- Common confusion
- Logging with mlflow.sklearn.log_model, which drops the lookup metadata needed at scoring.
1.9 Score a model using features from a feature store table.Batch scoring with automatic feature lookup.
- What it means
- Scoring with feature tables means passing only the lookup keys, plus any request-time columns, while the packaged model retrieves its own features.
- What to understand
- fe.score_batch takes a model URI and a DataFrame holding the lookup keys. Because the model was packaged with fe.log_model, it knows which tables and columns to join, so callers do not rebuild features by hand. That keeps training and inference inputs consistent and removes a common source of training-serving skew. The output is the input DataFrame plus a prediction column.
- How it shows up
- A question asks what the scoring DataFrame must contain; the answer is the primary key columns.
- Common confusion
- Assuming every feature must be joined manually before calling score_batch.
1.10 Describe the differences between online and offline feature tablesOffline Delta tables versus low-latency online stores.
- What it means
- Offline feature tables are the Delta tables in Unity Catalog used for training and batch scoring. Online stores keep a synchronized copy of selected features in a low-latency database for real-time serving.
- What to understand
- The offline store favours throughput and history, including point-in-time lookups on time series tables. An online store is tuned for millisecond reads by primary key and is published or synced from the offline table. Model Serving endpoints read online features automatically for models logged with feature metadata. Offline suits training and batch jobs; online suits real-time inference.
- How it shows up
- Real-time inference that needs fresh feature values at low latency points to an online store.
- Common confusion
- Training against the online store, or serving real-time requests straight from the Delta table.
1.11 Identify the best run using the MLflow Client API.Searching runs programmatically.
- What it means
- This covers finding the top run in an experiment with code rather than the UI, using MlflowClient.search_runs or the mlflow.search_runs helper.
- What to understand
- search_runs takes experiment IDs, an optional filter string such as "metrics.rmse < 5", an order_by list such as ["metrics.rmse ASC"], and max_results. Sort error metrics ascending and accuracy, F1 or AUC descending. The first result's info.run_id builds a runs:/<run_id>/model URI for loading or registering. mlflow.search_runs returns a pandas DataFrame; the client method returns Run objects.
- How it shows up
- Check the sort direction in order_by; DESC on an error metric is the classic distractor.
- Common confusion
- Sorting RMSE descending, which places the worst run first.
1.12 Manually log metrics, artifacts, and models in an MLflow Run.Explicit logging inside mlflow.start_run.
- What it means
- Manual logging means calling MLflow logging functions yourself inside a run context instead of relying only on autologging.
- What to understand
- Inside with mlflow.start_run(): use log_param or log_params for settings, log_metric or log_metrics for numeric results (optionally with a step), log_artifact or log_figure for files and plots, and a flavor call such as mlflow.sklearn.log_model for the model, ideally with a signature and input example. Autologging on Databricks captures much of this, but manual calls add custom metrics and artifacts it misses.
- How it shows up
- A fragment must save a confusion matrix image or a custom score; pick the matching log function.
- Common confusion
- Using log_param for a metric, or log_metric for a value that is not numeric.
1.13 Identify information available in the MLflow UIWhat experiment and run pages show.
- What it means
- The MLflow UI in a Databricks workspace displays experiments, their runs and the details captured for each run.
- What to understand
- A run page shows parameters, metrics with charts across steps, tags, artifacts including the logged model files, the source notebook and its revision, user, start time and duration, and the model signature. The experiment view filters, sorts and compares runs side by side with parallel coordinates and scatter charts. Lineage links a logged model to its registered versions in Unity Catalog.
- How it shows up
- Expect a question on where to find a run's source notebook, hyperparameters or saved plots.
- Common confusion
- Expecting the UI to show something that was never logged during the run.
1.14 Register a model using the MLflow Client API in the Unity Catalog registryRegistering model versions in Unity Catalog.
- What it means
- Registration turns a logged model artifact into a numbered version of a registered model in Unity Catalog, named catalog.schema.model.
- What to understand
- Set mlflow.set_registry_uri("databricks-uc") (the default on recent runtimes), then call mlflow.register_model("runs:/<run_id>/model", "main.ml.churn"), or use MlflowClient.create_registered_model and create_model_version. Unity Catalog requires a model signature. You need CREATE MODEL on the schema. Each new registration under the same name adds the next version number.
- How it shows up
- Look for a missing registry URI or a two-level model name in the snippet.
- Common confusion
- Using a workspace-style model name instead of the three-level catalog.schema.model form.
1.15 Identify benefits of registering models in the Unity Catalog registry over the workspace registryWhy models in Unity Catalog replaced the workspace registry.
- What it means
- Databricks recommends models in Unity Catalog over the legacy Workspace Model Registry, and this objective asks what that move gains.
- What to understand
- Benefits include central access control with grants on catalogs, schemas and models; cross-workspace access, so a model trained in one workspace can be served from another; lineage back to the run, notebook and training tables; audit logging; and flexible aliases and tags instead of fixed stages. Environments map neatly to catalogs such as dev, staging and prod.
- How it shows up
- Cross-workspace deployment or a lineage requirement points to the Unity Catalog registry.
- Common confusion
- Believing the Unity Catalog registry still has Staging and Production stages.
1.16 Identify scenarios where promoting code is preferred over promoting models and vice versaDeploy code versus deploy models.
- What it means
- There are two promotion patterns. Deploy code moves training code through environments and retrains in each. Deploy models trains once and promotes the model artifact itself.
- What to understand
- Deploy code is Databricks' default recommendation: production data may be readable only in production, retraining is automated, and the code is reviewed and tested. Deploy models fits cases where training is very expensive or one-off, such as fine-tuning a large model, or where production cannot run training jobs. The deciding factors are data access, training cost and retraining frequency.
- How it shows up
- Read the clues about production data access and training cost before picking a pattern.
- Common confusion
- Assuming promoting a finished model is always simpler and so always preferred.
1.17 Set or remove a tag for a modelModel and version tags in Unity Catalog.
- What it means
- Tags are key-value metadata attached to a registered model or to one model version, used for status, ownership or validation results.
- What to understand
- MlflowClient.set_registered_model_tag and delete_registered_model_tag work at model level; set_model_version_tag and delete_model_version_tag act on one version and take its number. A tag such as validation_status=passed can be checked by an automated job before promotion. Tags describe a version; they do not change which version a consumer loads.
- How it shows up
- A question asks which method marks one version as validated without affecting other versions.
- Common confusion
- Using a tag when the need is a movable pointer that loaders resolve, which requires an alias.
1.18 Promote a challenger model to a champion model using aliasesChampion and challenger aliases.
- What it means
- An alias is a named, mutable reference to one model version, such as champion or challenger, loaded with models:/name@alias.
- What to understand
- Register the new version, give it the challenger alias, compare it with the champion, then call MlflowClient.set_registered_model_alias(name, "champion", version) to promote it. Each alias points to one version at a time, so assigning it again moves it. Jobs that load by alias pick up the change on their next run. delete_registered_model_alias removes an alias.
- How it shows up
- Promotion without editing the consuming job's code is the clue for reassigning an alias.
- Common confusion
- Calling transition_model_version_stage, which belongs to the legacy workspace registry.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Databricks Runtime ML
Cluster image with ML libraries preinstalled.
- Remember
- Bundles MLflow, scikit-learn, XGBoost and deep learning frameworks.
- Tested as
- Runtime choice questions.
- Trap
- Assuming the standard runtime has them.
-
AutoML glass box
Every trial produces an editable notebook.
- Remember
- Baseline model plus full source code.
- Tested as
- AutoML advantage questions.
- Trap
- Calling it a black box.
-
FeatureEngineeringClient
Python client for Unity Catalog feature tables.
- Remember
- create_table, write_table, create_training_set, score_batch.
- Tested as
- Feature code questions.
- Trap
- Reaching for the legacy FeatureStoreClient.
-
Primary key
Required on every Unity Catalog feature table.
- Remember
- Non-nullable columns used for lookups.
- Tested as
- Table creation questions.
- Trap
- Omitting it.
-
FeatureLookup
Declares which features to join and on what key.
- Remember
- table_name plus lookup_key.
- Tested as
- Training set questions.
- Trap
- Key names that do not match the label data.
-
fe.log_model
Logs a model with its feature metadata.
- Remember
- Enables automatic lookup in score_batch and serving.
- Tested as
- Scoring questions.
- Trap
- Using a plain flavor log_model.
-
Online store
Low-latency copy of features for serving.
- Remember
- Synced from the offline Delta table.
- Tested as
- Real-time feature questions.
- Trap
- Using it for training.
-
search_runs order_by
Sorts runs by a metric or parameter.
- Remember
- ASC for losses, DESC for scores.
- Tested as
- Best-run questions.
- Trap
- Wrong sort direction.
-
log_artifact
Saves a file to the run.
- Remember
- Plots, reports and sample data.
- Tested as
- Manual logging questions.
- Trap
- Using log_param for files.
-
databricks-uc registry URI
Points MLflow at Unity Catalog.
- Remember
- Model names use three levels.
- Tested as
- Registration questions.
- Trap
- Two-level names.
-
Model alias
Mutable pointer to one version.
- Remember
- Load with models:/name@alias.
- Tested as
- Promotion questions.
- Trap
- Confusing it with a tag or stage.
-
Model version tag
Key-value metadata on a version.
- Remember
- Describes; does not route traffic or loads.
- Tested as
- Tagging questions.
- Trap
- Expecting it to change the loaded version.
-
Deploy code
Promote code and retrain in each environment.
- Remember
- Default Databricks recommendation.
- Tested as
- MLOps questions.
- Trap
- Assuming deploy models always wins.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Tags vs. aliases vs. legacy stages
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Tag | Key-value metadata on a model or version | Describes status; loaders ignore it | Using it to promote a model |
| Alias | Named pointer to exactly one version | Loaded with @alias; reassign to promote | Expecting several versions per alias |
| Stage (legacy) | Fixed Staging or Production labels | Workspace registry only | Using it with Unity Catalog models |
Offline vs. online feature store
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Offline feature table | Delta table in Unity Catalog | History and point-in-time joins for training and batch | Serving real-time traffic from it |
| Online store | Synced low-latency key-value copy | Millisecond lookups for endpoints | Training models from it |
Deploy code vs. deploy models
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Deploy code | Promote training code, retrain per environment | Production data stays in production | Ignoring very high training cost |
| Deploy models | Train once, promote the artifact | Suits expensive or one-off training | Choosing it when prod data is off-limits to dev |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Sort RMSE descending
- What candidates pick
- order_by=["metrics.rmse DESC"] to find the best run.
- Why it looks right
- Best sounds like highest.
- Why it's wrong
- Lower error is better, so ascending order puts the best run first and descending returns the worst.
Clue to watch for The metric is RMSE, MAE or log loss.
-
Stages in Unity Catalog
- What candidates pick
- transition_model_version_stage to Production.
- Why it looks right
- Older tutorials and blog posts use it.
- Why it's wrong
- Models in Unity Catalog have no stages; promotion means assigning an alias such as champion to the chosen version.
Clue to watch for The model name has three levels.
-
Plain flavor logging
- What candidates pick
- mlflow.sklearn.log_model after training on a feature training set.
- Why it looks right
- It is the usual MLflow habit.
- Why it's wrong
- Only fe.log_model with the training_set stores lookup metadata, so score_batch and serving can fetch features themselves.
Clue to watch for Scoring should need only the primary keys.
-
Workspace feature store for sharing
- What candidates pick
- Build features in one workspace's feature store and copy them elsewhere.
- Why it looks right
- Copying feels safe and familiar.
- Why it's wrong
- Unity Catalog feature tables are visible to every attached workspace with central grants and lineage, so copies are unnecessary.
Clue to watch for Several workspaces or a lineage requirement.
-
Tag to promote
- What candidates pick
- Set a tag stage=production on the new version.
- Why it looks right
- Tags look like labels for status.
- Why it's wrong
- Tags only describe a version; jobs load by alias, so only moving the alias changes which version they get.
Clue to watch for The load path ends in @champion.
-
Online store for training
- What candidates pick
- Read training data from the online store.
- Why it looks right
- It holds the freshest values.
- Why it's wrong
- Training needs history and point-in-time joins from the offline Delta table; the online store exists for low-latency key reads.
Clue to watch for The workload is training or batch scoring.
Answer framework
Use these five steps for Section 1 scenarios about AutoML, feature tables, MLflow tracking and the model registry.
- Locate the lifecycle stage in the scenario: environment setup, baseline modelling, feature management, experiment tracking, registration or promotion.
- For environment or library pain, choose Databricks Runtime for Machine Learning; for a fast, reviewable baseline, choose AutoML and its generated trial notebooks.
- For features, use Unity Catalog feature tables with primary keys, build training sets with FeatureLookup, log with fe.log_model, and add an online store only for low-latency serving.
- For experiments, log params, metrics, artifacts and models explicitly where autologging falls short, and query runs with search_runs using the sort direction that suits the metric.
- For lifecycle steps, register with a three-level name, describe versions with tags, move consumers with aliases such as champion, and prefer deploy code unless retraining is too costly.
Practice question
Want more like this? The Databricks ML Assoc practice test has questions for every domain.
Checklist
0 of 15
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this section the most time, because it is the largest and the least guessable from general machine learning knowledge. Work in a real workspace; Databricks Free Edition is enough for most of it. Start with one end-to-end notebook on an ML runtime: run AutoML on a small tabular dataset, open the best trial notebook, and read the data exploration notebook so you can explain what AutoML produced.
Next, build the feature engineering flow yourself. Create a feature table with a primary key, refresh it with write_table, assemble a training set with FeatureLookup, log the model with fe.log_model, and score with score_batch passing only keys. Then practise MLflow by hand: log parameters, metrics, a plot and a model, and query the experiment with search_runs in both sort directions.
Finish with the registry. Register two versions under a three-level name, tag one as validated, assign challenger and champion aliases, and load by alias. Write a one-line answer for when deploy code beats deploy models. Then move on to Section 2, Data Processing.
FAQ
How much of the Databricks ML Associate exam is Databricks Machine Learning?
Databricks Machine Learning is 38% of the exam, the largest of the four sections, or roughly 18 of the 48 scored questions.
Do I need to know the legacy Workspace Feature Store?
Only enough to explain why Unity Catalog feature tables are better: cross-workspace sharing, central permissions, lineage and discovery. The code objectives use Unity Catalog and FeatureEngineeringClient.
Are model stages still tested?
The objectives cover tags and aliases in the Unity Catalog registry. Stages belong to the legacy workspace registry, so treat them mainly as a distractor.
What does fe.log_model do that mlflow.sklearn.log_model does not?
It packages the model with the feature lookup metadata from the training set, so score_batch and Model Serving can fetch features by key without manual joins.
How do I find the best run in code?
Call search_runs on the experiment with an order_by on the metric, ascending for errors such as RMSE and descending for scores such as F1 or AUC, and take the first run's run_id.
Is the exam still current?
Yes. The guide linked from the Databricks certification page is a file labelled August 2026, though its content is dated 1 March 2025. No retirement or replacement had been announced by late October 2026.
Which other sections rely on Databricks Machine Learning?
Experiments from Model Development are tracked here in MLflow, and models registered here are the ones served in Model Deployment.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 1 knowledge
Practise questions on AutoML, Unity Catalog feature tables, MLflow tracking and alias-based promotion under timed conditions before your exam.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the Databricks ML Assoc AI tutor Get any concept explained your way