Skip to content

For Heads of data whose best model is still in a notebook

Machine learning

Your data scientist found something that works, and it's still running from a notebook on one laptop because the team is busy keeping the pipelines alive. We start with that one model and take it to a monitored endpoint on Databricks, usually in two to six weeks, with a gate that blocks a worse version from going live.

We write the retraining schedule and the rollback path before launch, and we work alongside your data scientists rather than replacing them. Tell us which model it is and a senior engineer will say what getting it served would take, including when a rule would do the job better than a model.

13 common questions, answered below ↓

Models fail on deployment, not accuracy

Models that reach an endpoint, get retrained on a schedule, and can be rolled back by somebody who was not there.

A model that never ships usually failed on deployment rather than on accuracy. The features were computed in a notebook that runs on one laptop, the training set can't be reproduced six months later, and nothing downstream notices when the data underneath shifts. The Databricks path out of that is well worn by now.

Feature tables in Unity Catalog so training and serving read one definition, MLflow tracking the experiments, every version registered in Unity Catalog, Model Serving behind an endpoint, and data profiling reading the inference table for drift instead of waiting for the business to notice the outputs. We do the unglamorous half of that.

The retraining job that runs on a Lakeflow Jobs schedule, the evaluation gate that stops a worse model reaching production, and a rollback path written down before anybody needs it at two in the morning. Sometimes the honest recommendation is a rule rather than a model, and we'll say so when it is.

  • Features registered once, so the training set and the live request read the same definition
  • MLflow experiments and a registry, so which model is serving is a lookup rather than an argument
  • Evaluation gates on promotion, so a worse model is blocked instead of discussed
  • Drift watched on the inference table, with a threshold and an owner rather than a dashboard nobody opens
  • A retraining schedule and a rollback path, both written down before launch

How an engagement works

01

Talk to an engineer

A real conversation about your initiative with a senior engineer who has built this before. Not a sales call. What you are trying to build, what has been tried, and what is realistic.

02

Discovery and scoping

Two to three weeks to clarify requirements, evaluate where AI fits, and define realistic scope. On AI work this is also where success gets defined precisely enough to score, because a goal nobody can measure cannot be hillclimbed. You get a plan you can act on before committing to a larger engagement.

03

The right team, daily demos

We put the team the work actually needs on it and show you running software every day. Built with the same rigor as any enterprise system: tested, monitored, documented.

04

Production and beyond

Deployed and running under real load, handling real business processes. Ongoing support and team continuity for whatever comes next.

From a notebook to a monitored endpoint

Features live in Unity Catalog. Any Delta table with a primary key can be a feature table, and a timeseries column on that key is what lets a training set be rebuilt as it stood on a given date: each label row looks up the feature values as of its own timestamp, so the model never trains on what happened afterwards.

That holds as long as nobody rewrites the feature table's history, which is why we also save the training set when an audit depends on it.

Log the model with the feature engineering client and the endpoint looks those features up for itself at request time, from the Online Feature Store, so the caller sends a customer ID rather than forty values.

Every training run lands in MLflow, and since MLflow 3 the evaluation metrics follow the model onto its version page in Unity Catalog, so comparing a candidate with the live one doesn't mean digging through runs.

Registered versions live in Unity Catalog, and an alias such as @champion marks the live one. A deployment job, in Public Preview as of this writing, can run the evaluation, wait for someone with permission to approve, and deploy to Model Serving each time a new version is registered.

The endpoint writes each request and response to an inference table as JSON. Features the endpoint looked up for itself only appear there if ENABLE_FEATURE_TRACING is set on the endpoint, so we set it at launch. A scheduled job unpacks the logs into a table with the prediction, the model version and the feature columns.

A data profiling monitor, which Databricks called Lakehouse Monitoring, reads that table with an inference profile and writes profile and drift metrics per time window. Once there are a few weeks of history, a job triggered when the drift table updates can check the threshold and start retraining, instead of a date on a calendar.

The same path on Databricks with the code written out, from the feature lookup to the alias, is on Databricks MLOps.

beats the live one

drift past threshold

Feature tables
in Unity Catalog

Training set
point-in-time lookup

MLflow run, version
in Unity Catalog

Evaluation
gate

Model Serving
endpoint

Inference table,
unpacked and profiled

Lakeflow Job
retrains

A schedule,
at first

A model's path from feature table to monitored endpoint on Databricks, and the loop that retrains it: on a schedule at first, on drift once there's history. The evaluation gate is where a worse model stops.

Checked on 12 October 2026 against MLflow 3, deployment jobs, models in Unity Catalog, feature tables in Unity Catalog, point-in-time feature joins, automatic feature lookup, the Online Feature Store, inference tables on serving endpoints, logging looked-up features, data profiling and Lakeflow Jobs triggers.

Where a machine learning engagement starts

  1. 01

    One model, end to end

    We pick one model with you and take it from wherever it is to a monitored endpoint, usually in two to six weeks depending on how the features were built. You keep the feature tables, the registered model, the endpoint, the monitor and a written record of each decision.

  2. 02

    MLOps for the models you already run

    For a team with several models and no common path to production. Feature tables in Unity Catalog, every model registered there with a live alias, an evaluation gate before promotion, an inference table and a monitor on each endpoint, and a retraining job per model that somebody other than its author can run.

  3. 03

    A platform check first

    When the models are fine and the estate under them isn't, the two-week Databricks Health Check reads it first, Model Serving spend included, and ends in a written scorecard whether or not you go on.

  4. 04

    Engineers beside your data scientists

    Our ML engineers pair with your data scientists on the features, the pipeline and the endpoint, and leave the modelling judgement where the domain knowledge is. A team with a lead, or individuals under your own, as forward-deployed teams describes.

Before a model ships

We start with these. A no on any of them is usually where the work is.

Questions for the model you're about to ship

  • Can you rebuild the exact training set the live model learned from, as it stood on the day it was trained?
  • Do training and serving read features from the same table, or does the endpoint carry its own copy of the logic?
  • Is the live version marked with an alias in Unity Catalog?
  • Does the endpoint write an inference table, and does a monitor read the unpacked version of it?
  • When drift crosses its threshold, who's told, and what are they expected to do that day?
  • Can somebody other than the model's author retrain it, and read why the new version passed?

FAQ

Machine learning, answered

What do your machine learning consulting services include?

Building models where one is needed and, more often, productionising the one you already have.

Feature engineering in Unity Catalog feature tables, MLflow for experiments, models registered in Unity Catalog, a Model Serving endpoint, an evaluation gate that has to pass before a new version is promoted, drift monitoring on the inference table, and the retraining job on a Lakeflow Jobs schedule. Eighty of our engineers are Databricks-certified, and the pipelines underneath are at /services/data-engineering.

Our model works in a notebook. What does it take to serve it?

Less than teams expect on the serving itself and more than they expect on everything around it. The endpoint is straightforward.

Reproducing the training set, moving feature computation somewhere that runs without one person's laptop, and deciding what happens when the model degrades are where the work actually is. That's usually two to six weeks depending on how the features were built.

How do you decide when to retrain?

On a schedule to begin with, because it's honest and it's cheap, then on a drift signal once there's enough production history to know what normal looks like.

Retraining on drift before you can characterise drift produces a model that chases noise. A data profiling monitor with an inference profile computes drift on the inputs and predictions window by window, against a baseline table you choose.

Do you build models, or productionise the ones we have?

Both, and the second is more common. Most teams we meet have a data scientist who has already found something that works and no path from there to an endpoint anyone will depend on.

Where a model does need building, our engineers work alongside your data scientists rather than replacing them, because the domain knowledge that makes a feature useful is already in your building.

When would you tell us not to use machine learning?

When a rule does the job. A threshold somebody can explain beats a model nobody can, if the threshold catches the cases that matter. We've replaced planned models with three lines of SQL more than once, and the client kept the budget.

A model earns its place when the pattern is real, the data to learn it exists, and the cost of being wrong is one you can measure.

What is MLOps, and do we need it?

MLOps is the discipline of shipping and running models the way software is shipped and run. Versioned features, tracked experiments, a registry that says which model is live, a gate before promotion, monitoring after it, and a rollback.

You need it the moment a model's output feeds a decision somebody is accountable for. Before that, a notebook is fine, and we'll say so.

Can you do predictive analytics on our existing data warehouse?

Yes, and the first question is whether the data has to move. Lakehouse Federation reads Snowflake, SQL Server, Synapse and others in place, which is enough for a first model.

If the model goes to production, the features usually want to live on Delta next to the serving endpoint, and that's the point at which the migration conversation at /services/databricks starts.

How is this different from your AI systems work?

This page is models that predict, score or classify, and reach an endpoint. Agents and applications built on language models, with retrieval, tools and a governance boundary, are at /services/ai-systems. The two share the platform, MLflow and Unity Gateway among them, and often share an engagement, but the failure modes are different and so is the evaluation.

Can we hire your machine learning engineers as a team?

Yes, that's the forward-deployed model at /services/forward-deployed. A working team with a lead who owns the outcome, in your workspace and your repository, or individual engineers under your own lead if that's the shape of the work. Ask for the certification count of any partner you talk to, because it's checkable and a tier isn't.

How does an engagement start?

With one model, end to end, because a proof of concept that never serves a request teaches nobody anything. We pick it with you, take it from wherever it is to a monitored endpoint, and write down what was decided and why. If the estate itself is the question, the two-week Databricks Health Check at /databricks/health-check comes first.

Are you a machine learning development company or a consultancy?

Both. We build models where one is needed, and more often we build what it takes to run one, from the feature tables and the training job to the endpoint, the monitor and the retraining schedule.

The engineers who scope it write the code and stay on it through go-live, so the advice and the delivery come from the same people.

Should features go in the workspace Feature Store or in Unity Catalog?

Unity Catalog. Any Delta table there with a primary key can be a feature table, and the workspace Feature Store is deprecated, available only to workspaces created before 19 August 2024.

We put new features in Unity Catalog and move old ones when their model next retrains, so lineage runs from the source table to the endpoint. For low-latency serving, the Online Feature Store, built on Lakebase, holds the latest values for the endpoint to read.

How do you roll a model back?

Every version stays registered in Unity Catalog, and an alias such as champion records which one is live, because models in Unity Catalog have no stages. Rolling back is pointing the endpoint and the alias at the previous version. We write that step into the runbook before launch, so whoever is on call can do it without the model's author.