What ran by hand,
now runs as a job
We set up and look after Databricks workspaces, with every table in one catalog, the notebooks that matter turned into tested jobs, and each job on a supported runtime, so every job can be reviewed, tested and run again.
Thanks, we’ll be in touch soon.
{{ heroStatus }}
You’re in good company
A few of the companies we’ve worked with.
When the work that matters lives in notebooks
Databricks is a platform for data and AI work that sits on the storage and security of the cloud account you already have. An account holds workspaces, where teams write notebooks and jobs and start the compute that runs them, and Unity Catalog holds the tables, each under a three-part name: its catalog, its schema and the table itself.
Notebooks are where much of that work begins: code written and run a cell at a time, with its results beside it, often to explore the data and try an idea.
A notebook that becomes important often keeps running the way it started: opened and run by hand, on compute left on between runs, with its code in no repository and no tests around it. Its tables may still sit in the workspace’s built-in legacy metastore, with access set workspace by workspace.
The platform has what that work needs: Git folders that keep code in a repository, and jobs that run it on a schedule once it’s been reviewed. So the real work is turning the notebooks that matter into reviewed jobs, reading tables kept in one catalog, each table with an owner.
What we build
Workspaces set up the same way for each stage, every table brought into one catalog, and the work that matters run as jobs you can review.
Workspaces set up for how you work
People and groups managed once, at the account, a workspace for each stage, each attached to the one catalog, and all of it defined in code.
Moved from the platform you have now
Jobs and tables brought over from an older platform a few at a time, each kept running on the old one until the new one gives the same results.
Every table in one catalog
Tables and views upgraded out of the legacy metastore, file mounts replaced, and groups moved to the account, one workspace at a time.
Notebooks turned into jobs
The notebooks that matter moved into a repository, reviewed, tested in CI, and deployed from there to run as scheduled jobs.
Data checked as it loads
Rules on each pipeline for a record that fails a check: kept and counted, dropped, or the update stopped, whichever the table calls for.
Grants at the level that fits
Grants made to groups, on the catalog, the schema or the table a team’s work needs, with row filters and column masks where a team should see less.
Runtimes kept supported
Each job on a supported long-term support runtime, tried on the newer one first, and moved ahead of its end of support.
Compute that fits its work
Scheduled jobs on compute that starts for the run and ends with it, notebooks on compute that stops when idle, policies on what each team may start, and tags that show which team used what.
AI where it helps
AI functions called in SQL where they answer a real question, with access to the models they call granted in the catalog, as for tables. Models in production go to MLOps.
- Pipelines and reporting across tools:Data Engineering
- Machine learning in production:Data Platforms & MLOps
- A security review of what you run:Application Security
- Engineers in your own team:Engineers for your team
Granted once, at the level that fits
Every table in the catalog has a three-part name: its catalog, its schema and the table itself. A grant made on a catalog or a schema reaches everything in it, the tables there now and the ones added later.
Reading a table also takes the right to use its catalog and its schema. A grant on the table alone isn’t enough.
So a team granted table by table can’t read the next table until someone grants that one too, and a team granted a whole catalog may read more than its work needs.
So we set grants with you at the level each team’s work fits, to groups rather than to people, and look at them again as new schemas arrive.
Tick a box to grant reading at that level. A tick above covers everything beneath it.
{{ catSay }}
Runtimes with an end date, moved ahead of it
Every job runs on a version of the runtime, and each version includes a version of Apache Spark™, the engine that runs the work. Databricks releases each runtime first as a beta for early evaluation, then as generally available while features are still being added to it, then in long-term support for a set period, with the date its support ends published ahead. After that date its support ends, and later the version is removed.
Once its support has ended, a job on it can keep running, with no support or fixes, and the version can’t be chosen for new compute. Once it’s removed, jobs still set to it fail.
Some older features are deprecated too: governance through the legacy metastore, and files kept in a workspace’s root storage and its mounts. Since October 8, 2026, new workspaces in every account come without them, and the docs recommend Unity Catalog, its volumes and its external locations in their place. Serverless compute, where it’s offered, runs on versions Databricks manages.
So we keep a list of each job’s runtime and the date its support ends, move each job to a supported long-term support runtime ahead of that date, tried on a copy first, and move tables and mounts off the deprecated features one workspace at a time.
Start with what runs, and where it reads from
The review covers the account and its workspaces, and whether people and groups are managed at the account; which workspaces use Unity Catalog, and which tables still sit in the legacy metastore; file mounts, and files kept in a workspace’s root storage; the runtime each job and each cluster uses, and when its support ends; the notebooks that run real work, and whether their code is in a repository; jobs, the compute each runs on, when it stops and the policies on it; SQL warehouses and serverless use; who holds admin rights, and how services sign in; grants, to groups or to people, and at which level; the checks in each pipeline; lineage and audit, from the system tables; and costs by team, from the billing tables and tags.
The first step is one of these, each tried on a copy or in a test workspace first: one workspace’s tables upgraded into the catalog; one notebook that matters turned into a reviewed, scheduled job; the jobs on the oldest runtime moved to a supported long-term support one; auto-termination and a compute policy for one team, with tags for its costs; or grants for one schema moved from people to a group, at the level the work fits.
What you receive is a written review and a proposal for that first step.
Questions worth asking
When does this platform make sense?
When several teams work on large amounts of the same data, for pipelines, analysis and machine learning, in the cloud account they already have. If the data is small and the reports are few, a simpler database is often enough, and we’ll tell you.
We inherited workspaces no one fully knows. Where do you start?
By reading what’s there before changing anything: the review above comes first, then the first step it proposes, tried in a test workspace before anything else follows.
Do we have to move off the legacy metastore?
Governance through it is deprecated, and Databricks recommends moving all data from it to Unity Catalog, while turning Unity Catalog on doesn’t stop the old tables working. We move them table by table, with each job pointed at the new names before the old ones are retired.
What happens when our runtime reaches its end?
Its support ends first, then the version is removed, as the section above describes. We keep a list of each job’s runtime and that date, and move each job to a supported runtime well before it, tried on a copy first.
What happens to the notebooks we use now?
The ones that run real work become reviewed jobs, kept in a repository. The rest stay as they are, for exploring.
Where does our compute spend go?
Tags by team and the billing tables show where it goes. From there, scheduled jobs run on compute that starts for the run and ends with it, and compute for notebooks stops when it’s idle.
Can AI assistants help with our jobs and queries?
Yes, as help for the people who write them: an assistant can draft and explain code, and each change is still reviewed before it runs. AI functions in SQL reach their models through the same grants as tables.
What does it cost to work with you?
That depends on the workspace and the first step you choose. Before any work starts, you get a written proposal with the scope, the price or rate, and how you pay.
Can we hire engineers for our own team?
Yes. Within 48 hours of your request, we introduce engineers for Databricks workspaces, in your time zone, and you meet them before choosing who joins.
Databricks is a trademark of Databricks, Inc., and Unity Catalog and Databricks Runtime are its products. Apache Spark, Spark, Apache and the Spark logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries. Webair is independent of Databricks, Inc. and The Apache Software Foundation, and isn’t sponsored by, endorsed by or affiliated with either.
Let’s build it better
Tell us which notebooks your teams still run by hand, and where their tables live, and we’ll suggest where to begin, in a short call.
Thanks, we’ll be in touch soon.
{{ ctaStatus }}