Databricks Certified Machine Learning Associate Study Guide¶

Independent AI-assisted resource — SOURCES + OBJECTIVES CHECKED; HUMAN REVIEW PENDING. Objective coverage, citations, volatility labels, links, and exam-integrity compliance were checked on October 28, 2026. This is not a guarantee that the guide is error-free or current after that date. See the sources-and-objectives record. The official certification page and its linked exam guide are authoritative.

Study guide at a glance

Start here

Report an issue with DATABRICKS-MACHINE-LEARNING-ASSOCIATE

Blueprint checked2026-10-28

Review stateSources + objectives checked — human review pending

Guide-only active reading30 min–1 hr

Prerequisites: No formal prerequisite; the official guide recommends six months of hands-on experience. Working Python, scikit-learn, Spark ML, statistics, data preparation, Unity Catalog feature/model governance, MLflow, evaluation and batch/stream/real-time inference are practical prerequisites.

Exam essentialsRead the objective map, key distinctions, and readiness checklist.

Deep understandingWork through every domain, including decisions, failure modes, and related items.

Hands-on labsBegin with Hands-on lab sequence, then use the remaining labs to produce evidence you can inspect and explain.

Official objective domains

See the objective map in this guide

The active-reading range uses 90–130 words per minute for technical material. Labs, troubleshooting, note-taking, spaced review, and prerequisite gaps add time; it is not a total preparation promise.

Library identifier: DATABRICKS-MACHINE-LEARNING-ASSOCIATE; Databricks does not publish a short exam code on the official page checked.
Current baseline: Detailed official guide for the live version as of March 1, 2025; live four-domain page checked September 28, 2026.
Upcoming blueprint change: None announced as of September 28, 2026. The detailed PDF is 18 months old and uses earlier names such as Delta Live Tables and workspace model registry comparisons. Translate those terms through current documentation, but do not silently replace the published objective.
Lifecycle status: Active; valid for two years, with the currently live exam required for recertification.
Assessment: Live page: 48 scored multiple-choice questions, 90 minutes, USD 200, no test aids, online or test-center delivery; English, Japanese, Brazilian Portuguese and Korean listed. The older PDF says multiple-choice or multiple-selection and online proctoring only; use the live page for current delivery metadata.
Prerequisite: None required. The official guide highly recommends course attendance and six months of hands-on experience; working Python, scikit-learn, Spark ML, Unity Catalog and basic statistics are practical prerequisites.

Living-guide watch — October 28, 2026¶

Current platform context: The detailed Associate guide remains the March 1, 2025 version. Databricks AI Runtime reached general availability October 21, providing managed GPU training infrastructure governed through Unity Catalog, with MLflow observability and Lakeflow integration. Its availability and supported configurations depend on the account and region; treat it as adjacent ML platform context, not an exam-guide revision. See the current certification page, AI Runtime GA announcement, and October release notes.

How to use this guide¶

Use one reproducible classification or regression project end to end. Preserve business objective, entity/time grain, feature definitions, split strategy, experiment/run IDs, code/data/environment versions, parameters, metrics and slices, registered model/version/alias, deployment contract, inference evidence and cleanup.

decision and metric -> governed labels/features -> leakage-safe split
-> preprocessing pipeline -> baseline -> tuning/CV -> slice evaluation
-> MLflow run -> registered model and alias -> batch/stream/realtime inference
-> monitored outcome and rollback evidence

The live page labels the second domain “ML Workflows,” while the detailed PDF calls its corresponding section “Data Processing.” This guide preserves the live label and maps the detailed data exploration/feature engineering objectives into it.

About related items: A Related item: callout adds prerequisite, architectural, migration, security, operational, or adjacent context that makes an objective easier to understand. It is useful supporting knowledge, not a claim that the item appears verbatim in Databricks' published exam objectives.

Objective map¶

Published domain	Weight	Evidence you should produce
Databricks Machine Learning	38%	MLOps lifecycle, runtime/AutoML decision, governed feature table, MLflow run and Unity Catalog model lifecycle.
ML Workflows	19%	Profile/visualization, outlier and missing-data decision, encoding and transformation without leakage.
Model Development	31%	Algorithm/metric choice, pipeline, imbalance treatment, tuning/CV calculation and bias/variance diagnosis.
Model Deployment	12%	Batch, streaming or real-time serving design with tested schema, scale and release behavior.

1. Databricks Machine Learning (38%)¶

Treat MLOps as a controlled lifecycle¶

An MLOps strategy connects data and feature contracts, reproducible training, experiment tracking, validation, registry governance, deployment, monitoring and retraining/rollback. Separate responsibilities: a notebook can explore; a job reproduces training; MLflow records runs and model artifacts; Unity Catalog governs data/features/models; serving or pipelines execute inference.

Best practices include version-controlled code, immutable or traceable data snapshots, isolated environments, deterministic seeds where possible, automated data/model tests, approval evidence, least-privilege workload identities, observability and an explicit champion rollback. Accuracy alone is not operational readiness.

Choose compute/runtime from dependencies¶

Databricks Runtime for Machine Learning includes tested ML libraries and integrations, reducing setup and compatibility work. A standard or serverless environment may be better where it supports the workload with lower operational overhead. Verify runtime version, CPU/GPU, Python/library compatibility, access mode, Unity Catalog requirements and serving/training differences.

Related item: Preinstalled libraries improve repeatability only when the runtime itself is pinned and recorded. Adding unpinned notebook packages can reintroduce drift.

Use AutoML as transparent acceleration¶

AutoML can inspect data, train/tune candidate models and create reviewable notebooks/results. It accelerates baseline, algorithm and feature exploration; it does not define the business target, prevent leakage, decide the cost of errors, guarantee fairness or approve deployment. Inspect preprocessing, split, trials, primary metric, feature importance/interpretability and generated code.

Use AutoML when its supported problem types and automation fit. Use custom development when the objective, data structure, constraints, algorithm, evaluation or deployment requires control it does not supply.

VERIFY CURRENT — choose a compatible exercise environment: the current AutoML reference says the built-in AutoML library is absent from Runtime 18.0 ML and later. This is a packaging boundary, not a claim that the AutoML service has disappeared. Record the exact runtime and supported entry point before following an older notebook. Classic ML compute uses dedicated access mode for Unity Catalog; check the runtime reference for the workload's dependencies and access support.

Create governed feature tables¶

Unity Catalog feature engineering uses governed Delta tables with primary keys (and timestamp keys for time series) plus feature metadata. Create/write features through supported DataFrame/SQL/Feature Engineering APIs, then use feature lookups during training so lineage and definitions travel with the model. The current feature engineering documentation controls APIs and prerequisites.

Offline feature table	Online feature table
Historical governed features for training and batch scoring	Low-latency published feature values for real-time serving
Supports point-in-time historical joins where configured	Optimized for key lookup and freshness, not training history
Source of record usually remains Delta/Unity Catalog	Synchronized derivative with publication/TTL/freshness concerns

Feature keys must represent an entity at a defined time. Split training/validation by time or entity before fitting imputers/encoders when leakage is possible. For online serving, require training-serving feature parity, key availability, default/missing behavior and freshness SLO.

Use FeatureEngineeringClient.create_table to declare a qualified table name and primary keys, and write_table to write feature rows; verify the mode and schema before a merge. An existing qualifying Unity Catalog Delta table can also be used. A primary-key declaration is informational: it does not reject duplicate keys. Enforce and measure uniqueness in the feature pipeline. See table constraints.

Point-in-time joins match an entity to the latest eligible historical feature row at its observation time; configure the timestamp key and timestamp_lookup_key. They differ from querying a Delta table version. For example, with feature observations at 09:00 and 11:00, a 10:00 prediction must not use the 11:00 value. Check missing-history and staleness behavior. Related item: a late-arriving record can have an old event timestamp; retain availability evidence if the experiment must reconstruct what the serving system actually knew.

Track experiments with MLflow¶

An MLflow tracking run records parameters, metrics, tags, artifacts, source/environment and a model. Manual logging is appropriate when autologging misses a business metric or custom artifact. Use the MLflow client/search API to compare runs by a declared primary metric and constraints; “best” is contextual, not simply the largest number.

The UI exposes runs, parameters, metrics over steps, artifacts, models, tags and comparison. Log data version/table, split seed/period, code revision, dependency/environment, signature/input example and slice metrics. Avoid logging secrets or unrestricted sensitive samples.

Govern models in Unity Catalog¶

The Unity Catalog model registry uses three-level model names, governed privileges, lineage, tags, versions and aliases. Register a model through a supported MLflow API; then test and assign an alias such as Champion to a validated version. An alias is a mutable pointer, not a copy or immutable approval record.

Promote code across environments when retraining should occur from environment-owned data/configuration. Promote a model artifact/version when the exact validated artifact must move or be referenced consistently. In many current Unity Catalog designs, share governed data/model access and deploy the same tested code rather than copying opaque artifacts between isolated registries.

Keep model lookup and deployment separate. A batch job that loads models:/catalog.schema.model@Champion resolves the alias when it loads; an already loaded object does not continuously refresh. For a serving endpoint, resolve the approved alias to a version and update the endpoint configuration, then verify readiness and traffic before calling the rollout complete. Moving an alias alone does not enact that endpoint change. New Unity Catalog model versions require signatures; capture input/output schema and the resolved version in release evidence. See the registry lifecycle reference.

The older PDF contrasts Unity Catalog with the legacy workspace model registry. Current new designs should use Unity Catalog unless a documented compatibility constraint applies. Tags carry metadata; aliases support deployment references; neither grants data access.

2. ML workflows: data processing and feature engineering (19%)¶

Profile distributions before choosing a repair¶

Use Spark DataFrame summary()/describe(), null/distinct counts, quantiles and Databricks data-profile summaries to inspect count, center, spread, extrema and missingness. Stratify by label, time and important groups; an overall average can hide drift or harm.

Choose visualizations by variable types:

Comparison	Useful methods	What to check
Continuous distribution	histogram, box plot, density/quantiles	skew, tails, outliers, clipping
Categorical distribution	bar/count proportions	rare levels, cardinality, missing/unknown
Continuous vs continuous	scatter/correlation, colored by split/label	nonlinearity, clusters, leakage, scale
Categorical vs categorical	contingency table/stacked proportions	association, sparse cells, imbalance
Continuous by category	box/violin/summary table	group spread, sample size and instability

Correlation is not causation, and a high correlation with the label may indicate leakage.

Handle outliers from domain and model behavior¶

Standard-deviation rules assume a roughly symmetric distribution and are sensitive to extreme values. IQR fences are more robust for skewed data. A value can be rare but valid; removing it changes the target population. Compare cap/winsorize, transform, robust model/scale, domain validation and quarantine. Fit any threshold on training data and apply it unchanged to validation/test.

Impute with a pipeline¶

Mean is sensitive to skew/outliers and suits roughly symmetric numeric features.
Median is robust for skewed numeric features.
Mode fits categorical or discrete features but can amplify the majority category.
Constant/unknown categories preserve missingness semantics where missing has meaning.
Add a missing-indicator when absence itself may be informative, while checking leakage.

Never compute imputation from the full dataset before splitting. Put the imputer in a scikit-learn or Spark ML pipeline so each cross-validation fold fits preprocessing only on its training portion.

Encode and transform deliberately¶

One-hot encoding suits unordered categories with manageable cardinality for models that need numeric features. It is usually unnecessary for tree implementations with native categorical handling and unsuitable for unbounded identifiers. Handle unknown categories at inference and avoid dummy-variable redundancy where the estimator requires it.

A log transform can reduce positive right skew, stabilize multiplicative relationships and make some models/residuals better behaved. Zero/negative values require a defined alternative such as log1p where appropriate. If the target is log-transformed, convert predictions back before interpreting them, and calculate business-scale metrics carefully because exponentiation introduces bias and changes error meaning.

Related item: Feature engineering must be fitted inside the training fold. Leakage can produce excellent validation scores and a useless deployed model.

3. Model development (31%)¶

Start from target, data and error costs¶

Classification predicts categories/probabilities; regression predicts a continuous target; clustering discovers groups without labels. Select an algorithm from sample size, linearity/nonlinearity, sparsity, interpretability, latency, missing/categorical behavior and distributed versus single-node scale—not brand popularity.

Linear/logistic models offer interpretable baselines; trees and ensembles capture nonlinearities/interactions; Spark ML pipelines scale distributed feature transforms/training for supported algorithms; scikit-learn is often productive for single-node data that fits memory. Always establish a simple baseline.

Understand estimators, transformers and pipelines¶

An estimator learns from data and produces a model/transformer. A transformer applies transform() to produce new columns/predictions. A pipeline orders stages so preprocessing and training are fitted consistently. In Spark ML, StringIndexer and OneHotEncoder learn state as estimators; their fitted model objects transform data. VectorAssembler transforms columns without fitting. The classifier/regressor is an estimator. The upstream encoder model reference shows the fitted model's Transformer inheritance.

Mitigate class imbalance¶

Accuracy can hide minority failure. Use stratified splits, class/sample weights, cost-sensitive learning, threshold tuning, suitable metrics, or carefully applied under/oversampling. Fit resampling within the training fold only. Synthetic examples can distort sparse or categorical spaces; evaluate precision/recall and calibration on the untouched natural distribution.

Tune without multiplying work blindly¶

Grid search evaluates every parameter combination; random search samples combinations and often explores more values efficiently; Bayesian approaches such as Hyperopt use prior trial results to choose promising configurations. The 2025 objective explicitly names Hyperopt fmin; use the Hyperopt documentation for current support/deprecation context before practice.

CURRENT BLUEPRINT / VERIFY CURRENT: retain Hyperopt fmin because it remains in the published objective. Databricks documents that Hyperopt is no longer maintained upstream and is not included after Runtime 16.4 LTS ML; it recommends Optuna or Ray Tune for current work. Do not silently rewrite the exam objective to those replacements.

For reading legacy code, Hyperopt's objective contract minimizes a scalar loss (or a result dictionary with loss/status). Identify the objective, search space, search algorithm, trial budget and trial history. To maximize validation F1, minimize its negative; a positive F1 loss would select in the wrong direction. Fit preprocessing inside each training fold. hp.choice can return an encoded choice index in the best assignment; decode with space_eval before treating it as an estimator parameter. No Hyperopt workload was executed in this review.

If a grid has a choices, b choices and k cross-validation folds, it fits a × b × k fold models, commonly plus a final refit depending on framework settings. Parallelizing single-node models can reduce wall time but multiplies CPU/memory and experiment runs. Avoid nested Spark oversubscription: distribute trials or each model deliberately.

Cross-validation estimates performance across multiple folds and uses data efficiently, but costs more and can still leak if folds ignore time/group structure. A train/validation/test split is cheaper and clearer for large data. For time series, use chronological validation; for repeated entities, group them to prevent identity leakage.

Run a small local training and tuning check¶

This synthetic exercise tests preprocessing and search mechanics. It is too small to estimate business performance. It uses NumPy and scikit-learn; it does not connect to Databricks. Keep the test-like query rows outside fitting, following the upstream leakage guidance.

import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

train_x = np.array([[1.0], [2.0], [3.0], [4.0], [6.0], [7.0], [8.0], [np.nan]])
train_y = np.array([0, 0, 0, 0, 1, 1, 1, 1])
query_x = np.array([[1000.0], [np.nan]])
pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scale", StandardScaler()),
    ("classifier", LogisticRegression(max_iter=300, random_state=7)),
])
pipeline.fit(train_x, train_y)
assert pipeline.named_steps["imputer"].statistics_[0] == 4.0
probabilities = pipeline.predict_proba(query_x)
assert pipeline.named_steps["imputer"].statistics_[0] == 4.0
search = GridSearchCV(
    pipeline,
    {"classifier__C": [0.2, 2.0], "imputer__strategy": ["mean", "median"]},
    scoring="f1", cv=StratifiedKFold(n_splits=2, shuffle=True, random_state=7),
    refit=True, n_jobs=1, error_score="raise",
)
search.fit(train_x, train_y)
assert len(search.cv_results_["params"]) == 4

There are four candidate configurations and two folds: eight validation fits, followed by one best-estimator refit. The earlier demonstration pipeline.fit is a separate fit, outside that search count. A fresh pipeline is fitted within each fold, so validation rows do not determine its imputer or scaler. The GridSearchCV reference defines refit and scoring behavior. Change the extreme query value and confirm the original median stays fixed; then test an incorrect full-data fit to expose leakage.

Choose metrics from the decision¶

Task/metric	Meaning and boundary
Precision	Of predicted positives, fraction correct; important when false positives cost more.
Recall	Of actual positives, fraction found; important when misses cost more.
F1	Harmonic mean of precision/recall at a threshold; hides probability calibration and true-negative value.
ROC AUC	Ranking over thresholds; can look optimistic with severe imbalance.
Log loss	Penalizes wrong confident probabilities; needs calibrated probability reasoning.
RMSE	Square-root mean squared error; emphasizes large errors.
MAE	Mean absolute error; robust and directly interpretable in target units.
R²	Variance explained relative to a mean baseline; not an absolute error unit and can be negative.

Evaluate the primary metric plus operational constraints and group/time slices. Choose a threshold using validation data, then report once on an untouched test set.

Diagnose bias and variance¶

High bias/underfitting: training and validation performance both poor—add signal, improve representation or model capacity. High variance/overfitting: training strong, validation materially worse—simplify, regularize, add representative data, reduce leakage or tune. Learning curves and fold variance strengthen the diagnosis. More complexity is not automatically better.

Related item: Statistical performance, fairness, explainability, robustness and serving cost are separate acceptance dimensions. A champion requires an explicit multi-dimensional gate.

4. Model deployment (12%)¶

Select an inference mode from the service contract¶

Mode	Strong fit	Key design evidence
Batch inference	periodic scoring of many records	input snapshot, model alias/version, output idempotency, schedule and reconciliation
Streaming inference	continuous events through a stateful pipeline	checkpoint, watermark/state, model loading, throughput/backpressure and replay
Real-time serving	request/response low-latency decisions	endpoint schema, authentication, concurrency, scale-to-zero/cold start, timeout and fallback

For batch scoring, load the model once per partition/batch where possible; a Pandas UDF can vectorize scoring. Do not call a real-time endpoint row by row from a high-volume Spark transformation when local/distributed artifact scoring fits.

Current model serving deploys supported Unity Catalog/MLflow models to endpoints. Define signature and input example, workload size/scaling, identity, network, secrets, traffic configuration and inference table/monitoring needs. Query with the expected records/DataFrame/tensor format and handle errors/timeouts.

Traffic splitting routes proportions between served model versions for canary/A/B behavior. It is not randomization proof by itself: record assignment, exposure, outcome, sample size, rollback threshold and version. Pin a version for reproducibility; use aliases for controlled release references.

For streaming inference, the PDF says Delta Live Tables; the current name is Lakeflow Spark Declarative Pipelines. Apply a locally loaded model/UDF in the stream where supported, manage checkpoints and autoscaling, and avoid high-latency external calls per event. Review batch and streaming inference for current patterns.

VERIFY CURRENT: serving endpoint types, scale behavior, traffic configuration, online feature stores, inference tables, AI Gateway and monitoring capabilities change quickly. Recheck them in the target cloud/region.

Integrated decision scenarios¶

Scenario A — churn model with governed features¶

Define churn horizon, prediction time and cost of misses/false outreach. Create Unity Catalog feature tables with point-in-time keys, split by time/customer, fit imputation/encoding inside folds and mitigate imbalance with weights/threshold rather than contaminating validation. Log run/data/code/slice metrics, register in Unity Catalog and assign Champion only after approval. Batch score customers and reconcile entity/version/output counts.

Scenario B — real-time fraud canary¶

Use online features only where latency/freshness justify them and prove training-serving parity. Train a probability model with log loss, precision/recall at an operating threshold and segment slices. Deploy a signed/versioned model endpoint, split limited traffic to a challenger, authenticate clients, monitor latency/error/drift/outcomes and roll back the endpoint version/traffic based on a predetermined threshold. Keep registry aliases aligned with the approved release, but verify the endpoint update separately.

Scenario C — streaming engagement anomaly detection¶

Use a Lakeflow/Structured Streaming pipeline with a ten-minute event-time window, watermark/checkpoint and a locally distributed model artifact. Test late/duplicate events and throughput/backpressure. Avoid per-row endpoint calls. Track the model/run/version used for each prediction, quarantine invalid features and make replay idempotent.

Worked decisions and answered checks¶

The following original cases are learning exercises, not exam items.

Evidence	Decision
Feature values 12 at 09:00 and 90 at 11:00; prediction time 10:00	Use 12 in the point-in-time example. Verify availability and permitted lookback; the current latest value leaks future information.
Training median 4; held-out value 1000	Transform the held-out record with the fitted training pipeline. Recomputing preprocessing on combined data contaminates the experiment.
TP=18, FP=6, FN=12, TN=64	Precision is 0.75, recall 0.60 and F1 about 0.667. Accuracy is 0.82 but misses 40% of actual positives. Choose the operating threshold from error costs and validation evidence.
Registry Champion changes from version 4 to 5 while endpoint serves version 4	Verify or perform an endpoint configuration update; the registry change alone does not prove served traffic moved.

Is a declared primary key a duplicate-row rejection rule? No; build a uniqueness check in the feature pipeline.
Does a Delta historical version implement every row's observation-time lookup? No; feature-time selection and table-version selection solve different problems.
Does selecting an ML runtime guarantee classic AutoML is preinstalled? No; check the runtime packaging boundary and supported entry point.
Should Hyperopt vanish from exam preparation? No; preserve the published scope and explain its runtime/support limits.
Why negate F1 in a Hyperopt loss? The optimizer minimizes; higher F1 must correspond to lower loss.
Which data fits preprocessing during cross-validation? Only the training fold, with the fitted transform applied to its validation fold.
Does an encoded hp.choice result always equal the chosen value? No; decode the search-space assignment.
Are model tags authorization grants? No; use the registry's governed privileges.
Does changing an alias mutate a model already loaded in memory? No; record the version resolved at load and deliberately reload or deploy.
Which scale should business error metrics use after log-target training? The original target scale, after the appropriate inverse transform; for log1p, use expm1. Re-transforming an average is not generally averaging re-transformed predictions. See upstream metric definitions.

Local execution boundary — September 28, 2026: the scikit-learn example and additional leakage, metric, refit-count and categorical checks were executed in an isolated local environment. No Spark, Hyperopt, MLflow service, Unity Catalog, AutoML, online feature store or serving endpoint was run. The eight workspace labs remain proposed.

Hands-on lab sequence¶

Profile and split: Build label/time/entity-aware train/validation/test data; profile missingness, skew, outliers and imbalance by split/group and document leakage risks.
Preprocessing pipeline: Implement median/mode imputation, unknown-category handling, one-hot/log transforms and a reproducible scikit-learn or Spark ML pipeline; prove validation data did not fit preprocessing.
Feature table: Create a governed feature table with primary/time keys, write features and train through feature lookup; demonstrate point-in-time behavior and lineage.
MLflow experiment: Train baseline plus candidates, log parameters/metrics/slices/artifacts/signature/environment, search for candidates and explain why the selected run is “best.”
Tuning and evaluation: Compare grid/random/Bayesian search, calculate expected fits, run leakage-safe CV and tune a decision threshold against business error costs.
Registry lifecycle: Register the validated model in Unity Catalog; apply tags and a Champion alias with a written approval/rollback record; test privileges.
Batch and stream: Score a batch through a vectorized pattern and a bounded stream through a pipeline/UDF; record versions, checkpoint and reconciliation.
Real-time canary: Deploy/query a test endpoint, validate schema/auth/error behavior, split test traffic between versions and execute rollback/cleanup.

Readiness checks¶

Databricks ML and workflows¶

Development and deployment¶

Places to learn¶

This is not a complete list, and it is not meant to be consumed in full. Choose a primary path, then spend at least equal time producing and testing feature, experiment, registry and deployment evidence. Public resource availability was checked September 28, 2026; runtimes are editorial planning estimates. Signed-in Academy and paid lessons were not inspected. Udemy access was blocked and Whizlabs returned no usable body.

Resource	Access	Estimated time
Official certification page and March 1, 2025 exam guide	Free	1–2 hours; map every objective and inspect vendor sample format without redistributing questions
Databricks Academy — Machine Learning with Databricks and four named self-paced courses	Free account/customer or partner entitlement varies	20–35 hours with labs; verify catalog and current terminology after sign-in
Databricks Free Edition or authorized workspace	Free/organizational	18–30 hours for eight labs; serving/online-feature capabilities may require another environment
Databricks machine learning documentation	Free	8–14 hours selected reading and reproduction
MLflow documentation	Free	4–8 hours selected tracking, model and deployment practice; reconcile OSS and managed Databricks behavior
Ben Mackenzie, Databricks: MLOps Gym feature-store explanation (April 29, 2024)	Free employee technical blog	About 45–75 minutes for reading and an entity/time/label worksheet; estimate includes the worksheet. Useful concepts, but older code needs current API/name checks; the article even mixes client variable names.
Databricks YouTube	Free	3–6 hours selected current MLflow, feature engineering, MLOps and serving sessions
Whizlabs: Databricks Machine Learning Associate	Paid; training/practice product	Stable public totals were not exposed; budget 6–14 hours and verify March 2025 coverage after sign-in
Udemy search: Databricks Machine Learning Associate	Paid marketplace	8–20 hours only after selecting a current, lab-based course; reject dump-focused listings

The 2025 blueprint is still live but aged: explicitly gap-check current Unity Catalog model/feature APIs, Lakeflow naming, Hyperopt support and serving behavior. No exact current Pluralsight, O'Reilly, LinkedIn Learning or MeasureUp product was independently verified.