The calculation method.
For every figure, YALineo shows where it comes from. Here is the full method, formula by formula, with the official Databricks and Microsoft sources it rests on. The extension's "How it is calculated" links lead here.
Observed
Read from the billing system tables, at the list price in force, with the join of Databricks' official example.
Allocated
Shared among tables run by run, or hour by hour for a SQL warehouse, by published rules; the precision is shown next to every cost.
Estimated or potential
Projections, the Calculator and savings to confirm, always flagged as such, with their assumptions and their step-by-step calculation.
Verifiable
"Why?" gives the reason for a zero or missing cost, and a reconciliation SQL query returns the same total as YALineo, in your own workspace.
An identity, to the cent.
For the whole platform, the period's spend breaks down with nothing left over (section 5.6). The unattributed part is never forced to zero. On the extension's example platform, 90 days:
- total spend
- $12,535.00
- Σ refresh(T)
- $9,734.00
- Σ read(T)
- $884.40
- tables off the map
- $0.00
- capacity with no query
- $160.80
- unattributed
- $1,755.80
Every table cost shows its precision.
The rule that allocated it, from the surest to the least sure (section 5.7). A table takes the least sure label among its parts.
Surest
- billedBilled to this table by Databricks: a materialized view or a serverless streaming table.
- single tableThe only table written by the runs linked to it: their whole cost is its own.
- compute timeA run that writes several tables: its cost is shared by the compute time of the queries writing each.
- even splitA run that writes several tables without a compute time for all of them: equal shares.
- warehouseA share of a SQL warehouse, hour by hour, by the compute time of that hour's queries.
- periodNo run linked to the lineage: the cost is shared among the tables written over the period. The least sure rule.
Least sure
Version 0.34.4, November 3, 2026.
This document states, for every figure on the FinOps and Calculator sides, where it comes from, how it is calculated, what is measured and what follows an allocation convention. It is written to be checked: every formula can be reproduced with the SQL queries given in the appendix, and every stated property is checked by an automated test (section 9).
Formulas in code spans and code blocks keep the notation of the French original, so that both versions read the same. Key to its terms: coût cost, coûtLancé cost of launched jobs, prix price, remise discount, dépense spend, rafraîchissement refresh cost, lecture read cost, lectures reads, écrit written, lu read, part share, temps time, rythme pace, exécutions runs, jours or j days, durée length, fin end, aujourd'hui today, du and au from and to, taille size, paiement payment option, valeur value, ligne row, courant or courante current, précédent or précédente previous, période period, identifiant id.
1. Principle
YALineo creates no cost data. It reads the system tables that Databricks publishes for billing and observability, in the user's workspace, with the user's permissions, read-only. It always distinguishes three kinds of figures:
| Kind | Definition | Example |
|---|---|---|
| Measured | Read as is from a system table, or the exact sum of values read | DBUs of a job, list-price cost of a warehouse |
| Attributed | A measured cost split between several objects according to an explicit, documented rule | Share of a job's cost that goes to each of the tables it writes |
| Derived | Ratio or extrapolation of a measured or attributed figure | Cost per read, monthly cost |
Allocating a shared cost has no single answer: it is a convention, as in cost accounting. YALineo applies the allocation models recognized by the FinOps Foundation (proportional split by a usage metric, even split as a fallback, explicit non-allocation) and shows, for each table, how precise its attribution is. No cost is invented or lost: the sum of what is attributed and what is not equals the measured spend, to the cent.
2. Sources
| System table | Columns used | Role |
|---|---|---|
system.billing.usage | usage_quantity, usage_unit, sku_name, cloud, usage_start_time, usage_end_time, usage_date, workspace_id, billing_origin_product, usage_metadata (job_id, job_run_id, dlt_pipeline_id, dlt_update_id, warehouse_id, notebook_id, cluster_id, endpoint_name, app_id, app_name, agent_bricks_id, uc_table_catalog, uc_table_schema, uc_table_name, job_name, notebook_path, genie.surface), identity_metadata.run_as, product_features (is_serverless, serving_type, agent_bricks.problem_type), custom_tags | Billable consumption, one row per usage period |
system.billing.list_prices | pricing.default, pricing.effective_list.default, price_start_time, price_end_time, currency_code | List price in effect at the time of use |
system.lakeflow.job_run_timeline | job_id, run_id, result_state, period_start_time, period_end_time | Outcome of each job run |
system.lakeflow.job_run_timeline (continued) | trigger_type, source_task_run_id | Runs launched by a "Run Job" task of another job (section 4.1) |
system.lakeflow.job_task_run_timeline | run_id, job_id, period_start_time, period_end_time | The job whose task launched a run |
system.lakeflow.jobs | workspace_id, job_id, name, change_time | The name of each job, including the launching job and the launched job (sections 4.1 and 4.2) |
system.query.history | statement_id, compute.warehouse_id, compute.type, total_task_duration_ms, written_rows, read_rows, start_time, end_time, query_source.genie_space_id | Work actually done by each query, its hours, and the Genie space that started it |
system.access.table_lineage | statement_id, source_table_full_name, target_table_full_name, source_path, target_path, source_type, target_type, entity_type, entity_id, entity_run_id, entity_metadata (job_info.job_run_id, dlt_pipeline_info.dlt_update_id, notebook_id), direct_access (since 0.28), event_id, record_id (since 0.29), workspace_id, event_date, event_time | Which query, which job or pipeline run, which dashboard reads or writes which table |
system.compute.node_timeline | cluster_id, node_type, driver, start_time, end_time | Machine hours of classic clusters (Calculator, section 13.4) |
system.lakeflow.job_run_timeline (names) | workspace_id, job_id, run_name, run_type, period_start_time, period_end_time | The name of a job system.lakeflow.jobs does not know: that of its latest named run (sections 4.2 and 6.8) |
system.lakeflow.pipelines | workspace_id, pipeline_id, name, change_time | The name of each pipeline (section 4.2) |
system.information_schema.tables | table_catalog, table_schema, table_name, table_type, created, last_altered, data_source_format | The type of an object (section 5.8), its creation date (section 6.7), the date of its definition, which is never a write (section 6.9), and the inventory that decides which links are bridged (section 6.10) |
All queries cover the open workspace (workspace_id), unless the user explicitly chooses "The whole metastore, other workspaces included" (setting "Catalogs shown"): the billing of every workspace of the account is then read. The exact queries are in extension/lib/queries.mjs (ids yalineo:costs, yalineo:spend, yalineo:runs, yalineo:work, yalineo:attrib, on demand yalineo:work-days for the curves of the overview (section 6.5), for the Calculator yalineo:vmhours, and since 0.24 yalineo:series, the spend of each workload per date, section 6.6). The size and auto-stop of SQL warehouses come from the workspace list of warehouses (GET /api/2.0/sql/warehouses, fields cluster_size and auto_stop_mins), also read for their names.
3. The cost of a usage row
For each row u of system.billing.usage in the period:
prix(u) = pricing.effective_list.default of the list_prices price such that
cloud, sku_name and usage_unit are equal to those of u,
and price_start_time <= u.usage_end_time
and (price_end_time is NULL or u.usage_end_time < price_end_time)
(pricing.default if effective_list does not exist on this metastore)
coût(u) = u.usage_quantity × prix(u)
-
effective_listincludes the temporary promotional prices applied to all customers; it is the effective list price according to the Databricks documentation. - The price used is the one in effect at the end of the usage row: this is the join of the official Databricks example ("Join the pricing with usage tables", section 12). The price periods of a given SKU do not overlap: each row has at most one price. Up to 0.17, YALineo required a single price to cover the whole row; a row spanning a price change was then left without a price (counted separately, never estimated). Since 0.18, it gets the price in effect at its end, as in the official example.
-
A row with no matching price is not valued (cost 0); its quantity is counted separately (
unpriced) and the screen says the priced total is partial. Nothing is estimated in its place. -
Since 0.28, one documented exception: the DBUs of the
GENIE_FREE_USAGESKU (the free usage of Genie, section 4.3) never have a list price, since this SKU "does not carry a list price". Their cost is 0 and they stay in the workload's DBUs, but they do not count inunpriced: free usage never makes the total partial. - Databricks corrections (a negative retraction row, then a restatement row) are added up like the others: the sum stays exact.
-
The period is in UTC calendar days (
usage_date), as in the Databricks table. It runs from:daysdays before today to:end_daysdays before today, both dates included (:end_daysis 1 for a chosen length and for a map load, which end yesterday; 0 when the period ends today). See "Period" (section 7).
Negotiated discount. Databricks contracts often carry a discount on the list price. YALineo does not know it; the user can enter it (0 to 90%). All amounts shown are then multiplied by (1 − remise). DBUs do not change. Without a discount, the screen states "list price".
What is not in the total. system.billing.usage holds Databricks consumption (DBUs and other Databricks units). The cost of the cloud provider's virtual machines for classic compute, and the storage and networking billed by the cloud, are not in it; YALineo therefore does not include them and says so on every FinOps page. For serverless compute, the machine is included in the Databricks price.
4. Workloads
Each usage row belongs to exactly one workload, determined in this order (queries costs and spend, same rule):
| Order | Condition on the row | Workload | Id |
|---|---|---|---|
| 1 | uc_table_catalog, uc_table_schema, uc_table_name set | Refreshed table (materialized view, streaming table) | full name of the table |
| 2 | agent_bricks_id set, or product AGENT_BRICKS or SUPERVISOR_AGENT | Agent (Agent Bricks) | agent_bricks_id (otherwise endpoint_name, app_id, then the product) |
| 3 | product GENIE (on-demand Genie AI usage) | Genie | usage_metadata.genie.surface (GENIE_CODE, GENIE_ONE, GENIE_AGENTS), otherwise GENIE: type not indicated (section 4.3) |
| 4 | product VECTOR_SEARCH (an index sync included, which also carries a dlt_pipeline_id) | AI Search endpoint (vector search) | endpoint_name (otherwise dlt_pipeline_id, then the product) |
| 5 | job_id set | Job | job_id |
| 6 | dlt_pipeline_id set | Lakeflow pipeline | dlt_pipeline_id |
| 7 | warehouse_id set | SQL warehouse | warehouse_id |
| 8 | notebook_id set | Serverless notebook | notebook_id |
| 9 | cluster_id set | Cluster | cluster_id |
| 10 | endpoint_name set | Serving endpoint (deployed agents and models) | endpoint_name |
| 11 | app_id set | App | app_id (name: app_name) |
| 12 | otherwise | Other | billing_origin_product |
agent_bricks_id is read by name in the JSON form of usage_metadata (an empty value counts as absent): on a metastore whose schema does not have this field yet, the query does not fail, and the agent is identified by its endpoint or its product. Likewise, query_source.genie_space_id is read in the JSON form of query_source; a query history without this column gets a fallback query, without Genie spaces. Genie space names come from the workspace API (GET /api/2.0/genie/spaces, the list only).
For a workload W over the period of N days:
coût(W) = Σ coût(u) for the rows u of W
DBU(W) = Σ usage_quantity for the rows u of W whose usage_unit = 'DBU'
By construction, each row belongs to exactly one workload, so Σ coût(W) = total spend.
Other attributes of a workload, all measured: number of runs (for a job, the runs in system.lakeflow.job_run_timeline; otherwise the distinct job_run_id or dlt_update_id), main product (the billing_origin_product with the largest quantity), "Run as" (the identity_metadata.run_as with the largest quantity), tags (the custom_tags of the row with the largest quantity), serverless (at least one is_serverless row), cost of the last 7 complete dates and of the 7 dates before (section 6), and the cost of its DBU rows alone (for the average price of a DBU, section 13.4).
Note: a job run on an all-purpose cluster is billed to the cluster, not to the job (job_id is only set for serverless compute and jobs compute, according to the Databricks documentation). YALineo points this out below the job list.
Note: an orchestration job (a "masterjob") whose tasks only launch other jobs ("Run Job" tasks) uses no compute itself. Each launched job runs and is billed under its own job_id: that job carries the cost, both in the job list and in its badge. The masterjob therefore has no cost and no badge, or only the cost of its own compute tasks (a notebook or a check on serverless, for example). Likewise, a task that starts a pipeline or a query on a SQL warehouse is billed to the pipeline or the warehouse. Since version 0.16, the cost of the jobs launched by a masterjob is shown next to its own cost, never added to the total (section 4.1).
4.1 Cost of launched jobs ("Run Job" tasks)
A run launched by a "Run Job" task of another job has trigger_type = 'RUN_JOB_TASK' in system.lakeflow.job_run_timeline, and its source_task_run_id column gives the task that launched it. That task is a row of system.lakeflow.job_task_run_timeline (run_id), which gives the launching job (job_id). Databricks has filled these two columns since early December 2025: before that, no run is linked to its launcher.
For each pair (launching job P, launched job C) over the period:
exécutions(P, C) = number of runs of C in the period whose source task belongs to P
coûtLancé(P, C) = Σ cost of the usage rows of these runs (job_run_id), at the list price of section 3, minus the discount
coûtLancé(P) = Σ_C coûtLancé(P, C)
- Kind: measured. Each amount is the billing of the runs themselves, not an allocation.
- Never added: this amount is already counted in the cost of each launched job (section 4). It is shown next to the launching job's own cost ("Jobs launched" column of "Jobs and compute", a line on its details card, badge on Databricks pages) and enters no total, no card and no attribution to tables. Totals stay the sum of own costs, to the cent.
-
Masterjob with no compute: a job none of whose usage rows carries its
job_id(only "Run Job" tasks) is listed at 0, with its runs, so that the cost of the jobs it launches has a line. Its badge shows that cost, preceded by "↳" and explained in the tooltip. - Window: as for the number of runs, a run counts as soon as one of its slices starts in the period (Databricks splits a long run into one-hour slices); the task that launched it is looked up from one day before the period, since it may have started the day before.
-
Separate, optional query:
yalineo:launches. Without access tosystem.lakeflow.job_task_run_timeline, only the "Jobs launched" column is missing; runs and failures remain. Without access tosystem.lakeflow.jobs, it runs again without the names (the ids remain). The 20,000 most expensive pairs are read, and 5,000 are kept with the map. -
One level only:
source_task_run_idpoints to the direct launcher. If A launches B, which launches C, the runs of C count for B, not for A. A job never counts as launching itself. - Details card of a launched job: it says who launched its runs ("Launched by"), with their number and their cost.
4.2 The name of a job (0.25)
The billing names a job only when it runs on serverless (usage_metadata.job_name). The other names come from the system tables, with no computation and no estimate: a name is read, never inferred.
-
The saved jobs of this workspace (
yalineo:jobs):system.lakeflow.jobsis regional (every workspace of the region) and ajob_idis unique only within its workspace (Microsoft Learn, "Jobs system table reference", consulted on October 25, 2026). The name kept is the one of the most recent row per (workspace_id,job_id), as the documentation reads an SCD2 table; a deleted job keeps the last name it had (a row without a name never hides it). The workspace is the one of the cost queries (its address, else the usage of the SQL warehouse); without access to the billing, its address alone; when it stays unknown (an AWS address without access to the billing), every workspace of the region, as before 0.25. Its rows come before the others', so the limit of 100,000 rows never cuts them. The same rule for pipelines (system.lakeflow.pipelines). -
One-time runs (
yalineo:run-names): a run submitted throughPOST /jobs/runs/submit(Azure Data Factory, the Airflow DatabricksSubmitRunOperator) is aSUBMIT_RUN, a notebook started bydbutils.notebook.runaWORKFLOW_RUN. They appear only in the run tables, never insystem.lakeflow.jobs, and their only name isrun_name; the lineage still names them as a job (entity_type = 'JOB'). For thejob_idvalues of this workspace that the lineage names over the link window (and those billed over the same days, for the FinOps view) and thatsystem.lakeflow.jobsdoes not know, the name is therun_nameof the latest named run of that window (system.lakeflow.job_run_timeline). It is shown with the mention "one-time run" whenrun_typeisSUBMIT_RUNorWORKFLOW_RUN; the id stays on the details card and in the tooltip. - In the FinOps view: a job the billing does not name takes the name from its own workspace (never the name of another workspace's job with the same id), else the one of its latest run, with the same mention. Reloading the FinOps period alone keeps the names found by the last full load.
-
Optional: without access to
system.lakeflow.job_run_timeline, the ids stay as before 0.25. No amount changes: only the names shown. -
Since 0.28: every saved job that has a run over the links' window gets a name, in this order:
system.lakeflow.jobs, else therun_nameof its latest run marked "name of its latest run", else the id with the reason. The name fromsystem.lakeflow.jobsalso comes before the billing's. Details, quotes and dates read: section 6.8.
4.3 Which Genie, which AI product (0.28)
The "AI and Genie" view names each AI line by the product the billing indicates, and only through documented fields. A missing value is said "not indicated", a value the documentation does not list "undocumented"; in both cases the line keeps its measured cost, on its own: nothing is guessed. Sources read on October 28, 2026 (2026-10-28); the update date of each page is in brackets, the full list at the end of this section.
The Genie products today. The documentation (Genie page, Sep 18, 2026) describes a family of three products: "Genie One: A simplified interface for business users", "Genie Agents: Domain-specific environments where data teams configure trusted data, metrics, and business rules that power Genie One answers", "Genie Code: The AI coding and data assistant for developers and technical practitioners inside the Databricks workspace". The names changed in 2026, according to the release notes: "Databricks Assistant is now Genie Code" (March 11, 2026); "Databricks One, the simplified Databricks interface, has been renamed to Genie" (April 27, 2026) then "Genie [...] has been renamed to Genie One" (June 9, 2026); "Genie Agents (formerly Genie Spaces) are now called Genie Agents" (July 9, 2026). A "Genie space" is therefore a Genie Agent today, and "Genie in Databricks One" is Genie One. "Agent mode" is a way of working of Genie Code and of the Genie Agents (release notes), not a product: the documented billing values have none for it.
In the billing. Each row of system.billing.usage with the GENIE product carries the Genie product in usage_metadata.genie.surface: "Identifies which Genie product generated the usage (GENIE_CODE, GENIE_ONE, or GENIE_AGENTS)" (Monitor and understand your Genie cost, Sep 11, 2026). The same page lists usage_metadata.genie.channel ("The access channel, for example UI") and product_features.genie.offering_type ("for example PAYGO"); YALineo does not read them, their values are not all documented. The reference page of the table (Billable usage system table reference, Oct 18, 2026) does not list the genie field yet: it is read by name in the JSON form of usage_metadata, like agent_bricks_id, and a metastore without it gives NULL instead of an error.
| Product shown | What says it in the billing | Id shown | What the billing does not say |
|---|---|---|---|
| Genie Code, Genie One, Genie Agents | billing_origin_product = 'GENIE' and usage_metadata.genie.surface = GENIE_CODE, GENIE_ONE or GENIE_AGENTS | none: the line is the product, for the whole workspace | which Genie Agent (formerly space) used the model: no field carries its id |
| Genie, type not indicated | GENIE without surface (or empty) | GENIE | the Genie product; the documentation does not say when the field is missing |
| Genie, type not read | a map loaded before 0.28 (the query did not read the field) | GENIE | reload the map |
| Genie, undocumented type | a surface value outside the three listed | the value, when it has the shape of a billing code (capitals, digits, _), else nothing | what it stands for |
| Knowledge Assistant (Agent Bricks) | product_features.agent_bricks.problem_type = 'AGENT_BRICKS_KNOWLEDGE_ASSISTANT' | agent_bricks_id | another problem_type value: "Agent Bricks, undocumented type" |
| Supervisor Agent (Agent Bricks) | billing_origin_product = 'SUPERVISOR_AGENT' | agent_bricks_id | |
| Agent Bricks, type not indicated | AGENT_BRICKS without problem_type (the documentation describes AGENT_BRICKS as "Knowledge Assistant Supervisor Agent workloads") | agent_bricks_id | Knowledge Assistant or Supervisor Agent |
| Model Serving: foundation model, deployed model, GPU model, Feature Serving | MODEL_SERVING and product_features.serving_type = FOUNDATION_MODEL, MODEL, GPU_MODEL, FEATURE | endpoint_name | without serving_type: "type not indicated"; another value: "undocumented type" |
| AI Gateway, AI Functions | a row that carries an endpoint_name and the AI_GATEWAY or AI_FUNCTIONS product | endpoint_name | |
| Endpoint, product …; Endpoint, product not indicated | a row that carries an endpoint_name and a product other than MODEL_SERVING, AI_GATEWAY or AI_FUNCTIONS, or no product | endpoint_name | what that product stands for; the cost stays measured, on its own line |
| AI Search (vector search) | VECTOR_SEARCH | endpoint_name, otherwise dlt_pipeline_id (an index sync) | |
| Databricks Apps | app_id | app_id (name: app_name) |
For a Genie Agent, the type comes from the query history: query_source.genie_space_id, "Statement executed from a Genie Agent" (Query history system table reference, Oct 20, 2026). Its name comes from the workspace API (GET /api/2.0/genie/spaces, the list only).
Free or billed. "Genie usage is split across two SKUs based on whether the usage is free or billed, not based on the Genie product": billed usage is under the Serverless Real-Time Inference SKU of the region, shared with other products (hence the filter on billing_origin_product), and free usage under GENIE_FREE_USAGE, which "does not carry a list price" (Monitor and understand your Genie cost). Free are the monthly allowance of 150 DBUs per user and, until January 31, 2027, Genie One and Genie Agents for users; service principals are billed. YALineo counts the DBUs of GENIE_FREE_USAGE apart (free_dbus of the costs query): they stay in the workload's DBUs, their cost is 0 and they are never said "not priced". Free DBUs used before July 20, 2026 are not in the table (the page says so). The 25 % promotional discount is already in the usage_quantity of billed usage: the list price applies as to any row (section 3). The corrections of July 21, 2026 (RETRACTION rows that cancel the Genie One and Genie Agents usage billed before) add up like any row: their sum is zero. To estimate these costs before building a Genie Agent, see the "AI: Genie and agents" page (section 13.16).
What is billed where, never counted twice. The Genie line carries the language model. The SQL queries Genie runs are billed by the SQL warehouse: "Budgets track large language model (LLM) usage only. Compute used to run the queries Genie generates, such as a SQL warehouse, is billed separately" (Genie consumption guide, Sep 11, 2026), and "Genie Agents require a pro or serverless SQL warehouse" (Create and manage a Genie Agent, Oct 9, 2026). Those queries are in the warehouse's workload (warehouse_id); each Genie Agent's share (section 5.4, hour by hour, by query_source.genie_space_id) is already in that cost and is never added to the AI cost. The screen shows side by side each agent's SQL share and the Genie Agents line (the model, all agents together): two separate costs, never added together. The compute Genie Code starts (a notebook, the SQL editor) is billed by that compute; the query history documentation lists no Genie Code source: that compute is not tied to Genie Code (unknown).
The order of workloads. Since 0.28, the AI products named by billing_origin_product (Agent Bricks, Genie, AI Search) come before the compute fields (table of section 4). The table reference says dlt_pipeline_id is also filled for "AI Search indexing": before 0.28, an AI Search index sync was counted as a pipeline and left out of the AI cost. Still outside "AI and Genie", for want of a documented field that tells them apart: the older Model Serving ("legacy model serving"), billed with a cluster_id (Cluster workload); the AI_FUNCTIONS, AI_RUNTIME, FOUNDATION_MODEL_TRAINING, AGENT_EVALUATION products and AI_GATEWAY without an endpoint_name, or whose row also carries a compute field (job_id, dlt_pipeline_id, warehouse_id, notebook_id, cluster_id, read before endpoint_name in the table of section 4), which go to the workload of that field (job, notebook...) or to "Other".
On screen and in the export. A Genie line carries the name of its product (Genie Code, Genie One, Genie Agents) and, under it, what it is and its former name; the other lines carry their product and, for an agent or an app, their billing id. A line whose type is not indicated says so, with "Why?" (the missing fields, the method). "By product" replaces "By type": each product, rounded by the largest remainder (section 6.2), adds up to the AI cost to the cent. The "AI and Genie" export adds three columns: ai_product (the product shown), ai_product_billing (the fields and values that say it, for example billing_origin_product = GENIE · usage_metadata.genie.surface = GENIE_CODE) and free_dbus; the lines of the Genie Agents' questions carry Genie Agent and query_source.genie_space_id. A value read from the billing is shown only when it has the shape of a documented code; a cell that looks like a formula stays text (lib/csv.mjs).
Checks. tests/v0280-genie28.test.mjs (classification of billing rows, unknown and hostile values, sums to the cent, export), tests/spark/finops_sql.py (Genie Code, Genie One and Genie Agents apart, free DBUs, missing or empty field, hostile value, AI Search index sync, older schemas), tests/security.test.mjs (attack through a booby-trapped surface value).
Sources (read on 2026-10-28).
- Databricks, Billable usage system table reference (Oct 18, 2026): https://docs.databricks.com/aws/en/admin/system-tables/billing ; Microsoft Learn, same page (2026-10-18): https://learn.microsoft.com/azure/databricks/admin/system-tables/billing
- Databricks, Monitor and understand your Genie cost (Sep 11, 2026): https://docs.databricks.com/aws/en/genie/monitor-cost ; Microsoft Learn (2026-09-11): https://learn.microsoft.com/azure/databricks/genie/monitor-cost
- Databricks, Genie cost and budgets FAQ (Sep 11, 2026): https://docs.databricks.com/aws/en/genie/genie-cost-budgets-faq
- Microsoft Learn, Genie consumption guide (2026-09-11): https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Databricks, Genie (Sep 18, 2026): https://docs.databricks.com/aws/en/genie/ ; Genie Agents (Oct 7, 2026): https://docs.databricks.com/aws/en/genie-agents/ ; Create and manage a Genie Agent (Oct 9, 2026): https://docs.databricks.com/aws/en/genie-agents/set-up ; Genie One (Oct 12, 2026): https://docs.databricks.com/aws/en/genie-one/ ; Genie Code (Oct 13, 2026): https://docs.databricks.com/aws/en/genie-code/
- Databricks, Query history system table reference (Oct 20, 2026): https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Release notes (names only): March 2026 (Mar 25, 2026): https://docs.databricks.com/aws/en/release-notes/product/2026/march ; AI/BI and Genie One release notes 2026 (Oct 27, 2026): https://docs.databricks.com/aws/en/ai-bi/release-notes/2026
5. Attribution to tables
This is the "attributed" part. Since 0.20, each rule starts from the most precise link the system tables give between a spend and a table: the billing of a table, then the run that wrote it, then the hour of a SQL warehouse, then, only as a fallback, the period. What cannot be linked stays visible as unattributed; nothing is spread to make a total add up.
5.1 Table billed directly ("billed" precision)
A usage row that carries the name of a Unity Catalog table (materialized view, streaming table refreshed by Databricks) is attributed in full to that table. This is a measurement, not an allocation.
rafraîchissement(T) += coût(W) for W of kind Table and T = W
5.2 Jobs and pipelines: run by run (attrib query)
The cost of a run. Each usage row of a job carries the run it bills (usage_metadata.job_run_id), each row of a pipeline its update (usage_metadata.dlt_update_id). For a run R of a workload W billed in the period:
coût(R) = Σ coût(u) for the rows u of W whose job_run_id (or dlt_update_id) = R
The tables written by that run. Lineage gives, for each write, the run that made it: entity_metadata.job_info.job_run_id for a job, entity_metadata.dlt_pipeline_info.dlt_update_id for a pipeline (on an older metastore, entity_type and entity_run_id). L(R) is the set of target tables of the events of the same workspace whose run is R, read over the period widened by one day on each side (a run may write the day before or after its billing).
The split within the run, n = |L(R)|:
n = 1 : part(R, T) = 1 "single table" precision
n > 1 and m(R, Ti) > 0 for every table : part(R, Ti) = m(R, Ti) / Σ m(R, Tj) "compute time" precision
n > 1 otherwise : part(R, Ti) = 1 / n "even split" precision
rafraîchissement(T) += Σ_R coût(R) × part(R, T)
-
m(R, T)is the sum oftotal_task_duration_msof the queries of runRthat writeT(join ofsystem.query.historyand lineage onstatement_id). A query that writesktables counts for1/kof its time in each.total_task_duration_msis, according to Databricks, the task time summed over all cores of all nodes: a measure of the compute used. -
statement_idis only filled in lineage for queries run on a SQL warehouse or on serverless. On a classic cluster, time per table does not exist: the split is even, and the table says so. - A table written by a run receives the cost of that run, not of the others: a job whose tables change from one run to the next is split run by run.
- A run with no write in lineage (a failure before the write, a write lineage does not capture) stays unattributed. Its cost is never moved onto the tables of the successful runs.
- Every table written counts in the split, whatever its catalog. The share of a table outside the catalogs of the map, or dropped since (temporary table, checkpoint), is counted apart ("tables off the map") and never moved onto the visible tables. A table's figure therefore does not depend on what the user chose to load.
-
Databricks internal catalogs (0.34.3). Databricks itself creates a catalog
__databricks_internal"to store internal state for features such as Lakeflow pipelines and AI/BI dashboards", a reserved name only Databricks uses (Microsoft Learn, What are catalogs in Azure Databricks?, part "The__databricks_internalcatalog", https://learn.microsoft.com/azure/databricks/catalogs/, read on 2026-11-03). The owner of the project also saw catalogs__databricks_internal_catalog_lakeview_<user>on a real workspace (3 November 2026). Since 0.34.3, a table of a catalog whose name starts with__databricks_internal, whatever the case, is never on the map, whatever the catalogs loaded and the inventory (extension/lib/internal-catalog.mjs). Its share of a run, or its share over the period in the fallback below (the same rule as the other tables written), counts in "tables off the map"; it is said apart,interne(W), a part ofhors_plan(W)never added to it a second time. The same goes for a usage row billed to such a table (section 5.1) and for a SQL warehouse query that writes or reads one (section 5.4): neither a refresh nor a read of a table, their cost goes tohors_plan(W)and tointerne(W). A usage row billed to an internal table stays a workload (the total falls to the cent), never named: "Databricks internal table (hidden)" on screen and in the files, without an id. The rows a query writes into an internal table make no table of the costs (review of 0.34.3).
Fallback over the period ("period" precision). Two cases have no run to link:
- a workload none of whose billed runs appears in lineage, while lineage shows its writes over the period (run ids missing or different);
- usage rows without a run id (for example a serverless notebook, section 5.3).
Their cost is then shared between the tables the workload wrote over the period: by compute time when every table has some, evenly otherwise. A single table written keeps the "single table" precision. The screen shows this fallback through its precision, the least sure one.
In this fallback, a workload none of whose tables written is on the map (all dropped since, or all in Databricks internal catalogs) has no table to share with: its whole cost stays unattributed, neither "tables off the map" nor "Databricks internal catalogs". Run by run, the same workload would go to those lines. This is the rule of the gone tables, kept as is for the internal tables (review of 0.34.3): with no run linked, nothing says which part of the cost belongs to those tables rather than to runs with no write.
Check. The query also returns, per workload, the number and cost of its billed runs (runs) and of those linked to lineage (tied): the difference is the cost of the runs with no write observed.
The shares of a run add up to 1: a run is attributed at most once.
5.3 Serverless notebooks
The billing of a serverless notebook carries no run. Its cost over the period goes to the table it wrote if it wrote only one ("single table"), otherwise it follows the fallback over the period of section 5.2 ("period"). A notebook launched by a job is billed to the job and follows section 5.2.
5.4 SQL warehouses: hour by hour ("warehouse" precision)
A warehouse serves several uses at once. Since 0.20, its cost is split hour by hour (work query):
coût(W, h) = Σ coût(u) × fraction of row u in hour h (a usage row is spread over the hours it covers)
ms(q, h) = total_task_duration_ms(q) × fraction of the duration of q in hour h
coût(q) = Σ_h coût(W, h) × ms(q, h) / Σ_q' ms(q', h) (evenly between the queries of the hour if none has any time)
rafraîchissement(T) += Σ coût(q) / k for the queries q that write T (k tables written)
lecture(T) += Σ coût(q) / k for the queries q that read T without writing anything (k tables read)
- A query across two hours counts in each for the share of its duration spent there.
- A query has one role only: it writes (if it writes at least one table) or it reads. It is never counted twice.
- Capacity with no query: an hour billed with no query running (start-up, wait before auto stop) is spread over nobody. It is shown apart, per warehouse, under that name.
-
Queries that touch no table in lineage (ad hoc queries, metadata,
SELECT 1) and those on tables outside the catalogs of the map stay unattributed. - Since 0.34.3, a query that writes or reads a table of a Databricks internal catalog (section 5.2) gives neither a refresh nor a read: its cost goes to "tables off the map", said apart under "Databricks internal catalogs".
-
By construction,
Σ_T [refresh + read] + capacity with no query ≤ coût(W): no more than the spend is ever attributed.
The queries of a dashboard, a saved query or a Genie space likewise receive the cost of their queries, hour by hour (section 6); that amount is already in coût(W) and adds to nothing.
5.5 What is not attributed
All-purpose clusters, endpoints, apps, notebooks without lineage, runs with no write observed, the share of warehouses that matches no table: YALineo ties them to no table, for lack of a measured link. They stay visible as "unattributed". This is the FinOps Foundation's "do not allocate" option, preferred to an arbitrary split. Two amounts are isolated: the share of tables off the map (section 5.2) and the capacity with no query of warehouses (section 5.4).
5.6 Accounting identity
For any workload W:
coût(W) = vers_tables(W) + vers_lectures(W) + hors_plan(W) + capacité_sans_requête(W) + non_attribué(W)
and for the platform:
total spend = Σ_T rafraîchissement(T) + Σ_T lecture(T) + tables off the map + capacity with no query + unattributed
The unattributed part is never brought back to zero: a Databricks correction (a negative row) can make it negative, and the identity stays exact to the cent. It is checked by the tests (section 9) and visible on screen.
Since 0.34.3, hors_plan(W) = tables_disparues(W) + interne(W): the share of the tables of Databricks internal catalogs (section 5.2) is a part of the tables off the map, said apart and never added a second time. The identity does not change.
5.7 Precision levels shown
From the surest to the least sure:
| Label | Meaning |
|---|---|
| billed | A usage row in the table's name (section 5.1). The only label without "≈" on badges |
| single table | The only table written by the runs linked to it: their whole cost is its own |
| compute time | A run that writes several tables, shared by the measured compute time of each write |
| even split | A run that writes several tables without a compute time known for all of them |
| warehouse | A share of a SQL warehouse, hour by hour, by the compute time of the queries |
| period | No run linked: shared between the tables written over the period |
A table that receives several shares takes the least sure label. A map loaded before 0.20, without the attrib query, keeps the former rule (split over the lineage window) under the "period" label, and the screen invites a reload.
5.8 Tables and views
Unity Catalog tells tables (managed or external), views, metric views, materialized views and streaming tables apart. So does the map (a view has a hollow ring), and since 0.21 every cost list says the object type, with an "Object type" filter (section 7) and a type column in the export.
- Materialized view, streaming table: their data is kept and refreshed. Their refresh follows the rules of section 5: billed to their name when Databricks bills it so (section 5.1), otherwise a share of the runs that refresh them.
-
View, metric view: no data kept; Databricks computes it from its sources at each read. It is never refreshed:
-
a run that (re)defines it (
CREATE OR REPLACE VIEW: the lineage notes the view as written,target_type=VIEWorMETRIC_VIEW) gives it no share. The run pays its other tables; if it wrote views only, its cost stays not attributed (section 5.5); - a warehouse statement that (re)defines it is neither a write nor a read: its share of the hour stays with the warehouse, not attributed;
-
its cost is what the queries that read it cost,
lecture(V)(section 5.4), shown with "≈".
-
a run that (re)defines it (
- Reads through a view: reading a view reads its sources. The reads of a view therefore also count for the tables it reads, and for their own sources when those are views too:
lectures_par_vues(T) = Σ lectures(V) for each view V built on T, directly or through other views
lectures(T) = lectures_directes(T) + lectures_par_vues(T)
Since 0.28, lectures_directes(T) does not count the lineage rows marked direct_access = false (the table under a view that was read): otherwise a read through a view would count twice for T (section 6.8).
A table read only through a view is therefore no longer "with no read observed", whether in the FinOps side, in Analytics ("written with no read observed") or in the health check. The cost of those reads stays with the view: it is never counted twice.
-
Bound of the walk: each view read always counts for its direct sources. Beyond them, the walk stops at 100 nested views (Spark's limit for nested views) and at 2 million links walked in all; real platforms stay far below both bounds. Past either one, the reads of the objects upstream of the stop are a minimum, marked "≥": these objects are never called unread, and their cost per read is not shown (it would be overstated). A notice says so under the list of tables, and the
reads_at_leastcolumn of the export isyesfor them. - A map loaded before 0.21 keeps the shares it received; those that go to a view stay not attributed, and the identity of section 5.6 holds to the cent.
5.9 Catalogs and schemas
Since 0.22, the "Catalogs and schemas" page of the FinOps side and the badges of Catalog Explorer say what each catalog and each of its schemas costs. No new figure: these are the sums of the per-table figures of sections 5.1 to 5.8.
rafraîchissement(C) = Σ rafraîchissement(T) for the tables T of the catalog (or schema) C
lecture(C) = Σ lecture(T)
A schema belongs to one catalog: the schemas of a catalog add up to it, and the catalogs to the total of the tables, to the cent (rounding of section 6.2, in the export too). The tables of the map with no cost over the period are counted, so a schema that cost nothing still shows. Objects without a catalog (files, paths) are counted apart, "outside the catalogs".
Exact or split. The amount of a level (catalog or schema) is exact when no sharing rule between this level and another is involved:
- a part billed in the name of a table (section 5.1) is exact everywhere;
- a workload (job, pipeline, notebook) whose every object written over the period (tables kept, tables dropped since, views redefined) lies in this one catalog, or this one schema, gives it the whole of what it paid for them: how that cost is then shared between its tables does not change the sum of the level. No part of that workload may also go to a view (section 5.8) or to a table off the map (section 5.2), a table of a Databricks internal catalog included (0.34.3);
- a workload that wrote in several catalogs (or schemas), and any part of a SQL warehouse (shared hour by hour, section 5.4), are shared by the rules of the tables: their part in the level is an estimate.
exact(C) = Σ parts(T, W) for the tables T of C and the workloads W billed to T, or that wrote only in C
réparti(C) = rafraîchissement(C) − exact(C)
Example: a job that writes lake.silver.a and lake.gold.d is exact for the catalog lake and split between the schemas silver and gold. The screen shows "exact" or "x % split" on each line, and the exact share of the total; a badge has no "≈" when its amount is exact.
Reads. lecture(C) is the part of the warehouses paid by the queries that read its tables (section 5.4), always an estimate, shown "≈". It is not added to the refresh: these are two different uses.
Share of the total. The "share" column is rafraîchissement(C) / total spend of the period.
Identity. Without table filters, the screen reconciles everything to the cent:
total spend = Σ_C rafraîchissement(C) + outside the catalogs + Σ_C lecture(C) + capacity with no query + unattributed + tables off the map
Databricks internal catalogs (0.34.3). A catalog whose name starts with __databricks_internal (section 5.2) is never a row of the page, of its export nor a badge. What its tables received is said on a line of its own in the reconciliation, "Databricks internal catalogs"; the line "Tables gone since" keeps the rest of the tables off the map. A figure another reader would still have filed under such a table (refresh or read) goes on that same line, never on a catalog row. The identity then reads:
total spend = Σ_C rafraîchissement(C) + outside the catalogs + Σ_C lecture(C) + capacity with no query + unattributed + tables gone since + internal catalogs
tables gone since + internal catalogs = tables off the map (section 5.6)
Example (tests/v0343-internal.test.mjs): a spend of $193.81. A pipeline ($100.37) writes lake.gold.orders_daily ($60.25) and a table of __databricks_internal ($40.12); a job ($12.34) writes only a dataset of a catalog __databricks_internal_catalog_lakeview_<user>; a refresh is billed to the internal table ($3.33), another to lake.gold.orders_daily ($7.77); a warehouse ($50.00) writes lake.gold.orders_daily ($10.01), reads it ($15.02), reads and writes the internal dataset ($4.44 + $1.11), stays idle $6.66 and spends $12.76 on no table; a job ($20.00) writes a table dropped since. The page shows lake $78.03, reads $15.02, idle warehouses $6.66, compute writing no table $12.76, tables gone since $20.00, Databricks internal catalogs $61.34 (40.12 + 12.34 + 3.33 + 4.44 + 1.11): $193.81 to the cent, and no __databricks_internal row.
What keeps their names (review of 0.34.3). The screen, the CSV, HTML and Excel files (the sheet's file included, third review) and the badges never name an internal table or catalog. A charge billed to an internal table is called "Databricks internal table (hidden)" there, under the key TABLE:internal and without an id, whether it comes from the costs loaded, from the period before or from the list of the largest changes of Trends (second review). Technical fields keep those names, because the calculations or the navigation need them; they stay on the user's device, like the map itself: the map downloaded as JSON ("Download the map", the input of the pre-flight), which is the model as YALineo computes it (hidden.writes, the writes kept for the split of the costs; bridged.through, the tables a bridge crosses; the cost and query rows read, finops; in analyst mode, the answers of the lineage API, api.rows); the address of the studio page when the sheet, the trend or a filter of the exploration is about such a charge (parameters asset, trend and ex, shown in the address bar of the browser); the key the follow-up of a finding is kept under. The search of "Jobs and compute" and of the exploration also looks in that hidden id: typing the name of an internal table shows its row, still under the hidden name (known limit of 0.34.3).
Catalogs chosen that are all internal. Chosen before 0.34.3, they are no longer read; when no other is left, YALineo reads nothing (and never "every catalog" in their place) and asks to choose others: the load, the period of the costs and every query that depends on the catalogs (any statement that receives the saved choice of catalogs: column inventory, trends, "Why?", for a map saved before 0.34.3 and in the pre-flight too) stop before sending a statement, and the map already saved stays. A statement that does not depend on that choice (the columns of one named table, for example) goes as before. In the settings, saving with no catalog ticked says so once; saving again without ticking any then reads every catalog, as chosen. The message always compares with the last choice saved, never with the one the page opened with. The volume estimate of the settings reads the boxes ticked in the form, where no internal catalog is offered: with no box ticked, it estimates every catalog, like a save with no box ticked.
With a table filter (section 7), only the tables chosen are added up and the reconciliation is not shown: it holds for the whole platform only.
Change. The total card is set against the same sum over the previous period (section 7.1): the catalogs of that period, with the same filters and the same discount.
6. Derived indicators
| Indicator | Formula | Note |
|---|---|---|
| Monthly cost | x × (365 / 12) / N | Linear extrapolation of the observed period over an average month of 365/12 days (30.42), the same everywhere (the Calculator included: 730 hours, and 12 months make 365 days); shown as "≈ per month". N is the number of days counted in the period (section 7, "Period") |
| Projection (cost and DBUs) | H × rythme(W), summed by product, by table and for the total | "Projections" page and "Projection, next 30 days" card of the overview: section 7.2 |
| Reads of a table | Number of lineage rows where the table is the source, direct only since 0.28 (section 6.8), over the cost period (attrib query), plus the reads of the views built on it (section 5.8) | Includes reads by other processes, which are real uses. A map loaded before 0.20 counts over the map's activity window |
| Cost per read | rafraîchissement(T) / lectures(T) | Empty if the table is not refreshed or not read |
| Cost per million rows written | rafraîchissement(T) / written_rows(T) × 10⁶ | Rows measured by system.query.history |
| Upstream chain cost | rafraîchissement(T) + Σ rafraîchissement(U) for the tables U upstream of T | What an asset depends on. A shared table counts in full for each asset: these amounts do not add up across assets |
| Cost of a dashboard's queries | Σ coût(q) of its queries, hour by hour (section 5.4) | Queries tied to the dashboard by lineage |
| Cost of a Genie space's questions | Σ coût(q) of the queries whose query_source.genie_space_id is space G (section 5.4) | Already in the warehouse's cost: added neither to the total nor to "AI and apps" |
| AI and apps | Σ coût(W) of the Agent, Genie, Serving endpoint, AI Search and App workloads, corrections included | Measured. Apps are included: the name says so. Genie spaces are shown separately (previous row) |
| Cost of a view | lecture(V): the share of warehouses paid by the queries that read it | A view is never refreshed (section 5.8); shown with "≈" |
| Table with no read observed | rafraîchissement(T) > 0 and lectures(T) = 0 over the period, neither directly nor through a view | An attributed cost, not a saving: a read outside Databricks, an export or a monthly use does not appear in lineage. To check with the owner before stopping anything |
| Rising cost | coût 7 j ≥ 1,5 × coût 7 j précédents (the last 7 days cost at least 1.5 times the previous 7) and a gap ≥ max(1, 2 % de la dépense de la semaine) (at least 1, and at least 2% of the week's spend) | Fixed, published thresholds. The "7 days" are the last 7 complete dates of the period: fin − 6 to fin; for a period that ends today (still running), the 7 dates ending yesterday (today − 7 to today − 1). The "previous 7 days" are the 7 dates before. A constant spend shows no gap. The costs query therefore reads at least 14 days before the end |
| Cost of failures | Cost of the runs whose final state is FAILED, ERROR or TIMED_OUT | Joined on job_run_id |
| Estimate of an AI run (glossary, 0.22) | calls = tables chosen; tokens_in = Σ (90 + ⌈name / 4⌉ + ⌈description / 4⌉ + ⌈first 60 columns / 4⌉), in characters; tokens_out = calls × 400; cost = (tokens_in × price_in + tokens_out × price_out) / 10⁶ | Derived, before running. The prices per million tokens are the ones the user types (Databricks pricing page for the model chosen): without them, no amount. 400 is the max_tokens bound written in the statement, so a maximum; four characters per token is an approximation. The real bill is Databricks' (Foundation Model APIs) |
6.1 Badges in Databricks pages
In Databricks pages (job list, Catalog Explorer, workspace browser...), a small amount follows each link to an object of this workspace that costs at least one cent. It creates no new figure: it is one of the figures above, over the loaded period (N days), at list price minus the discount entered, with no filter.
Since 0.28, every object the map knows gets a badge: "< $0.01" under a cent, or a short mention with its reason ("$0 · view", "not attributed"...). The cases and their rules are in section 6.8.
Since 0.34.3, a Databricks internal catalog (section 5.2), its schemas and its tables get no badge, neither an amount nor a mention.
| Link to | Amount shown | Kind | Formula |
|---|---|---|---|
| Job, pipeline, SQL warehouse | Its cost | Measured | coût(W) (section 4) |
| Job that launches other jobs ("Run Job" tasks) | Its cost, and in the tooltip the cost of the jobs it launches; with no compute of its own, that cost alone, preceded by "↳" | Measured | coûtLancé(P) (section 4.1), never added to its cost |
| Table, materialized view, streaming table | Its refresh cost, preceded by "≈" unless it is billed in its name ("billed" precision) | Attributed | rafraîchissement(T) (section 5); the tooltip names the type, gives the precision and lecture(T) |
| View, metric view | What the queries that read it cost, preceded by "≈" | Attributed | lecture(V) (section 5.8); the tooltip says a view is never refreshed |
| Catalog, schema (Catalog Explorer, since 0.22) | The refresh of its tables, preceded by "≈" as soon as a part is split | Attributed | rafraîchissement(C) (section 5.9); the tooltip gives the exact and split parts, the three workloads that pay the most, lecture(C) and the number of tables that cost |
| Dashboard, saved query | The cost of its queries, preceded by "≈" | Attributed | Σ coût(q) of its queries ("cost of a dashboard's queries" row above) |
Genie Agent, formerly Genie space (/genie/rooms/<id>, section 4.3) | The cost of its questions on warehouses, preceded by "≈" | Attributed | Σ coût(q) of its queries |
| Serving endpoint, app | Its cost; for an endpoint, plus that of the Agent Bricks agents it serves (billed under usage_metadata.agent_bricks_id, the endpoint coming as their name, since 0.21) | Measured | coût(W) (for an app, the workload whose app_name is the page's name); with billing from several workspaces, only the workload of the page's workspace, and no badge if it cannot be told apart |
| Notebook | Its serverless compute, plus the cost of its queries on warehouses ("≈" as soon as there are any) | Measured, plus attributed | coût(W) of the notebook + Σ coût(q) of its queries |
-
A link to another workspace (another host, or another
?o=than the page), to a run (/jobs/<id>/runs/...), a tab, a notebook cell or another sub-object has no badge: it is not the object whose cost is known. - While the last day of the period is not billed yet (section 8, item 5), the chip card says so: a dashboard, a Genie space or an agent gets a badge for that day only once its hours are billed. The warehouse badge already shows the bill that has arrived.
- Badges do not add up: a warehouse and the dashboards it serves show the same dollars, seen from two sides. The exact totals are those of the FinOps screens.
- The amount is rounded for display (two decimals below 10, whole units above, short notation beyond 100,000); the tooltip recalls the period, the price, the discount and the source.
6.2 Rounding to the cent
Calculations use exact values; only the display rounds. When several rounded amounts are shown with their total (the products of the overview, the teams of a tag, the rows of the table and projection CSV exports), they are rounded by the largest remainder method: each amount gets its lower cent, then the cents missing to reach the rounded total go to the largest fractions (the first one on a tie). The sum of the amounts shown therefore equals the total shown, to the cent, credits included.
Export cells (0.23). Every CSV file of the extension follows one rule (lib/csv.mjs): a text cell that starts with =, +, -, @, a tab or a carriage return, even after blanks, gets an apostrophe in front and stays text; an amount stays a number, negative included (a credit, a fall); a missing or non-finite amount is an empty cell, never NaN nor 0.
6.3 Findings to review (0.23)
The "Findings" view (the "To review" section of the studio) lists one finding per asset and situation. Findings are computed again at each read, from what was read: no new query. Each one gives the asset, the possible effect, the evidence (the system table or the rule, and the measured values) and a next action. An amount always says its nature: observed (usage measured in system.billing.usage, at list price), estimated (the same, minus the workspace's discount) or potential (a saving to confirm). Without readable billing, cost findings are "not evaluated" and the screen says so: no amount is shown, never 0.
| Finding | Rule | Amount | Severity |
|---|---|---|---|
| Health check checks | Each check of the health check, asset by asset (at most 1,000 findings per check, the most read tables first; the health check and the catalog keep them all) | none | the check's; "for info" becomes "useful" |
| Team rules | Each imported rule, table by table, with the value that breaks it (last write, missing item, name, readers, link) | none | the rule's |
| Failed runs | A job with at least one run of the period ending in FAILED, ERROR or TIMED_OUT (section 6, "Cost of failures") | the cost of the failures, observed or estimated | priority if the last run failed or the share of failures reaches 50%; to check from 5%; useful below |
| No read observed | An inventory table with no read over the activity window (health check), or a table with no read observed over the period of the costs ("Table with no read observed" row above) | potential: rafraîchissement(T) × (365 / 12) / N, said "to confirm" | to check with an amount, useful otherwise |
| Spend rising sharply | coût(W) ≥ 1,5 × coût_précédent(W) and coût(W) − coût_précédent(W) ≥ max(1, 2 % de la dépense de la période) (at least 1.5 times the period before, and a gap of at least 1 and at least 2% of the period's spend), against the period before of the same length (section 7.1), after the same discount. A workload with no spend the period before is not a rise | the gap, observed or estimated | to check |
| Team tag missing | A workload that cost something over the period without the team key in its main tags (section 8, limit 4). The team key is, among team, equipe, équipe, owner_team and squad, the one that covers the most spend | its spend, observed or estimated | useful |
What a missing team tag means: YALineo's spend per team (section 10.1) files each workload under the value of that key; a workload without it counts in the "Without the tag" line. No other rule assigns it to a team. When no workload carries a team key, this finding is not evaluated, and the screen says so. Likewise, failures are evaluated only if the outcome of the runs was read, rises only if the period before was, savings only if the attribution to tables was.
The personal follow-up. Each finding can be "To review" (the default), "Checked by me" or "Ignored", with a note. The follow-up keeps the day and the signature of the observation: the measured values (date of the last write, failures and runs, amount at list price, sensitive sources upstream, rule and value that breaks it, tags read). A new discount therefore changes no observation. If the signature changes at a later read, the finding goes back to "To review" and says "Changed since your check on …". A finding no longer observed leaves the list, whatever its follow-up. The follow-up stays on the device, workspace by workspace, with the retention rule of the maps (erased when the browser closes, or kept if the user chooses "Keep"): at most 2,000 findings, notes of 300 characters.
6.4 The sheet of an asset (0.23)
The sheet of a table, a view, a workload (job, pipeline, SQL warehouse, serverless notebook...) or a consumer (dashboard, query) creates no figure: it takes those of sections 4 to 6, for one asset.
- The whole asset: the spend and table filters (section 7) do not apply to it; the workspace discount does.
-
A table: its
refresh(T)andread(T)over the period (sections 5 and 5.8), then each part they are made of: the workload that pays, its rule (precision of section 5.7), the share of its workload (part.share) and the amount. Parts are rounded by the largest remainder (section 6.2); the refresh shown is the sum of the parts shown, the total the sum of the two lines shown. Per read, per million rows, at a month's pace and the upstream chain are the derived indicators of section 6. -
A workload:
cost(W), its DBUs, its runs and the cost of its failures (section 4), then the identity of section 5.6 (tables, reads, tables outside the map, idle capacity, not attributed), rounded the same way: the lines shown add up to its cost shown. The previous period is the same workload read over the period before (section 7.1), after the same discount. - A consumer: the cost of its queries on SQL warehouses (section 6, already in the cost of the warehouses, never added) and the cost of the data it depends on (upstream chain, section 6).
Nature shown. Each amount carries one of three natures, from its rule:
| Nature | Rules | Why |
|---|---|---|
| Observed | cost of a workload; "billed" part (section 5.1); cost of failures | read as is in system.billing.usage |
| Attributed | "single table", "compute time", "warehouse"; cost of a consumer's queries | a measured cost given by a measured link (the run that wrote the table, compute time, the warehouse hour) |
| Estimated | "even split", "period"; reads on SQL warehouses | the least certain rule (section 5.7), or a read that is always estimated (section 5.9) |
A table that receives several parts takes the least certain nature of its parts, like its precision.
Billing not read. When the billing was not read (a file, an example without costs, the FinOps side switched off, rights refused, a failed read, no row for this workspace), the sheet says "Cost unavailable" and why: never 0, never an older value. The CSV export then leaves the amount cell empty and gives the reason.
Reads over 30 and 90 days. The map knows the reads of its activity window (direct and through views, section 5.8) and, since 0.20, those of the FinOps period. For 30 and 90 days when neither has that length, a click reads the events of the table on demand (yalineo:trend-table, 179 days): these are the direct reads of the last 30 and 90 UTC dates, today included, without those made through a view.
6.5 The cost overview (0.24)
The "Overview" page of the Costs section (titled "FinOps overview") creates no figure: it takes those of sections 3 to 7, over the period and with the filters chosen, and gives each one its nature. A single bar sets the period (7 days, 30 days, 90 days, 12 months, or two dates in the calendar, section 7), the FinOps filters and the export.
Four natures. They refine the three of section 1 for the screen:
| Badge | Definition | Nature in section 1 |
|---|---|---|
| Observed | read in system.billing.usage (or system.lakeflow for the outcome of runs), at list price | measured |
| Attributed | an observed cost shared between tables or schemas by the rules of section 5 | attributed |
| Estimated | an observed figure with an assumption added: the workspace discount entered, or a projection (section 7.2) | derived |
| Potential | a possible saving, to confirm before acting (tables with no read observed) | derived |
With a discount entered, the spend and the cost of failures go from "Observed" to "Estimated".
The six cards.
| Card | Figure | Nature | Curve | Change |
|---|---|---|---|---|
| Spend | Σ coût(W) | Observed (Estimated with a discount) | spend per day (spend), the period before dashed | section 7.1 |
| DBUs used | Σ DBU(W) | Observed | DBUs per day, when spend gives them | section 7.1 |
| Share paid for table refresh | Σ rafraîchissement(T) / spend | Attributed | none | section 7.1, always grey |
| Tables with no read observed | Σ rafraîchissement(T) of these tables, per month (section 6) | Potential | none | section 7.1 |
| Failed runs | cost of failures (section 6) | Observed (Estimated with a discount) | none | section 7.1 |
| Projection, next 30 days | 30-day projection and its range (section 7.2) | Estimated | measured spend per day | against the sum of the last 30 measured dates of the period, without colour: a projection is not a measure |
A card without a curve says why: the billing read gives neither the share of refreshes, nor the unread tables, nor the failures day by day (they are calculated over the whole period). Under a tag or "run as" filter, the spend per day does not add up (section 7, "Spend per day"): no curve, and the card says so. Each card opens its detail (the cost analysis set on its measure, tables, jobs or projections).
The essentials. Sentences written from the figures of the page, with no other source:
- the spend and its change from the period before (section 7.1); then the product group and the workload whose change goes furthest in the direction of the total (amounts of "Where the spend goes" and of the variations, below);
-
the average per day of the last 7 complete dates against that of the other dates of the period:
(average7 − average_rest) / average_rest, from 14 dates; an unsettled last day is left out (section 7.1); then the largest fall of a workload, if above 1; - the tables with no read observed (monthly potential), the cost of failures with the workload that has the most, and the range of the 30-day projection.
Look at first. The findings of section 6.3, calculated on the costs shown, filters included: the failure with the largest amount, the rise with the largest change, the tables with no read observed and the workloads without a team tag. Same rules, same thresholds and same natures as the "Findings" page.
Spend day by day. The spend query (section 7), by product. Products are ranked by spend of the loaded period; at most six are named, otherwise five and "Other products". Grain: the day up to 31 dates, the week up to 120, the month beyond; the day stays available up to 120 dates. Weeks are blocks of 7 dates that end on the last day of the period; the first may be shorter and is marked partial. Months are calendar months; an incomplete month is marked partial.
The period before is read day by day by the same query (spend, since 0.24, section 7) and aligned by position: the i-th date of the period against the i-th date of the period before, both counting as many dates. Its total per column is the dashed line, drawn only if its days add up to its total to the cent. A click on a column opens its detail: by product and by workload type, against the same positions of the period before, rounded by largest remainders (section 6.2). "See the data" shows each column, by product, with its totals to the cent. No marker (release, incident) is drawn: the system tables read hold none.
Why spend moved. A waterfall from the spend before to that of the period, one step per product group (the groups above). The spend of the groups is rounded to the cent by largest remainders, period by period, each on its total; the step of a group is cents(group, period) − cents(group, before). So total before + Σ steps = total of the period, exactly, to the cent. A workload counts under its main product of each period. Hovering a step names the workloads that explain it; a click lists them all, with the amounts of both periods rounded the same way on the step.
Where the spend goes. Three splits, each rounded by largest remainders:
-
Product:
Σ coût(W)per product group, its share of the spend and its change (section 7.1). The rows add up to the spend. A click filters the page on that product; -
Team:
Σ coût(W)per value of a tag key, the one the user chooses, otherwise the team key of section 6.3, otherwise the key that covers the most spend. Workloads without that key form the "Without the <key> tag" row, so the rows add up to the spend; a value that cost nothing in either period has no row. A workload's tags are those of its largest usage row (section 8, limit 4); -
Schema:
refresh + readof the tables of each schema (sections 5 and 5.9), the first eight, the others together. This is an attributed cost: it covers only a part of the spend (the rest is not attributed to tables, section 5.5), and the screen says so.
The strongest variations. Each workload against itself in the period before (same workspace, same id; absent from a period, it counts 0 there): coût(W) − coût_before(W), the six largest rises and the six largest falls of at least one cent. A workload that only launches other jobs (section 4.1) is not listed.
The curve of each workload named on the page comes from a query run on demand, yalineo:work-days: the spend per day of these workloads alone, over both periods, with the expressions of the costs query (section 4). The workloads go in a named parameter (:keys, at most 40, as TYPE:id), the end in a date parameter never after today, the length in an integer of at most 365 days. It runs once per period and list of workloads, after the page is shown, never while the map loads. Over the same dates, the sum of a workload's days equals its cost from the costs query (Spark test). Without a workspace that can be queried (the example, a file), there is no curve, and the row says so.
Export. The CSV of the page gives each card, each day by product, the total of the period before per day, each step of the waterfall, each split and each variation, with the period, the period before, the unit, the nature and the currency. The amounts are those of the screen, to the cent; each split (products, teams, days) adds up to the spend. Cells are neutralised against formulas, like the other exports.
6.6 Views by workload type (0.24)
The Costs side sorts its lists "by workload type": Jobs and compute, Tables, SQL warehouses, AI and Genie, Catalogs and schemas, Teams and tags. These views create no cost: each amount is one of those of sections 4 to 6, over the period and with the filters of the side, after the discount entered. The period before is read by the same queries and the same attribution (section 7.1).
Key figures and their nature. Each view starts with a row of figures. An amount carries its nature: Observed, Attributed, Estimated (section 6.4) or Potential (a saving to confirm, section 6.3). A number or a ratio has no label: it is measured or derived (section 1).
| View | Figure | Formula | Nature |
|---|---|---|---|
| Jobs and compute | Cost | Σ cost(W) of the workloads of the list's filter | Observed |
| Runs | Σ runs(W) (section 4) | measured | |
| Average cost per run | Σ cost(W) of the workloads that have runs / Σ their runs | derived | |
| Failures | failed job runs, and their share of the runs of the jobs whose outcome was read | measured | |
| Cost of failures | section 6 | Observed | |
| Tables | Table cost | Σ [refresh(T) + read(T)] of the tables listed | Attributed |
| Reads | Σ reads(T) of the tables listed (section 6) | measured | |
| Refresh per read | Σ refresh(T) of the tables read / Σ their reads | derived | |
| No read observed | number of tables (section 6), and Σ refresh(T) × (365 / 12) / N | Potential | |
| SQL warehouses | Cost | Σ cost(W) of the warehouses | Observed |
| Queries | statements of system.query.history on these warehouses during the period (total rows of the work query) | measured | |
| Average cost per query | Σ cost(W) of the warehouses with at least one query / Σ their queries | derived | |
| Capacity without queries | Σ idle_capacity(W) (section 5.4), and its share of the warehouses' cost | Attributed | |
| Table reads | Σ to_reads(W); below, the writes Σ to_tables(W) (attributed) | Estimated | |
| AI and Genie | AI cost | Σ cost(W) of the Agent, Genie, serving endpoint, AI Search and App workloads | Observed |
| AI workloads | number of these workloads with a cost | measured | |
| Genie questions on warehouses | Σ cost(q) of the queries of Genie spaces (section 6), already in the warehouses' cost | Attributed | |
| Calls and messages | not in the billing, which counts DBUs: "Not billed", never 0 | ||
| Teams and tags | Spend, Untagged | section 10.1 | Observed |
| Tag coverage, Teams | share of the spend carried by the workloads that have the key; number of values | derived | |
| Catalogs and schemas | Refresh; reads on warehouses | section 5.9 | Attributed; Estimated |
| Projections | Projected cost, DBUs and cost per day; measured over the period | section 7.2 | Estimated; Observed |
Change. Each card, each workload, each table, each catalog and schema, each tag value is set against the same thing over the period before: x − y and (x − y) / y, with the variation rule of section 7.1 (bands, arrow, sign and amount). A workload, a table or a value absent from the period before counts 0 there: it is "new". Failures are compared only when the outcome of the runs was read for both periods; tables and catalogs, only when the attribution to tables was read the same way. In the list of jobs, a filter that depends on the period itself (rising, failing, not attributed) or on chosen tables does not carry over to the period before: its cards are not compared, and the screen says so.
Small charts.
-
The "Cost" card (Jobs and compute, SQL warehouses, AI and Genie): the spend per day of the
spendquery for these workload types, each date of the period (0 on a day without usage rows). No line under a tag or run-as filter (the spend per day does not follow them, section 7), nor when the days do not add up to the card's cost to the cent (a workload billed under two products or two computes, under a product or compute filter): the screen says why. -
Each row (workload, warehouse, AI workload, tag value): the optional
yalineo:seriesquery, read with the costs. For each workload (the sameCASEas section 4, the same prices as section 3):Σ cost(u)of its usage rows per date, day by day for a period of 31 dates or less, week by week past that (weeks ending on the last date of the period, the first one cut by its start). A workload's points add up tocost(W)to the cent, checked on Spark. Only the 2,000 workloads with the largest absolute cost of the period are read (at most 2,000 × 53 rows): past them, the row says "not read", never a line at 0. A job that only launches other jobs has no usage row: its points are 0. A tag value has the sum of its workloads' points, only when all of them were read. Without this query (a map loaded before 0.24, a failed query), the column is not shown and the screen says so. - The top 5 workloads (Jobs and compute, SQL warehouses, AI and Genie): the points of the five most expensive workloads listed, stacked, then "Others": the sum of the points of the other workloads listed, only when all of them were read. Each bar therefore adds up to the spend of the workloads listed for its date or week. A first week shorter than 7 dates is drawn paler and says so. A negative point (a billing correction) leaves the chart out rather than distort it.
- A table has no line: its cost is attributed over the period, run by run (section 5.2), never day by day. The screen says so.
-
Projections: the measured spend of each date of the period (the same rule as the "Cost" card), then each day of the window at the same amount,
projected cost / H, betweenlow / Handhigh / H(section 7.2). Derived.
SQL warehouses. Per warehouse: cost(W) = idle_capacity(W) + writes(W) + reads(W) + rest(W), where rest holds the part not attributed and the tables outside the map (identity of section 5.6), to the cent in the export. Queries: the number of statements of the query history run on the warehouse during the period. Size and auto-stop: cluster_size and auto_stop_mins from the workspace list of warehouses (GET /api/2.0/sql/warehouses, already read for their names), kept with the map. A warehouse absent from that list (deleted, not visible with the user's rights, map loaded before 0.24) shows "unknown". Without the query history, queries and idle capacity are "not read", never 0. The state of queries (failures) is not read. The list "Table reads on the warehouses" takes read(T) of section 5.4, estimated.
AI and Genie. The cost of each type (Agent, Genie, serving endpoint, AI Search, App), rounded by the largest remainder (section 6.2): the types add up to the AI cost to the cent. The questions of Genie spaces are listed apart: attributed, already in the warehouses' cost, never added to the AI cost. The number of calls or messages is not in system.billing.usage: it is said "Not billed".
AI and Genie, by product (0.28). Each AI line carries its product (Genie Code, Genie One, Genie Agents, Knowledge Assistant, Model Serving...), read from documented billing fields (section 4.3); "By product" replaces "By type" and adds up to the AI cost to the cent. Genie spaces are called Genie Agents today: their questions stay listed apart, beside the Genie Agents line (their language model, all together), never added to it.
Teams and tags. The spend per team of section 10.1, over the period and with the filters of the side: each workload under the value of the chosen key in its tags (those of its largest usage row, section 8, limit 4), the workloads without that key in "Untagged". Default key: the team key of the findings (team, equipe, équipe, owner_team or squad, the one covering the most spend), else the key covering the most spend; the reader picks another among those of the billing. The lines, rounded by the largest remainder and shown to the cent, add up to the total of the period. Main workload: the value's workload with the largest cost. A click on a value applies the tag filter key = value to the whole side (section 7); "Untagged" cannot be filtered (there is no "without" filter), nor a key that holds "=". A tag key or value is never an object key: __proto__ is a key like any other (attack test).
Exports. Jobs and compute, SQL warehouses, AI and Genie, Teams and tags: each amount column rounded by the largest remainder, the "total" line equal to their sum to the cent; each workload carries its whole name as billed (the path of a notebook, which the list shortens), or else its kind and id; the cells go through lib/csv.mjs (a name that looks like a formula stays text, an unknown amount is an empty cell). Genie questions follow the "total" line of the AI workloads, on lines of their own.
Cost map. The list "Schemas by cost" adds up, for each schema, Σ [refresh(T) + read(T)] of its tables (the rule of the stations, section 7), rounded by the largest remainder; a schema opens the cost of its tables.
6.7 Why a cost is missing or zero (0.26)
Wherever YALineo shows a cost (the sheet of an asset, the "Costs" block of the catalog and of the dependencies, the lists of the Costs side), a figure that is zero, missing or only a share of a larger bill carries a "Why?" link. It opens a short list of reasons. No reason creates a figure: each one restates a rule of sections 3 to 8, with the values read (a date of the lineage, a cost, a number of runs or reads), and the action that would change the figure. The function costReasons (extension/lib/cost26.mjs) computes them; the page only shows them.
| Code | What YALineo says | Rule | Action offered |
|---|---|---|---|
billingDenied, billingFailed, billingEmpty, billingNotLoaded, billingOff, billingFile, billingNoMap | The billing is not read: refused (the grant the Databricks message names, else SELECT on system.billing.usage and system.billing.list_prices, read together), failed, empty for this workspace, not loaded, switched off, or absent from a file or from a map not loaded yet. No amount, never 0 | 2, 6.4 | Copy the SQL for an admin (docs/Admin_Grant.sql), load again, settings |
view | A view or a metric view is never refreshed; its cost is read(V), and its reads count for its sources | 5.8 | |
filtered | The spend filters leave out the workload that pays; the amount without them is given | 7 | Remove the spend filters |
createdAfter | Table created (information_schema) after the last day of the period | 7 | Include today |
noWrite, writesUnknown | No write in the lineage over its window: nothing to pay for, or a write outside the lineage; or the activity of the tables was not read with this map | 8, point 2 | Open in Databricks, load again |
writtenBefore | Last write observed before the first day of the period | 5.2 | Widen the period (the shortest length of the list that covers that date, a year at most) |
writerNotBilled | Written by a job, a pipeline, a notebook or a query with no billing row in its name over the period: a job on an interactive cluster (billed to the cluster), a notebook on a classic cluster, no run, a job that only launches other jobs, a workload of another workspace (only this workspace's billing is read) | 2, 4, 4.1, 5.4, 5.5 | Open its sheet, open in Databricks, widen the period |
writerNotTied | Written by a billed workload none of whose billed runs is tied, in the lineage, to a write of this table; the runs with no write observed and their cost | 5.2 | Open its sheet, widen the period |
writerUnknown | Written by queries the lineage ties to no job, pipeline or notebook: a cost only on a SQL warehouse, through the query history | 5.4 | Open in Databricks |
sharedWriter | Paid by a workload that pays for others: its cost, the table's part (the one of the sheet) and its rule, the other tables, the rest; the three add up to the workload's cost to the cent | 5.2, 5.4, 5.7, 6.2 | Open the workload's sheet |
belowCent | A refresh of less than a cent | 6.2 | |
attribPeriod | Map read without the attrib query: spread over the period | 5.7 | Load the costs again |
perReadTiny | Cost per read under a cent: shown "less than $0.01", with its value | 6 | |
noRead, readsUnknown | No read observed over the period, neither direct nor through a view; or the reads were not read with this map | 6, 8 point 6 | Load again |
readsNotOnWarehouse | Reads, none by a query on a SQL warehouse: those of jobs and pipelines are in their own cost, those through a view stay with the view, those of dashboards, queries and Genie spaces count only on a warehouse | 5.4, 5.8 | |
noQueryHistory | Query history not read: neither reads on warehouses nor rows written (the missing grant when it was refused) | 5.4 | Copy the SQL for an admin, load again |
noRowsMeasured, noRowsWritten | No cost per million rows: no row measured (writes on classic compute, absent from the query history), or 0 row | 5.2, 6 | |
notBilled | A workload of the lineage with no billing row in its name over the period; its last activity seen | 4 | Open in Databricks, widen the period |
launcherOnly | A job that only launches other jobs: 0 of its own, the cost of the launched jobs beside it | 4.1 | Open the launched job |
unpriced | Usage with no list price: partial cost | 3 | |
noTablePaid, partlyUnattributed, clusterNoTable, serviceNoTable | Spend tied to no table: runs with no write observed, views, tables outside the map, an interactive cluster; agents, Genie, endpoints and apps, which write no table and count in "AI and apps" | 5.5, 5.6, 6 | |
levelTables | A catalog or a schema at 0: its tables counted by their first reason | 5.9 | See its tables, widen the period |
listPrice, openDay | Good to know: list price with no discount entered; last day not fully billed yet | 3, 7.1 | Enter a discount |
Names read from the workspace (jobs, tables, warehouses) stay text in the list, and the CSV export of the sheet adds one why row per reason, neutralised like every other cell (attack test in tests/security.test.mjs).
6.8 What YALineo counts, what Databricks shows (0.28)
A figure of YALineo that can be compared with a Databricks screen says the same thing, or says exactly why it differs. Every Databricks behaviour cited here comes from an official page, read on 2026-10-28; what those pages do not say is written "not documented".
Reads: direct reads only. The page "Lineage system tables reference" (https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/lineage), column direct_access: "When false, the source is an intermediate dependency discovered through view expansion. For example, if a query reads from a view, the lineage record for the view's underlying base table is recorded with direct_access = false." A query on a view therefore leaves one row for the view and one row for each table under it. Before 0.28 the read queries counted both: a table read through a view counted that read once in its own activity, then a second time through lectures_par_vues (section 5.8), so its cost per read was too low. Since 0.28:
-
lectures_directes(T)counts only the rows wheredirect_accessis notfalse(coalesce(direct_access, true)): queriesactivity,attrib(reads of the period) andtrend-table(reads day by day).lectures_par_vues(T)then adds them once, through the walk over views. A view read once gives 1 read to its base table, never 2 (Spark test). -
The readers of a table ("Read by",
entitiesquery) are its direct readers: a dashboard that reads a gold view built on a silver table reads the view, not the silver table. There is no false "report on bronze or silver" any more, and the impact analysis no longer puts it at the first level of the silver table. -
A warehouse query that reads a view pays the read of the view (
work), in full: "the cost of those reads stays with the view" (section 5.8) was not held when the tables under the view each took a share. -
A metastore without the
direct_accesscolumn yet gets the former forms (fallback variants): its reads are counted as before, with limit 15 of section 8.
The activity window counts the last N UTC dates, today included (still running): "30 d" covers 30 dates, like the on-demand reads of the sheet (trend-table). Before 0.28 it covered 31. The FinOps period ends the day before by default (section 7). Since 0.29, the lineage queries (links, readers and writers, activity, volume estimate, columns, job names) count these dates from :today, the browser's UTC date that the cost queries of the same load also receive (section 7, "Today"), sent as a named date parameter. The trend of a table and "Why no link?" (section 6.10), read later on demand, start from the UTC date of the day they are asked for. Before 0.29, these queries started from current_date() of the SQL warehouse, which follows its TIMEZONE parameter ("The system default is UTC", Microsoft Learn, TIMEZONE, read on 2026-10-29): a time zone set otherwise by an administrator shifted their windows by one day from the costs. Two queries keep current_date() and count nothing shown: the rights probe (probe, one day of lineage) and the lookup of a SQL warehouse's workspace in the billing of the last 35 days.
Where reads and writes come from. The activity query reads, in the same pass, the rows with no entity (entity_id NULL) and the reads that write another table or path (target_type set: "Read and write", section "Reading lineage system tables" of the same page). The documentation says of rows with no entity: "If all the values in entity_metadata are null, it means no Azure Databricks entity was involved in the event. For example, it could be the result of a JDBC query or from a user clicking into the Sample Data tab". The sheet therefore no longer says "no reader observed" beside 44 reads: it says how many reads come from a named object (job, notebook, dashboard, query), how many write another table (they are downstream), and how many have no Databricks object attached. The same for writes ("no job, pipeline or notebook identified; 22 writes with no Databricks object attached"). Since 0.29, a write counts once per write event. A statement that reads several sources to write a table leaves one row per source (the example of the same page: a query that joins two tables leaves two rows to its target), and a source that is a view adds one row per table under it (direct_access = false); these rows share their event_id: "Multiple rows may share the same event_id if they were generated by the same event" (same page, read on 2026-10-29). The activity (writes, writes with no object), entities (writes of each writer) and trend-table (writes day by day) queries therefore count distinct event_id values, and the row's own record_id when event_id is empty (one row, one event). A job that reads two tables and a view to write a table leaves four rows and counts 1 write, never 4 (Spark test). Before 0.29, each row counted. On a metastore without the direct_access column, the former forms still count one write per row (section 8, limit 19). The days written, the last write, the freshness and the rhythm (section 6.9) count only dates and do not depend on it.
Catalog Explorer's "Popularity" counts something else. Page "View table insights and popularity" (https://learn.microsoft.com/en-us/azure/databricks/discover/table-insights): "The popularity metric is determined by the total number of interactive reads of a table, including reads from JDBC, the SQL Statement Execution API, SQL connectors, and sample data clicks in Catalog Explorer. Hover over a table's popularity icon to see how many times it was queried in the last 30 days." The lineage "represent[s] a subset of all read/write events, as it is not always possible to capture lineage. Records are only emitted when lineage can be inferred" (lineage tables page). The two numbers do not measure the same thing and can differ a lot (1,394 queries against 0 or 44 reads). How popularity is computed exactly, and whether it counts a view or its tables, is not documented; no system table gives it (not documented). system.query.history has no column of the tables read (page "Query history system table reference", https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/query-history): it cannot give a count per table. The statement_id link between the two tables only holds for queries on a SQL warehouse or serverless compute, and stays limited to the lineage rows emitted. YALineo therefore keeps the lineage count, with its scope said: the tooltip of the catalog's "Reads" column, the sheet and the chip's card recall it.
A view is never written. Lineage rows whose target is a view are not a write of data: a view stores nothing (section 5.8). When Databricks emits them (the view created or replaced, or each query that expands it) is not documented. For a view or a metric view, YALineo shows no "Last write", no "Write rhythm", no freshness and no lateness: the sheet says "Not applicable: a view stores no data", "Defined on" (its direct sources, as Catalog Explorer lists them), and "Lineage rows into the view" with their number, their days and the latest one, shown as lineage rows. The storage format is never shown for a view, nor when Unity Catalog returns UNKNOWN_DATA_SOURCE_FORMAT. A view never enters "late" nor "no read observed" (already so since 0.21).
Badges in Databricks pages: never a silent absence. Since 0.28, every object the map knows gets a badge (section 6.1); only an object absent from the loaded map gets none, and the card of its page says "Not in the loaded map".
| Case | Badge | Tooltip (reason) | Rule |
|---|---|---|---|
| A cost of a cent or more | The amount, as in 6.1 | As in 6.1 | 6.1 |
| A cost above 0 and under a cent | "< $0.01" | "Less than a cent over the period." | 6.2; before 0.28, no badge |
| View, metric view with no reading cost | "$0 · view" | "View · no cost of its own · read N times over D days", then: a view is never refreshed; its reads by jobs are in those jobs' cost; on a SQL warehouse they count when the query history is readable; the difference with "Popularity" | 5.8, code view (6.7) |
| Table with no write observed | "$0 · no write" | No write observed in the lineage | noWrite, writesUnknown |
| Table written before the period | "$0 · written before" | Last written before the period | writtenBefore |
| Table created after the period | "$0 · created after" | Created after the end of the period | createdAfter |
| Table whose writers are not billed | "$0 · not billed" | A job on an all-purpose cluster is billed to the cluster (usage_metadata.job_id "does not populate for jobs run on all-purpose compute", page "Billable usage system table reference") | writerNotBilled |
| Table written by a billed workload with no run tied, or by queries with no object | "not attributed" | The reason of its code | writerNotTied, writerUnknown |
| Table paid by shares adding up to 0 | "$0" | "Billed 0 over the period." | |
| Catalog, schema of the map with no table at an attributed cost | "not attributed" | No table of this level has an attributed cost | levelTables |
| Job, pipeline of the lineage with no billing row | "$0 · not billed" | No billing under its name (all-purpose cluster) | notBilled |
| Job, pipeline, SQL warehouse billed 0 (all its rows of the page's workspace) | "$0" | "Billed 0 over the period." | 4 |
| Notebook, dashboard, query of the map with no billed query | "$0"; "cost unknown" when the query history is not readable | The reason | 5.4, noQueryHistory |
A badge without an amount has a dashed outline, quieter than a cost. It never holds a name read from the workspace: only numbers and a word from a fixed list, in the language of the computer (seven languages). A serving endpoint, an app or a Genie space the billing does not know gets no badge (the map only knows them from the billing). With no billing loaded, no badge, as before: the chip's card and the settings say why.
Job names (section 4.2). The order is: the name from system.lakeflow.jobs (the latest row per workspace_id, job_id, as the page "Jobs system table reference" shows it, https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/jobs); else the run_name of its latest run (system.lakeflow.job_run_timeline), marked "name of its latest run" (or "one-time run" for a SUBMIT_RUN or a WORKFLOW_RUN); else the id, with the reason in the tooltip ("Name unknown": read and absent, read refused or failed, or a map loaded without the names). The page says a job can be missing from system.lakeflow.jobs when it was created in another region or very recently ("Recent job creation (table lag)"); the table is regional; "the latest historical entry for each job_id [...] is always available". It defines run_name as "The user-supplied run name associated with this job run": that it is the job's name for a JOB_RUN is not documented, hence the mark. Since 0.28, every saved job that has a run (run_type = JOB_RUN) over the links' window is read this way, whether the lineage or the billing names it or not; one-time runs stay bounded to those the lineage or the billing names (an orchestrator can submit thousands). In the FinOps view, the name from system.lakeflow.jobs comes before the one the billing carries (usage_metadata.job_name, "User-given name of the job", set for serverless jobs only); when only the billing names the job, its latest name is kept (max_by over the end of the usage row), never the largest in alphabetical order.
Proposal, not applied. Giving a view a share of the cost of the jobs that read it would mean cutting the cost of a run between what it writes and what it reads; the current method gives the whole cost of a run to the tables it writes (section 5.2), and the identity of section 5.6 would no longer hold if a share also went to the view. This choice is the project owner's.
6.9 Write rhythm and freshness of a table (0.28)
Write rhythm. write_days(T) (column write_days of the activity query) counts the dates on which the lineage saw a write of T during the activity period (:days, the "Period" setting). The usual interval is max(1, activity days ÷ write_days(T)) days, from 3 written dates; T is late when its last observed write is older than max(2 × interval, interval + 6 h), or more than 8 days without a known rhythm. The divisor is always the activity period, the one write_days is counted over: before 0.28, "Late tables" (Analytics), the table explorer, the proposed refresh tag, the proposed description and the "refreshed every day" point of the "delay" severity (section 11) divided by the link window (365 days by default). A table written 20 days out of 30 then stopped for 10 days had an interval of 18.3 days instead of 1.5 and was missing from "Late tables"; a table written every day was given refresh=monthly. The sheet and the followed tables already divided by the period.
Freshness. It comes from the last write the lineage observed during the activity period, and from nothing else. information_schema.tables.last_altered is "Timestamp when the relation definition was last altered in any way" (TABLES, Microsoft Learn, read on 2026-10-28): a definition date, never a write. It gives no freshness level and no lateness, and shows as "definition changed on …" when nothing else is known. A table with no observed write, read or not, says "no write observed in N days", N being the activity period read (when the activity answer was not cut at its limit, for a table with no row). A NULL date returned by the SQL warehouse stays unknown, never 1 January 1970. Before 0.28, a table with no event at all took its freshness from last_altered and could be "late", while a table read 120 times with no write had an "unknown" freshness. The catalog export (last_write), the explorer ("last write") and the freshness sort no longer take last_altered for a write.
6.10 Upstream, downstream, bridged links and names read (0.28)
The upstream and downstream counts, the bridged links, the external paths and the names read create no cost: they are counts of the lineage loaded (measured) or figures drawn from it by a rule written here (derived). They say what the map sees and why it can differ from Catalog Explorer.
Direct neighbours, then the whole chain. The chip in Databricks, its card, the sheet of an asset, the catalog and the panels first give the direct neighbours, as the Lineage tab of Catalog Explorer does: the assets linked to it by a link of the map, reads by dashboards, queries and notebooks included, and, for a job or a pipeline, the tables it writes (directNeighbours, extension/lib/model.mjs). Two kinds of links are not part of them: a link the lineage only saw through a view (all its rows carry direct_access = false; the view is the direct neighbour, section 6.8) and a link that exists only as a bridge (below). Then comes the whole chain, named as such ("Whole chain: x upstream, y downstream"): every asset reached step by step through every link of the map, both kinds included. Example (tests/v0280-coh28.test.mjs): a view defined on a fact table, itself fed by three tables, one of which receives 17 feeds, shows "1 upstream" and 21 over the whole chain. Consumers (dashboards, queries, notebooks) are counted the same way, direct then over the chain.
The link window. The map reads links over the link window (:link_days days, 365 by default, chosen in the settings). The Lineage tab of Catalog Explorer shows one year by default: "The default selection is 1 year" (Microsoft Learn, Lineage in Unity Catalog, Retention part, https://learn.microsoft.com/azure/databricks/data-governance/unity-catalog/data-lineage, read on 2026-10-29). When the map's window counts fewer than 365 days, the chip's card says so ("Links read over N days; Catalog Explorer shows the last year by default"): an older link can be missing from the map and appear in Catalog Explorer. In analyst mode (lineage API), this remark does not apply.
Bridged links. When the inventory (system.information_schema.tables) was read in full, a table only the lineage knows, in a schema where the user reads other tables, is removed from the map: dropped since (often a temporary or checkpoint table of a job), or not readable with the user's rights ("The rows returned are limited to the relations the user is privileged to interact with", Microsoft Learn, TABLES, https://learn.microsoft.com/azure/databricks/sql/language-manual/information-schema/tables, read on 2026-10-29). Each pair made of a link a into that table and a link b out of it gives a link from the source of a to the target of b, marked "bridged", with the table crossed and its reason. Its figures are its own, kept apart (edge.bridged):
événements(raccord) = min(événements(a), événements(b))
premier(raccord) = max(premier(a), premier(b)) unknown if either half has no start date
dernier(raccord) = min(dernier(a), dernier(b))
(raccord bridge, événements events, premier first seen, dernier last seen.) A bridge is therefore as old as its newer half and as recent as its older half. Several tables crossed between the same two assets add up their events and keep the first start and the last end; a half that is itself a bridge counts with its own bridge figures. These figures are never added to the events, dates or objects observed between the two assets. A link also observed directly keeps its observed figures, and the bridge is said beside them; a link that exists only as a bridge has no observed figure (0 events, empty dates), is said "inferred" in the evidence of a relation, is not a direct neighbour, but stays in the whole chain. For the link period filters and old links, its last date is the later of the two: its own and its bridge's. Bounds: a table that would need more than 2,500 bridges (links in × links out) stays on the map, and the bridges made in all do not exceed the number of links of the lineage, or 5,000 when it has fewer; beyond, the tables stay. The coverage of the map counts these links ("of which N bridged"), and the impact analysis says how many tables were removed (section 11.1). On the cost side, the share of a removed table stays counted in "tables off the map" (section 5.2).
Tables of Databricks internal catalogs (0.34.3). They leave the map the same way, but always (inventory read or not, pre-flight included) and first: their links are bridged within the same bounds, and their writes kept for the split of the costs (section 5.2). An internal table that would need more bridges leaves all the same: its links are not drawn and their number is said on the map's note. A bridge never names an internal table, it counts it ("1 Databricks internal table") and gives its reason ("Databricks internal catalog, hidden by YALineo"); a bridge that crosses both kinds of tables gives both reasons. The coverage, the map's note, the tooltips and the impact analysis count apart the internal tables removed and the links bridged across them; "gone tables hidden" and "links bridged across a table missing from the inventory" keep their meaning. A map saved before 0.34.3, a file and a kept load ("what changed") are read without them, their links bridged within the same bounds: a kept load therefore never shows those bridges as new links. A saved map is cleaned once per load (same fetchedAt), not on every read. In analyst mode, the exploration crosses an internal table at the level where it found it, without exploring it or starting from it, to reach what follows; the whole map never asks for it.
In the pre-flight (review of 0.34.3), an internal table too linked to be bridged stays on the map with its links, like a gone table: cutting its links there would under-report the impact past it, and in the pre-flight over-reporting is the safe side. The extension removes it.
Limit: an internal catalog this workspace does not see. The lineage does read the links that go through an internal table, which is what lets the paths be bridged, but only within the scope of the catalogs shown. With "this workspace only" (setting "Catalogs shown"), a link whose other end is in a catalog system.information_schema.catalogs does not list for the user (for example a colleague's __databricks_internal_catalog_lakeview_<colleague> catalog) is not read: the path that went through that table is not bridged. "The whole metastore" reads it. "Why?" counts those links under the rule of the internal catalogs.
External paths. A path read or written outside a table (source_path, target_path) is brought back to its folder, so that a folder read file by file (Auto Loader, for example) makes one link: partition folders (/key=value) are removed, and the last element is removed only when it follows a folder or a root and ends with a known file extension (the FILE_EXTENSIONS list of extension/lib/queries.mjs: parquet, csv, json, avro...). The scheme of the path (abfss://, s3://...) and the storage root (container@account, the bucket) always stay. Since 0.28, two storage accounts or two buckets are therefore two external sources, and a folder with a dotted name (exports/sales.v1) stays whole; before, the rule could merge two accounts into one source, or cut that folder. The same rule serves the links (edges), the estimate of a load (estimate) and "Why no link?" (why-links).
Why no link? (0.27). For a table with no upstream or no downstream, "Check over 365 days" runs on demand a read-only query (yalineo:why-links, one table, named parameters) over the last 365 days of system.access.table_lineage. Each link of that table (upstream: from a table or a path; downstream: to a table or a path, and the reads of a job, a notebook, a dashboard or a query) is counted once, under the first rule of the map that leaves it out, in this order: since 0.34.3, the other end is a table of a Databricks internal catalog (hidden, its links bridged; only the date of the latest is said, never its name), even in a catalog this workspace does not see; the other end is in a catalog this workspace does not see; neither end is in the catalogs chosen; the other end is a table the inventory does not list while it lists other tables of its schema (dropped or unreadable, its links bridged); the link was last seen before the link window; otherwise, the map should show it (first seen after the load, or missing from the map). Each group gives its number of links and the date of the most recent one, and the name of the most recent one unless it is in an internal catalog. Since 0.29, the reads of a job, a notebook, a dashboard or a query count there only when direct (direct_access is not false), like the readers of the map (section 6.8): a read through a view is a read of the view, never a missing link of the table under it; a metastore without the column gets the former form. The links missing from the map are the ones the map should show, minus the ones first seen after the load, minus the links the map observed: a bridged link is not observed (no lineage row joins its two ends, so the check cannot see it), it stays drawn but no longer hides a missing link. This number is never negative. The 365 days end on the UTC date of the day of the check (:today, section 6.8).
Names of dashboards and queries. The lineage gives only their ids; their names come from the workspace API lists (/api/2.0/lakeview/dashboards, /api/2.0/sql/queries), read page by page to the end, 20,000 names at most per list (1,000 before 0.28) and 1,000 pages at most. A list that goes beyond, that returns a page token already followed, or an empty page while announcing more, stops there: the assets of the map of that type left without a name are counted and said in the map coverage ("N dashboard or query names not read: names are read up to 20,000 per list"), and the health journal notes it. An asset with no name read keeps its id. No amount changes.
6.11 Erasing terms from the glossary (0.29)
After a failed import or an extraction that does not suit you, "Erase terms" (Glossary page, at the end of the terms bar) removes terms from the glossary kept on this device. Nothing is erased in Unity Catalog, nor in the published table: the glossary only gets there through the script its owner runs. Three choices (eraseTerms, extension/lib/glossary.mjs):
| Choice | What goes | What stays |
|---|---|---|
| The whole glossary | Every term, validated ones included, and the list of rejected terms (they will be proposed again) | The published table, the sector, the AI model and prices |
| The terms that came from an imported file | The terms whose sources are all a file: an Excel or CSV workbook, or the AI's answer imported | A validated term, a term another source also gave, and the rejected list |
| The terms extracted from Unity Catalog | The terms whose sources are all the extraction: comments, metric views, tags, columns | Same rule |
Before erasing, the panel gives the number of terms that go (and, for the whole glossary, how many of them were validated), the number of terms of the source that stay, and offers "Export first as CSV". A term typed by hand or read from the published table is never in the choice of a source. After the erasure, "Undo" puts the glossary back as it was, once it has been saved.
The erase password. It is asked before any erasure; a wrong password erases nothing. The code holds only its SHA-256; what is typed is compared on the spot, then the field is emptied: that text is never kept, sent or written in a message. It is a guard against an erasure by mistake, not an access control: the extension runs in the browser, and anyone can also remove terms by rejecting them in the list.
7. Filters
Two families, with different effects, stated on screen.
Spend filters (product, workload type, serverless or classic compute, tag, run as): they select workloads. Every figure, table costs included, is recalculated from these workloads alone, with the formulas above. Several values of one filter combine with "or", different filters with "and". For tags: several values of one key with "or", different keys with "and".
Checked consequence: the values of a filter form a partition. For example, the sum of the spend of each team (team=…) equals the total spend of the tagged workloads, and serverless plus classic equals the total.
Table filters (catalog, schema, domain, object type since 0.21): they select the tables to add up and list. They never change a table's cost. The "Selected tables" block gives the exact sum of their refresh and read costs and, for each workload, the share that pays for these tables. The sum of the selections of all catalogs equals the total attributed to the tables on the map (a table dropped since, absent from the map, belongs to no catalog shown).
Period: it reruns only the cost queries; the lineage map does not change. Three ways to choose it (since 0.13):
-
a length in complete days (7, 30, 90, 180 or 365 days), ending yesterday:
:days = durée,:end_days = 1. Today is excluded, because it is not over and billing arrives a few hours late. This is also the period of a map load (the activity window in the settings); -
today alone:
:days = 0,:end_days = 0. Its amounts are partial and the screen says so ("still running"); -
two dates, "From" and "to", inclusive, as UTC dates:
:days = aujourd'hui − du,:end_days = aujourd'hui − au. A single day is a period, today included. The dates are checked before anything is sent, and each refusal has its own message: a missing or impossible date, "From" after "to", "to" after today (the UTC date of the day is shown), "From" more than 365 days back. Nothing is reloaded while a date is refused. Both values are sent as named integer parameters, never in the query text; a start that is not an integer from 0 to 365 is never sent (nor replaced by another length).
Today (:today): the browser's UTC date, taken once per load and sent as a named date parameter to the four queries (and, since 0.29, to the lineage queries of the same load, section 6.8). They therefore read the same days, even if the load crosses midnight, and these days are the ones shown, whatever the warehouse's session time zone (usage_date is a UTC date). A value that is not a real date within one day of now is replaced by today's date.
Bounds applied by the four queries: usage_date and event_date (lineage) between date_sub(:today, :days) and date_sub(:today, :end_days); for timestamps (period_start_time of runs, start_time of the query history), from date_sub(:today, :days) and before date_add(:today, 1 − :end_days), that is, up to the end of the last day. A run counts on the date its slice starts, as before.
Days counted N (for the monthly cost and the "over N days" labels): each of the dates of the period, N = :days − :end_days + 1. Examples: September 1 to 30, N = 30; the last 30 complete days, N = 30; today alone, N = 1. A period that includes today counts that day in full even though it is still running: its monthly cost is then underestimated until the end of the day, and the screen flags it. The screen shows the number of days counted before applying. Costs loaded before 0.13 keep the number of days stored with them.
Previous period: with each cost load, the same queries costs, spend (since 0.24: the spend per day of the overview, section 6.5), runs, work and attrib also read the period before it, with the same number of dates and ending the day before its first day: :days' = :days + N, :end_days' = :days + 1. Example: the last 30 complete days (30, 1) are compared with the 30 days before (60, 31); today (0, 0), with yesterday (1, 1). It is not read if it would start more than 365 days back (system tables keep one year): the cards then say "No comparison". These queries are optional: if they fail, the cards say "Comparison unavailable" and nothing else changes; if only spend, work, attrib or runs is missing (for example a timeout on a long query history), the cards concerned say "Not comparable", and the others stay compared. They add five queries to each cost load; with the map, the previous period is kept without the work per consumer (dashboards, queries), which is not compared. A Spark test checks that two adjacent periods sum, workload by workload and to the cent, to the period that joins them.
Cost map with a followed table: when the map shows only the lineage of one table (the map's table filter), each station shows Σ (rafraîchissement(T) + lecture(T)) of its drawn tables only, and the list on the right shows the same amounts table by table. The sum of the stations therefore equals, to the cent, that of the tables of the lineage shown. Same rule for an isolated station (focus, since 0.14): the map keeps only the station's tables and the links that go through them, and each drawn station sums only its drawn tables. With no followed table and no focus, a station sums all the tables of its schema, as before. The card of a line sums the refresh cost of the line's tables kept by the table filters of the FinOps side (the "Domain" filter of this section, with the chosen line); on a reduced map (followed table, catalog, focus), only those that are drawn. Isolating the line therefore does not change its figure.
Spend per day: the spend query aggregates by day, product, workload type and compute. The chart therefore follows these filters. A tag or "Run as" filter cannot be followed day by day without multiplying the volume read; in that case the chart is hidden with an explanation, rather than showing a curve that would not match the totals. A workload billed under two products, or partly on serverless, counts in the totals under its main product and its main compute, but day by day under each: under a spend filter, the chart is therefore shown only if the sum of its days equals the total to the cent; otherwise it is hidden with the same explanation.
7.1 Card changes against the previous period
Each card of the overview (section 6.5) and of the panel shows its change from the previous period, calculated with exactly the same formulas, the same discount and the same filters as the period shown (sections 3 to 6 applied to the previous period):
| Card | Figure compared | Better when |
|---|---|---|
| Spend | Σ coût(W) | it goes down |
| DBUs used | Σ DBU(W) | it goes down |
| Paid for table refreshes | Σ rafraîchissement(T) / dépense, in points | neither: the share only says how the spend is split |
| Tables with no read observed | Σ rafraîchissement(T) of the tables with no read observed, per month | it goes down |
| Failed runs | cost of the failed runs | it goes down |
| Selected tables (table filter) | their cost and that of the tables with no read observed | it goes down |
"No read observed" applies to each period, with its own reads. Failures are compared only if run outcomes were read for both periods; the share of tables and the tables with no read observed, only if the attribution to tables was read the same way for both.
Change rule (variation, finops.mjs), with x the value of the period and y the one before:
-
change
x − y, and as a percentage(x − y) / y; for a share, the change in points; -
stable (grey) if the change is under 2%, or under 1 in amount, or under half a point for a share; "new" if
y = 0andx > 0(never "+∞"); -
otherwise, when a decrease is better: green for a decrease, red for an increase, in bold from 10% (since 0.30; before, an increase of 2 to 10% was amber). The thresholds are fixed and published (
VARIATION); - a share stays grey, whatever its change;
- a period whose last day's billing was not complete at load time keeps the colour of its direction since 0.30 (before, it stayed grey), and each change is preceded by "≈", with the reason in its tooltip: today (still running), or a last day that ended less than 12 hours ago (UTC) if billing does not yet hold its last hour (no usage row, across all workloads, ends at midnight after that day). Billing arrives a few hours late: a decrease marked "≈" may come from rows not published yet, and the screen says so under the title;
- when totals are negative (billing corrections in a filtered subset), the percentage change is relative to the absolute value before, and "new" is used only for an amount that goes from zero to a positive amount.
Color is never alone: each change has its arrow (▲, ▼ or =), its sign and its amount, and the tooltip gives the dates and the value of the previous period.
7.2 Projections of cost and DBUs
Since 0.17, the "Projections" page of the FinOps side says what the same usage would cost, and how many DBUs it would use, over the coming days if it kept its pace: for the platform, each product, each workload and each table. These are derived figures (section 1): never a measurement or a bill forecast, and the screen says so below the title.
Measured period and window ahead. The period of the FinOps side ("Measured over" on this page) is made of past days: that is where both paces are measured. The projected window is made of days to come.
Horizon (H days): the end of the month, 30, 90 or 365 days. It starts the day after the last day of the period, or today (UTC date) if the period ended before: a projection looks ahead, never back. "End of month" runs to the last day of the month of that start (a whole month if the period ends on the last day of a month). The window can also be chosen as two dates to come, "from" and "to", inclusive: the first day no earlier than the start above, the last day after the first, three years at most (1,096 days); H is then the number of days from one to the other. Refused dates are refused with their reason, and nothing is recomputed. The screen shows the dates and H.
Two paces per workload W, read in the same costs query as the other figures:
| Pace | Cost per day | DBUs per day |
|---|---|---|
| Of the period | p(W) = coût(W) / N | dbu(W) / N |
| Of the last 7 days | r(W) = coût7(W) / 7 | dbu7(W) / 7 |
coût7(W) is the spend of the last 7 complete dates of the period (fin − 6 to fin), the same as for "rising cost" (section 6); dbu7(W) (column dbus_7d, new in 0.17) sums the DBUs of these same dates, DBU unit only, like dbu(W). The recent pace exists only if the last 7 dates of the period are all in the period and complete: the period ends before today, has at least 7 dates, and its last day's billing was complete at load time (the 12-hour rule of section 7.1). Otherwise (a period that includes today, a last day not yet complete, fewer than 7 dates, a period whose "last 7 days" would spill over before it), the projection follows the period's pace alone, with no spread, and the screen says why. Costs loaded before 0.17 have no dbus_7d: their DBUs follow the period's pace.
Intermittent workload: a workload billed on fewer than one date per week, jours(W) × 7 < N, where jours(W) is the number of dates in the period on which it has usage (active_days). Seven days do not show its cycle: a monthly close that ran last week would be multiplied by four, and a close at the start of the month would drop to zero. It follows the period's pace, and the screen marks it "intermittent"; its spread starts at zero when it cost nothing in these 7 days. A regular workload stopped for more than a week is not intermittent: it follows its recent pace, zero, and its spread goes up to the period's pace.
Value and spread between the two paces of a workload:
-
value:
proj(W) = H × r(W), orH × p(W)for an intermittent workload or one with no recent pace; -
spread: from
H × min(p(W), r(W))toH × max(p(W), r(W)); the same rule for DBUs. These are the two measured paces, not a confidence interval: no probability is attached, and the screen says "between two paces".
Sums: the total and each product are the Σ proj(W) of their workloads, to the cent, and their spreads are the sum of the workloads' spreads (an envelope, wider than the gap between the two paces of the total when workloads move in opposite directions). A job that only launches other jobs (section 4.1) has no projection of its own: each launched job has its own, and nothing is counted twice.
Tables: proj(T) = Σ_W part(T, W) × proj(W), with the shares of section 5 (rafraîchissement(T) = Σ_W part(T, W) × coût(W)). A table therefore keeps its precision (section 5.7) and the share of each workload that pays for it. The sum of the tables' projections is the projected share of the workloads attributed to tables, not the total.
Pace change (card and "Recent pace" column): (Σ r(W) − Σ p(W)) / Σ p(W), or (r(W) − p(W)) / p(W) for a workload. Above zero, spending is speeding up. It compares the two paces themselves, whichever one each workload follows.
Discount and filters: the projection starts from the costs shown, so from the list price minus the discount entered, and from the workloads kept by the spend filters only. With table filters, the page adds the projection of the refresh cost of the chosen tables (Σ proj(T), without their read cost), lists only these tables and the workloads that pay for them (write or read), and the export follows the page. Every workload that has a figure is listed, credits (negative) and unpriced DBUs included: the rows sum to the cards.
Overview card: "Projection, next 30 days" is the value for the 30-day horizon, with the spread between the two paces below (section 6.5); a click opens the page.
Export: the CSV button writes one row for the total, one per workload and one per table: measured (cost and DBUs), projected, low and high bounds, projected DBUs, currency, dates and H. Workload amounts are rounded by the largest remainder method: their rows add up to the total row, to the cent (section 6.2). Names go through the common rule of the exports (section 6.2): a cell that starts with =, +, -, @, a tab or a carriage return stays text.
What is not projected: price or contract changes, workloads that did not exist during the period, seasonality (limit 10, section 8), unpriced usage (counted separately, section 3).
8. Known limits
-
List price, not invoice. Amounts are at the Databricks list price, minus the discount entered. The actual invoice depends on the contract (commitments, credits) and on the cloud provider's costs, which are absent from
system.billing.usage. - Lineage coverage. According to Databricks, the lineage tables are a subset of reads and writes: an event is emitted only when lineage can be inferred. An untracked write leaves the workload's cost unattributed, never wrongly attributed.
-
Compute time as the allocation key. Within a warehouse hour or a run that writes several tables, splitting in proportion to
total_task_duration_msassumes that the cost follows the compute used. This is the standard assumption; it ignores memory and scaling effects (a peak that starts an extra cluster costs more than its share of time). The hourly split reduces this effect without removing it. The screen shows it with the "warehouse" or "compute time" precision. - Main attributes of a workload. Product, "Run as" and tags are those of the workload's largest consumption. A workload whose tags change during the period is filtered by its main tags.
- Publication delay. Databricks updates the system tables a few hours late; the last days may be incomplete. A period that ends a few days before today avoids this effect.
- Reads. The number of reads comes from lineage: a read outside Unity Catalog (export, external tool without lineage) is not counted. "No read observed" is therefore a signal to confirm, never a proof nor a saving.
- Monthly figures. Linear extrapolation over an average month of 365/12 days does not account for seasonality.
- Comparison. Two periods of the same length can differ in their calendar (a closing month, public holidays): a change is a signal to explain, not a verdict in itself.
- Launched jobs. The link between a run and the "Run Job" task that launched it has existed in the system tables only since early December 2025, and only for the direct launcher. An older period shows launched jobs with 0 links.
- Projections. A projection extends a measured pace: it knows nothing of upcoming jobs, planned stops, seasonality or price changes. The pace of the last 7 days reacts fast to a rise, but also to an exceptional week; the spread between the two paces shows the other reading. A workload billed less than one day per week follows the period's pace (section 7.2).
- Calculator. Its figures are estimates at the public prices of a dated snapshot, plus the prices and discounts entered: no disks, no networking, no spending commitments, no price changes after the snapshot (section 13.6). Measured machine hours cover only the last 90 days and can miss nodes that ran less than 10 minutes: the coverage is shown (section 13.4).
-
Runs and lineage. Run-by-run attribution assumes that lineage carries the run id (
entity_metadata, orentity_run_idon an older metastore). When it is missing, the workload follows the fallback over the period, with the "period" precision. A run that writes outside lineage (untracked files, external connector) stays unattributed. - Rows billed over several hours. A warehouse usage row is spread over the hours it covers in proportion to time: a one-hour row is exact, a longer row assumes regular consumption over its duration.
-
Queries read again in parts. On a large workspace, an answer over the Databricks inline result limit (25 MiB) is read again in 8, then 64 parts (lineage,
attrib,work). Each part is one more statement on the chosen SQL warehouse: up to 1 + 8 + 64 runs for one query, and as many for the period before. That cost is the user's, on their warehouse; it shows in that warehouse's costs at the next load. -
Views and lineage. The lineage notes a query on a view as a read of the view, and also notes each table under the view, with
direct_access = false(documented, section 6.8). Since 0.28, YALineo counts only the read of the view and adds it once to its sources (section 5.8). On a metastore without thedirect_accesscolumn yet, the former forms are read and that read can count twice for the source tables: a sign of use, not an exact count. The type of an object comes from Unity Catalog (information_schema.tables) or, failing that, from the lineage. - Very long chains of views. The lineage keeps the links of a redefined view over its whole window: views redefined one after the other form a chain longer than what Spark accepts today. The walk of reads through views is therefore bounded (section 5.8); past the bound, reads are a minimum, marked "≥".
- Exactness of a catalog or a schema. A workload is judged on the objects the lineage sees it write over the period. A write outside the lineage (section 8, item 2) can therefore make "exact" a level it would have made "split"; the amount itself does not change.
- Names read. The names of dashboards and saved queries are read up to 20,000 per list (section 6.10): beyond, an asset keeps its id, and the map says how many names are missing. The names of Genie Agents (formerly Genie spaces) follow the same bound, without a count of those missing.
-
Reads counted per lineage row. Since 0.29, a write counts once per event (section 6.8). A direct read still counts once per row: a statement that reads one table to write two tables leaves two rows, hence two reads. It is a signal of use (point 6), not a number of queries. On a metastore without the
direct_accesscolumn, the former forms also count writes per row. The days written, the last write, the freshness and the rhythm count only dates and depend on neither number.
9. Verification
Automated tests, run for every version: the unit tests with npm test, and the SQL queries themselves with python3 tests/spark/finops_sql.py (Spark 4 in ANSI mode, synthetic billing tables whose answers are known, queries extracted exactly as the extension sends them).
| Property | Test |
|---|---|
| Cost per row at the price in effect, effective price first, negative corrections included, other workspace excluded, row without a price counted separately | tests/spark/finops_sql.py |
| Spend per day, per type and per compute, equals the sum of the workloads | tests/spark/finops_sql.py |
| Tags read per workload, old schema included | tests/spark/finops_sql.py |
| Period chosen with two dates: each query stops at the last day, the week compared is the last one of the period, a single past date counts alone, the days sum to the workloads to the cent | tests/spark/finops_sql.py |
| Today alone (0 days back) reads only today; two adjacent periods sum, workload by workload, to the period that joins them | tests/spark/finops_sql.py |
| A single day (today included) is a period, each refusal has its reason, the previous period has as many dates and ends the day before, a start outside 0 to 365 is never sent | tests/v0130.test.mjs |
| Cards compared with the same filters and the same discount, the change rule (bands, direction, zero, period still running), a stored and tampered previous period has no effect | tests/v0130.test.mjs |
| Dates checked before anything is sent (order, future, more than one year, impossible dates, tampered text), end sent as a named integer, days counted and monthly figures, older cards read as before | tests/v0110.test.mjs |
| Cost map with a followed table: the sum of the stations equals that of the tables of the lineage shown, to the cent | tests/v0110.test.mjs |
| Cost map with an isolated station (focus): the sum of the stations equals that of the drawn tables, to the cent | tests/v0140.test.mjs |
| Time per table: a query that writes two tables counts for half in each; total per warehouse limited to this workspace | tests/spark/finops_sql.py |
| Warehouses hour by hour: an hour's cost shared between its queries by compute time, a query across two hours counted in each, hours with no query as capacity apart, queries with no time evenly | tests/spark/finops_sql.py |
Run by run: single table, compute time, even split; the failed run unattributed; lineage with and without entity_metadata; the fallback over the period; a notebook; tables outside the catalogs counted apart | tests/spark/finops_sql.py, tests/v0200.test.mjs |
| Attacks on the convention: tables that change from run to run, failed run, table off the map, unknown rule, prototype names, another workspace, bounded flood of rows, negative correction never brought back to zero, identity to the cent with a discount | tests/v0200.test.mjs |
| Rounding: rounded shares add up to the rounded total (largest remainder), credits and ties included; table and projection exports, teams | tests/v0200.test.mjs |
| Accounting identity: tables + reads + off the map + capacity with no query + unattributed = total | tests/v070.test.mjs, tests/v081.test.mjs, tests/v0200.test.mjs |
| A run is attributed at most once, shares in proportion to measured time | tests/v070.test.mjs, tests/spark/finops_sql.py |
| Teams (tag) partition the total; serverless + classic = total | tests/v080.test.mjs |
| A table filter does not change a table's cost; the sum of the catalogs equals the attributed total; "Who pays" sums to the selection | tests/v080.test.mjs |
| A spend filter recalculates each table's cost from the chosen workloads only | tests/v080.test.mjs |
| A table off the map (dropped or outside the catalogs) keeps its share, counted apart; the readable table does not receive it and the accounting identity holds | tests/v081.test.mjs |
| Databricks internal catalogs (0.34.3): never listed nor read in the inventory, their tables off the map and bridged, their share said apart within "tables off the map", no catalog row, reconciliation to the cent, hostile names | tests/v0343-internal.test.mjs, tests/security.test.mjs, tests/spark/finops_sql.py |
| Review of 0.34.3: a usage row billed to an internal table stays a workload never named (screen, files, findings, synthesis, sheet), the rows written into an internal table make no table of the costs, the impact of a column crosses the internal tables, "Why?" never names an internal table, a saved map is cleaned once per load, the pre-flight keeps an internal table too linked to be bridged, catalogs chosen that are all internal read nothing, a kept load is bridged like the map | tests/v0343-review.test.mjs, tests/spark/finops_sql.py |
Agents, Genie, endpoints and apps each on its own line; a Genie space gets its share of the warehouse; an old schema without agent_bricks_id works | tests/spark/finops_sql.py, tests/v082.test.mjs |
Genie Code, Genie One and Genie Agents apart through usage_metadata.genie.surface, free DBUs apart, a missing field said "not indicated", an AI Search index sync counted as AI Search (0.28) | tests/spark/finops_sql.py, tests/v0280-genie28.test.mjs |
| Trends: two complete periods of the same length, the same attribution as the costs, movers sorted by change, runs and failures by date, distinct readers and writers per period | tests/spark/finops_sql.py |
| Trends: weeks aligned on the last day (the first one partial), spend groups that sum to the total, change, slope and peak | tests/v083.test.mjs |
| An object's badge gives the figure of the FinOps screens (cost of a workload, refresh cost of a table, queries of a dashboard), discount included; nothing under one cent, nothing for another workspace | tests/badges.test.mjs, tests/e2e/run_e2e.py |
| Launched jobs: only runs started by a "Run Job" task count, never a job for itself, never added to the totals | tests/spark/finops_sql.py, tests/v0160.test.mjs |
| Projections: DBUs of the last 7 dates read like their cost, horizons, value at the pace used and spread between the two paces, intermittent workloads at the period's pace, total and products equal to the sum of the workloads to the cent, tables at the share of their workloads, discount and filters as elsewhere, CSV neutralized | tests/spark/finops_sql.py, tests/v0170.test.mjs, tests/security.test.mjs |
| Price of a usage row spanning a price change: the price in effect at its end, as in the official example | tests/spark/finops_sql.py |
| Calculator: each formula checked by hand (jobs, clusters, Classic and Pro warehouses through their documented machines, serverless, Photon, new or existing reservation, spot rerun on demand, four payment options), total of an estimate equal to the sum of its rows to the cent, CSV export that sums to its total | tests/v0180.test.mjs, tests/v0200.test.mjs |
| Calculator: nothing invented (a missing region, price, instance type or size gives "not priced"), entered prices take precedence, fictional examples priced on Azure and AWS, GCP machines asked for | tests/v0180.test.mjs |
Calculator: machine hours read over the 90 days that node_timeline keeps, shared between the workloads of a cluster in proportion to their DBUs, DBUs and cost over the same dates, coverage; proportional levers of a measured workload | tests/spark/finops_sql.py, tests/v0180.test.mjs |
Views by workload type (0.24): each workload's points (series query) add up to its cost to the cent, day by day then week by week, in parts and on the older schema; key figures equal to the sum of the rows; idle capacity, writes, reads and rest equal to each warehouse's cost; AI types, tag values and "Untagged" adding up to their total to the cent; exports to the cent; hostile tag keys and values (__proto__, markup, formulas) kept as text | tests/spark/finops_sql.py, tests/v0240-fotypes.test.mjs, tests/e2e/run_e2e.py, tests/e2e/security/hostile_metadata.py |
| Catalogs and schemas: the schemas add up to their catalog and the catalogs to the total; exact plus split equals the refresh; a job in one schema, in two schemas of one catalog, in two catalogs, a warehouse part, a billed table; identity to the cent on the sample; table filters; export to the cent; Catalog Explorer badges; comparison with the previous period | tests/v0220.test.mjs, tests/badges.test.mjs, tests/e2e/run_e2e.py |
Glossary: column inventory in 1 and 8 parts, publication script stored as written by Spark (hostile text included), published table read back through IDENTIFIER, ai_query statement run to one row per term with a simulated model | tests/spark/finops_sql.py, tests/v0220.test.mjs |
| Price snapshots: one per cloud, dated, aligned, plausible (spot at most the pay as you go price, 3-year reserved at most 1-year), sources named without addresses, no network request; storage of estimates bounded and free of prototype pollution | tests/v0180.test.mjs, tests/e2e/run_e2e.py |
Overview and composer (0.24): the waterfall, products, teams and days add up to the cent, the period before aligned by position, buckets by day, week and month, the first N and "Others" adding up to the total, the reasons for a missing comparison, the export to the cent and neutralised; hostile saved analyses cleaned and bounded; read-only work-days query, its workloads in a named parameter, its sums equal to costs over the same dates | tests/v0240-fo24.test.mjs, tests/security.test.mjs, tests/spark/finops_sql.py, tests/e2e/run_e2e.py |
Costing a data project (0.24): each brick to the cent on a snapshot of round prices, the BI warehouse for a domain model, the sizing tools, the project record read back as hostile | tests/v0240-calc24.test.mjs, tests/security.test.mjs |
| Calculator services and tools (0.25): rates and sources of the snapshot, formulas per service type, ranges, free parts, discounts per billing unit, account prices read back as hostile, SKU and token prices, Excel export, estimate file, assistant | tests/v0250-rates25.test.mjs, tests/v0250-svc25.test.mjs, tests/v0250-tools25.test.mjs, tests/v0250-account.test.mjs, tests/security.test.mjs |
| Why a cost is missing or zero (0.26): each reason with its values read and its action, the share of a table, that of the other tables and the rest of a shared workload exact to the cent, every code documented, crafted texts inert | tests/v0260-cost26.test.mjs, tests/security.test.mjs |
| Simulations (0.27): each tuning and sizing tool on its example, computed by hand on a snapshot of round prices, totals to the cent, a missing measured figure reported and never guessed; calculations by capability and by role, an estimate line priced to the cent of the tool; profiles that include each calculation (0.28) | tests/v0270-tune27.test.mjs, tests/v0270-simcap27.test.mjs, tests/v0280-roles28.test.mjs |
What YALineo counts (0.28): direct reads only (direct_access), a read through a view counted once for its table, direct readers, direct neighbours and whole chain, reads and writes by origin, views never written, a badge for every asset of the map, job names, link window, metastores without direct_access | tests/v0280-coh28.test.mjs, tests/spark/finops_sql.py |
| Erasing glossary terms (0.29): what each choice erases and keeps (validated terms, other sources, rejected list, settings), the state before a failed import given back exactly, the password compared through its digest, refused in any other form and kept nowhere, a trapped scope or glossary without effect, "Undo" | tests/v0290-erase29.test.mjs, tests/security.test.mjs, tests/e2e/run_e2e.py |
Lineage counts (0.29): one write per event (event_id, else record_id) in the activity, the writers and the trend of a table; "Why no link?" on direct readers, compared with the observed links (a bridge no longer hides a missing link); each lineage window ends on :today (UTC date sent as a named parameter, a trapped value replaced by today's date); the forms for metastores without direct_access | tests/v0290-lin29.test.mjs, tests/spark/finops_sql.py |
Map data (0.28): rhythm over the activity period, bridged links kept apart, freshness without last_altered, the folder rule (two storage accounts, a dotted folder name), names read up to the bound, free DBUs out of the average price of a DBU | tests/v0280-data28.test.mjs, tests/spark/finops_sql.py |
| AI: Genie and agents (0.32): a Genie Agent priced by hand on a snapshot of round prices (the warehouse rule of section 13.9, free allowance, promotion, service principal), an agent part by part from the services snapshot and cross-checked with the token comparator, discounts by category, totals to the cent, what is missing asked for and never counted as 0, estimate lines priced as the page does, hostile inputs without effect | tests/v0320-ai32.test.mjs, tests/v0320-ai32-ui.test.mjs |
| Size a data ingestion (0.32): the example computed by hand on a snapshot of round prices, totals to the cent and equal to the estimate's month, DBUs per GB asked for and never guessed, a database connector's gateway, the backfill apart, hostile inputs without effect | tests/v0320-ingest32.test.mjs |
Reconciliation by the user. YALineo's total spend for a period can be checked with this query, to run in a Databricks SQL editor (replace the workspace id and the number of days):
SELECT SUM(u.usage_quantity * CAST(coalesce(p.pricing.effective_list.`default`, p.pricing.`default`) AS DOUBLE)) AS cout_catalogue,
SUM(CASE WHEN u.usage_unit = 'DBU' THEN u.usage_quantity END) AS dbu
FROM system.billing.usage u
LEFT JOIN system.billing.list_prices p
ON u.cloud = p.cloud AND u.sku_name = p.sku_name AND u.usage_unit = p.usage_unit
AND u.usage_end_time >= p.price_start_time
AND (p.price_end_time IS NULL OR u.usage_end_time < p.price_end_time)
WHERE u.workspace_id = '<workspace id>' -- remove if the setting "The whole metastore, other workspaces included" is chosen
AND u.usage_date >= date_sub(current_date(), <days>)
AND u.usage_date <= date_sub(current_date(), 1);
current_date() must be the UTC date: set the session time zone to UTC (SET TIME ZONE 'UTC') before the query if the warehouse uses another time zone. The period of a chosen duration ends yesterday (section 7); for a period that ends today, remove the last condition. For a period chosen with two dates, replace both date conditions with u.usage_date BETWEEN DATE'<from>' AND DATE'<to>'.
The result must equal the total shown by YALineo without a discount. The same total can be compared with the Databricks usage dashboard (account console) for the same workspace and the same period.
10. Analytics: questions and trends over time
The studio's "Analytics" view creates no new figure: these are the costs of sections 3 and 4 and the lineage events of section 6, grouped by date. Each read is a read-only query run on demand (never while the map loads).
Two periods of the same length. For a period of N days (7, 30, 90 or 180), the current period is made of the last N dates, today included, and the previous one of the N dates before. The queries read 2N − 1 days back (parameter :lookback): both periods are complete. "Today" is the browser's UTC date, or the most recent date returned if the warehouse is ahead.
Grouping. Day by day up to 31 days, week by week beyond. Weeks end on the last day of the period; when N is not a multiple of 7, the first week is shorter, marked "partial" and drawn paler, so that it is not read as a drop.
| Chart or figure | Query | Formula |
|---|---|---|
| Platform spend | spend over 2N − 1 days | Σ coût of the usage rows of each date, by group: Jobs; SQL warehouses; Pipelines; AI (Agent, Genie, AI Search, Endpoint, App); Interactive compute (Notebook, Cluster); Materialized views (Table); Other. Each type belongs to a single group: the sum of the groups equals the total to the cent |
| What changed most | trend-movers | For each workload (same attribution as in section 4): coût(W, courante) − coût(W, précédente), sorted by absolute change |
| Cost of a workload | trend-workload | Σ coût of the workload (type, identifiant) by date, with the expressions of section 4 (the same CASE, checked by a test) |
| Runs billed | trend-workload | Distinct count of billed job_run_id or dlt_update_id; a run billed on two dates counts on each |
| Cost per run | coût(période) / exécutions facturées(période) (cost of the period divided by the runs billed in it) | |
| Runs, failures, duration of a job | trend-runs | Read from system.lakeflow.job_run_timeline; a run counts on the date it starts; failure: final state FAILED, ERROR or TIMED_OUT; mean duration of a group: mean of the daily durations weighted by the number of runs |
| Reads, writes of a table | trend-table | Lineage rows where the table is the source (read, direct only since 0.28) or the target (write, one row per source read), as in sections 6 and 6.8 |
| Distinct readers, writers | trend-table | Distinct count of (entity_type, entity_id), or of the user for a query with no entity, in each period. Only the counts come back, never the names |
| Change | courante − précédente; as a percentage (courante − précédente) / précédente, replaced by "new" if the previous value is zero and by "stable" under 0.5% | |
| Trend over the period | Least squares line over the daily values of the current period: its slope × (N − 1), relative to the mean, that is, the estimated change from the first to the last day. Empty under three points or with no activity; "stable" under 5% | |
| Peak | The largest group of the period (the first one in case of a tie) | |
| The map over time | Snapshots kept | Number of assets and links of each load kept on the device |
Amounts are at list price, without the discount (like the reconciliation query of section 9). The last two dates may still fill in: billing arrives a few hours late (section 8, point 5).
10.1 Answers to the questions
Each question applies filters stated on screen (period, sort, grouping) and answers with a sentence that gives figures. The figures are as follows; none is estimated beyond those already estimated in the previous sections.
| Question | Source | Figures in the answer |
|---|---|---|
| What costs the most? | trend-movers | coût(W, courante) of each workload; its share coût(W) / Σ coût; the share of the top three |
| What rose the most? | trend-movers | The workload with the largest positive change, its change and its percentage; the change in total spend. Its curve opens below (filter applied for the user) |
| Where does the spend go? | spend | The group with the highest amount and its share of the period |
| How much of the spend goes to AI? | spend | Σ coût of the AI groups / spend, for each period; the two shares sum with "The rest" to 100% |
| Serverless or classic compute? | spend | Same calculation with the is_serverless flag of each usage row |
| Which days of the week cost the most? | spend | For each day of the week, the mean of the daily totals of the period; the weekend / weekday ratio |
| What do failures cost? | loaded costs | Cost of failures from section 6, per job, and their sum, over the FinOps period |
| Tables with no read observed | loaded costs | rafraîchissement(T) of the tables with no read observed (section 6), their sum and its monthly equivalent; an attributed cost to check, not a saving |
| Spend per team | loaded costs | Cost of each workload filed under the value of a tag key (team, cost_center...); the workloads without this tag form their own row, so the rows sum to the total (to the cent, section 6.2); the tag's coverage is the share of the total carried by the tagged workloads. A workload's tags are those of its largest usage row (section 8, limit 4) |
| Most-read tables, tables written with no read observed, late tables, hubs, tables without a description, weight of catalogs | the map | Counts of lineage events (section 6), lateness rule based on each table's own rhythm, number of downstream assets (measured for the 80 tables with the most direct links), refresh cost of the tables of each catalog (section 5) |
Three questions are answered in the explorer alone (section 10.2): when the tables were last written (number of tables per week of their last write, by layer), which layers are up to date (number of tables by layer and by freshness) and who owns the most tables (number per owner). Outside a queryable workspace (the example, a file, the FinOps side turned off), "What rose the most?" takes the change of the last 7 days over the 7 before for each loaded workload (section 6), and "What costs the most?" the cost of the FinOps period.
10.2 The explorer
The explorer arranges the rows of a dataset along an X axis and computes a Y measure for each value of X (and, if a color is chosen, for each value of the series), after the filters. Each question of section 10.1 sets the explorer to its view; the reader can change everything.
| Dataset | One row | Origin | Period |
|---|---|---|---|
| Spend per day | one day, one product, one workload type, serverless or not | system.billing.usage loaded with the map (section 2) | the FinOps period, discount included |
| Workloads | a job, pipeline, warehouse, notebook, agent... | the loaded costs (sections 4 and 6) | the FinOps period, discount included |
| Tables | a table, view, materialized view or streaming table of the map | the map, and the refresh cost of section 5 | the activity observed at load time |
| Cost changes | a workload | trend-movers (section 10) | the last N days against the N before, at list price |
| Loads kept | a load | the maps kept on the device | all the loads kept |
Calculations, on the rows themselves, never on rounded subtotals:
-
Sum:
Σ y(ligne)of the rows of the group. Count: the number of rows in the group. -
Mean:
Σ y / n, n being the number of rows where the measure is known (a table with no known activity does not count as zero). - Maximum, minimum: over the rows where the measure is known.
-
Ratio of the sums: cost per run
Σ coût / Σ exécutions; mean durationΣ (durée moyenne × exécutions) / Σ exécutions(mean duration weighted by runs); change(Σ coût courant − Σ coût précédent) / Σ coût précédent. Never the mean of the ratios. -
Mean per day:
Σ coût / nombre de jours du calendrier(total cost divided by the number of calendar days) of the group, over the dataset's period (from the first to the last billed day); a day without billing counts, as zero. For a day of the week, these are the dates of that day in the period (the mean of the daily totals of section 10.1); for a product or a workload type, all the days of the period.
Values shown and "Other": on an axis that is not time, the values are sorted (largest first, smallest, largest change, or axis order) and the first N are shown; the following ones are merged into "Other", calculated on their rows with the same calculation. For a sum or a count, the values shown plus "Other" make the total, to the cent, and each share is valeur / total. Series keep the five largest, the others form "Other"; each series keeps its color whatever the filter.
Time axis: days, weeks (starting on Monday) or months, with no gap between the first and the last value (a day without spend is 0), the last 400 points at most. Rows older than these points are left out of the view and of its total, and their number is shown: what is shown always adds up exactly. Week of last write: the week of lastWriteMs (lineage), otherwise of last_altered (section 5).
Shares: valeur / total only for a sum or a count of positive amounts; for a change (cost change, 7-day change), there is no share, and the bars show the direction of the change.
Filters: each filter keeps (or excludes) values of an axis; "Name contains" keeps the rows whose name (table, owner, workload) contains the text. The values offered by a filter are counted on the rows kept by the other filters.
Verification: tests/v0100.test.mjs checks that the spend grouped by each axis sums to the loaded daily spend, that the workloads and "Other" sum to the total cost, that the refresh cost per catalog sums to that of the cost index, that the cost per run is the ratio of the sums and that the mean per day of the week is the one of section 10.1, to the cent.
10.3 The composer of the cost analysis (0.24)
At the top of the "Cost analysis" page, the composer calculates from the loaded costs (sections 4 to 6), over the period and with the FinOps filters of the Costs pages, with no new query. The questions of section 10.1 stay below it.
| Measure | Value of a row | Source |
|---|---|---|
| Cost | coût(W) | workloads |
| DBUs | DBU(W) | workloads |
| Runs | the runs of the workload (section 4); a workload without runs is not counted | workloads |
| Failures | the number of failed runs | workloads, if the outcome of runs was read |
| Cost of failures | the cost of failures (section 6) | workloads, if the outcome of runs was read |
| Cost of tables | rafraîchissement(T) + lecture(T) | tables of the map (section 5), attributed |
| Reads | the reads of the table (section 6) | tables of the map |
Splits. For a workload measure: none, product, workload type, compute (serverless or classic), workload, team (the value of a tag key, as in 6.5), run as. For a table measure: catalog, schema, table. A split that does not fit the measure is not offered. The product and team filters of the composer keep the workloads of that product or tag value.
Time. The time axis comes only from the spend per day (spend): cost or DBU measure, split by nothing, product, workload type or compute, no team filter, and only if the days add up to the totals to the cent (section 7). Otherwise the screen says why and shows the totals of the period (bars, gaps or table). Grain and columns: those of section 6.5.
The first N and "Others". Values are sorted by absolute amount over the period, then over the period before. The first N (3, 5, 8 or 12) are shown; the following ones are merged into "Others", calculated on their rows. If only one is left, it is shown under its name. The amounts shown are integers (cents for money, whole units for DBU, runs, failures and reads), rounded by largest remainders: the rows add up to the total, and on the time axis the columns of a row add up to the row.
The colours of the gaps. In a waterfall ("Why spend moved" and the composer's "Gaps" chart), a rise is red and a fall green, whatever the measure: runs and reads included, although the variation rule (section 7.1) keeps them grey on the cards, a rise there not being necessarily bad. The exported picture of this chart (PNG, SVG, the page's report) writes the same amounts to the cent, with the same colours, but draws each bar from zero, as a ranking, not as a waterfall. Both choices are the project owner's (0.34).
The period before. Same formulas, same discount, same filters (section 7.1); on the time axis, the comparison is by position, as in 6.5. It is not offered, and the screen says why, if it was not read (too old or failed), if its spend per day is missing for a chart over time, or if the attribution to tables or the outcome of runs was not read the same way for both periods.
The sentence and the data. The sentence uses the rounded amounts of the table: the total, the change from the period before, the first value and its share, the largest rise. The table gives each row, its columns, its total, the period before and the change, to the cent for money and to the unit for DBU and counts; the CSV export gives the same values, with the measure, the unit, the currency and the dates of both periods.
Saved analyses. An analysis keeps its name (at most 80 characters), its configuration (measure, split, grain, chart, product and team filters, N, comparison), the FinOps filters and the dates of its period, never an amount: reopened, it is recalculated on the loaded costs, and the screen says when the loaded period is not its own. Analyses stay on the device, workspace by workspace (yalineo.analyses:<workspace address>), with the retention rule of the maps: erased when the browser closes, or kept with "Keep the map and its history on this device". Fifty at most per workspace. They are cleaned field by field on every read and every write: known keys only, values taken from their lists, bounded sizes, no control or direction characters; an entry that does not pass is ignored. Forgetting a workspace erases them. For the example and a file, they live only as long as the window. The link of an analysis carries its configuration in the address (fa parameter, at most 1,000 characters, cleaned the same way), with no cost data.
10.4 Chosen period, questions per asset, comparison and saved analyses (0.33)
The chosen period. Besides the four lengths (the last 7, 30, 90 or 180 dates, today included), two independent calendars give two dates from and to (real UTC dates, from ≤ to ≤ today, a year at most). The current period is those n dates, the previous one the n dates just before from. The trend queries only read the last 2d dates (d among 7, 30, 90, 180, section 10): the page picks the smallest d with 2d − 1 ≥ (today − from) + n, so both periods are read in full, then keeps the rows of those dates. If even d = 180 is not enough (both periods go back further than 359 days), the period is refused and the screen says why: no date left unread is counted as zero. Sums, changes, trends and peaks are those of section 10, over these dates.
What does not follow the chosen period says so in one line: the answers that read the costs loaded with the map (FinOps period) or the activity of the load, and, when the two dates fall wholly or partly outside the costs loaded, the line says so (« load the costs over these dates »). « What changed most » and « What costs most » compare rolling periods (trend-movers): for two chosen dates they read the last d dates against the d before, and the filter chip says it. In the explorer, the daily spend is kept to the chosen dates that are inside the costs loaded. A table's distinct readers and writers are counted by the query over its rolling periods: they are not shown for two chosen dates.
Questions about one asset. Under « Detailed analysis », each asset has its questions, each answered with what YALineo already holds; missing data is « not read », never 0.
| Asset | Question | Figures of the answer |
|---|---|---|
| Table | Who reads it? | The assets of the map that read it directly (dashboards, jobs, notebooks, queries; section 6, direct links), the tables written from it, its reads observed over the activity window |
| Table | Last write | The last write observed in the lineage, its age, lateness against its own rhythm (section 10.1) |
| Table | Refresh and reads | refresh(T), read(T) (section 5) and their sum over the FinOps period; the monthly equivalent of the refresh |
| Table | Who writes it? | The workloads with a share attributed to its refresh (section 5), then the lineage producers; amount per workload |
| Table | Reads or writes | trend-table over the chosen period: reads and writes, each against the period before; the verdict compares both percentages (5 % threshold) |
| Table | Cost of its readers | Σ cost(W) of the billed readers (jobs, notebooks) over the FinOps period: their whole cost, never the table's share; and read(T) attributed on SQL warehouses |
| Table | What depends on it | The number of assets downstream (full walk), tables and uses |
| Job | Runs and failures | Runs and failures of the workload over the FinOps period (section 4), the rate failures / runs; otherwise trend-runs over the chosen period |
| Job | Cost of failures | The cost of failures (section 6) and its share of the workload's cost |
| Job | Duration | Average duration from trend-runs over the chosen period against the previous one (section 10) |
| Job, pipeline | Cost per run or per update | cost(W) / runs(W) over the FinOps period (derived) |
| Job, pipeline | What it writes | The tables a share of its cost is attributed to (section 5), else those of the lineage; the share attributed |
| Job, pipeline | Cost over time | trend-workload: cost of the chosen period against the previous one |
| Job | Run-as identity | run_as of the workload (section 4) |
| Pipeline | Who reads what it writes | The direct readers, on the map, of the tables it writes |
Comparing assets. Up to six tables, jobs or pipelines on one chart, over the chosen period: for a workload, cost, DBU or billed runs (trend-workload); for a table, reads or writes (trend-table). A measure that does not apply to an asset says so, with no value. The buckets are the same for all (section 10); the table gives for each asset the total of the period, of the previous one and the change. Each asset gets a colour when it is added (the first free one of six) and keeps it as long as it stays compared: removing or reordering the others never changes it. Each series is the sum of its query's rows: its buckets add up to its total.
Saved analyses. An analysis of the page keeps its name (80 characters at most), the question, the explorer's view, the chosen period, the asset analysed, the assets compared with their colours, the measure and chart of the comparison, the cost card's configuration and the FinOps filters, with the dates of the costs loaded; never an amount: opened again, it is recomputed. It stays on the device, workspace by workspace (yalineo.an33:<workspace address>), with the retention rule of the maps, thirty at most; « Clear everything » and forgetting a workspace erase it. It is cleaned field by field on each read and each write (known keys only, bounded lists, no prototype key, no control or direction character). Deleted, it comes back at its place with « Undo » for a few seconds.
Pictures and report. A chart downloads as SVG or PNG (drawn in the page) with its values; the whole page as one self-contained HTML file: its sentences, its questions and answers, each chart as a picture and its values as a table, with no script or outside resource, every text escaped.
Verification: tests/v0330-analytics33.test.mjs checks the two periods of two dates, the coverage of the queries, the answers per asset against the cost index and the lineage, the stability of colours, the cleaning of saved analyses and the escaping of the report.
11. Impact analysis: severity and monthly refresh
The severity of an asset touched by a change follows a points rule, shown with its reasons:
| Reason | Points |
|---|---|
| Dashboard | 3 |
| Query or notebook (read by people) | 2 |
| Gold or platinum layer | 2 |
| Silver layer | 1 |
| 100 reads or more over the period | 2 |
| 10 reads or more | 1 |
Certification tag (certif, trusted, golden) | 2 |
Sensitive data tag (pii, personal, sensitive, confidential, gdpr, rgpd) | 1 |
| Directly downstream | 1 |
| "Drop" scenario (a table or a column) or "rename" scenario (a column): direct reader (it breaks at once) | 2 |
| "Late refresh" scenario: table refreshed daily or more often | 1 |
Critical at 5 points or more, High at 3 or 4, Medium at 1 or 2, Low at 0.
Monthly refresh of the touched tables: Σ rafraîchissement(T) × (365 / 12) / N of the touched tables, at the pace of the FinOps period. It is not a priced loss: it is what these tables take each month, to weigh against an outage. This is the attribution of section 5; there is no double counting between tables, since each appears only once downstream.
11.1 What the analysis reads (0.23)
The analysis reads the whole map loaded: the whole lineage window of the load (system.access.table_lineage over link_days days up to the date of the load, links no longer seen recently included; in analyst mode, what the lineage API returns for the tables explored), the catalogs of the load (a link is read when its source or its target is in them), every asset type of the map and the whole downstream (for a job or a pipeline: the tables it writes, then their downstream). The filters of the map and of the dependencies view (link period, catalog, schema, kinds of links, followed table, direction, depth) do not apply to it; the page always says so and names those that are set. The limits of the load are said too: tables dropped since (their links bridged), lineage cut at its row limit, readers, reads or tags not read.
11.2 A column: three answers, never mixed (0.23)
For a column of a table, the analysis reads on demand system.access.column_lineage (over the lineage window of the setting) for the table and its downstream tables, the closest first, 2,000 at most. Each downstream asset gets a single answer:
Since the review of 0.34.3, the read also covers the tables of Databricks internal catalogs that the bridged links of that downstream cross (section 6.10): the chain of columns goes through them as before 0.34.3. Such a table is never an asset of the answer nor a derived column, and crossing it counts no column link: a table behind it keeps the answer "observed relation", at the distance the map shows it.
| Answer | Rule |
|---|---|
| Observed relation | a column link starts from this column and reaches the asset, directly or through other columns |
| Table dependency to check | the table relation is observed, but no column link is known between the table and the asset (a dashboard, a query or a notebook never has one) |
| Coverage too thin | column links of the table reach the asset, none from this column: "No link of this column observed in the available data: coverage to be confirmed" |
The points are those of the table above, with the distance counted in column links for an observed relation. A "Coverage too thin" answer stays at the low level, with the reason "severity not assessed, coverage to be confirmed": its points only say what the asset would weigh if it were touched, and the "direct reader" point does not apply to it. The owners to notify and the monthly refresh of the touched tables count only the observed relations and the dependencies to check.
The three changes of a column each have their plan: rename (a transition column or a compatibility view, derived columns, dashboards and queries that cite the old name, removal of the old name after a period with no read that cites it), change the type (conversions of the derived columns, aggregates and joins compared on a test environment, formats and filters of the dashboards), drop (who still reads the table: neither the lineage nor system.query.history says which column is read; calculations to remove; observation period; rollback script). Added to these: the check by hand of the dependencies to check, and the coverage warning.
CSV exports: "Export this view" writes the rows shown after the severity, kind and search filters; "Export all the available data" writes every row. Each row says which export it comes from, the lineage window, that the graph filters are not applied (and which ones are set), the filters of the view, the source and the snapshot. The monthly refresh of the rows counted (counted_at_stake = yes) is rounded to the cent by the largest remainder method, so these rows add up exactly to their total; a table with no known cost, a dashboard or a notebook has an empty cell, never 0.
12. The official basis of the method
Each rule of this document relies on the public documentation of Databricks and Microsoft, reviewed for 0.18 (October 2026); the last five rows, added for 0.28, were read on October 28, 2026 and checked on October 29, 2026. The table says what the source establishes and what YALineo does with it; a rule that is a convention says so (section 1).
| YALineo rule | What the official source says | Source |
|---|---|---|
The cost of a usage row is usage_quantity × pricing.effective_list.default (section 3) | The effective_list key "resolves list and promotional price, and contains the effective list price used for calculating the cost" | Microsoft Learn, Pricing system table reference |
| The price used is the one in effect at the end of the usage row (section 3) | The official example "Join the pricing with usage tables" joins on usage_end_time >= price_start_time and usage_end_time < price_end_time | Microsoft Learn, Monitor costs using system tables |
| Databricks retractions and restatements are added up (section 3) | A correction adds a retraction (RETRACTION, a negative quantity that cancels the original row) then a restatement (RESTATEMENT): the sum of the quantities gives the corrected usage | Microsoft Learn, Billable usage system table reference |
| The last day of a period is "still running" for 12 hours (section 7.1) | "Records are typically available within 12 hours" | Microsoft Learn, Billable usage system table reference |
A workload is identified by usage_metadata (job, pipeline, warehouse, notebook, cluster, endpoint, app) (section 4) | The usage_metadata field describes the resources and objects involved in the usage | Microsoft Learn, Monitor costs using system tables |
| The cost of classic compute machines is not in the FinOps total (section 3) | An Azure Databricks reservation (DBCU) "covers only the DBU usage. Other charges, such as compute, storage, and networking, are applied separately" | Microsoft Learn, What are Azure Reservations? and Optimize Azure Databricks costs with a prepurchase |
| The compute time of a query splits the cost of a warehouse, hour by hour (section 5.4) | total_task_duration_ms is "The sum of all task durations", across all cores of all nodes; start_time and end_time bound the query | Microsoft Learn, Query history system table reference |
| The cost of a job or pipeline run is the sum of its usage rows (section 5.2) | usage_metadata.job_run_id and usage_metadata.dlt_update_id identify the run billed | Microsoft Learn, Billable usage system table reference |
| The tables written by a run come from lineage (section 5.2) | entity_metadata carries job_info (job_id, job_run_id) and dlt_pipeline_info (dlt_pipeline_id, dlt_update_id) of the writing entity | Microsoft Learn, Lineage system tables reference |
| A write without lineage leaves the cost unattributed, never wrongly attributed (section 8, limit 2) | The lineage tables are "a subset of all read/write events"; "Records are only emitted when lineage can be inferred" | Microsoft Learn, Lineage system tables reference |
| A period of one year at most | Free retention of 365 days for usage, jobs, query history and lineage | Microsoft Learn, System tables reference |
| Machine hours (Calculator) are read over 90 days at most, and their DBUs over the same dates (section 13.4) | system.compute.node_timeline: free retention of 90 days; a node that ran less than 10 minutes may be missing; neither serverless nor SQL warehouses | Microsoft Learn, System tables reference and Compute system tables reference |
| A reservation is paid every hour, used or not (section 13.3) | A reservation is "use-it-or-lose-it" hour by hour | Microsoft Learn, How the Azure reservation discount is applied to virtual machines |
| The split of shared costs follows recognized models (section 5) | Proportional split by a usage metric, even split as a fallback, explicit non-allocation | FinOps Foundation, Allocation |
| Only direct reads count; a read through a view goes to the view, then once to its sources (sections 5.8 and 6.8) | direct_access: "When false, the source is an intermediate dependency discovered through view expansion" | Microsoft Learn, Lineage system tables reference |
| A write counts once per event, whatever its number of rows (section 6.8) | event_id: "Multiple rows may share the same event_id if they were generated by the same event" | Microsoft Learn, Lineage system tables reference |
The lineage windows start from the UTC date YALineo sends, not from current_date() (section 6.8) | TIMEZONE: "The system default is UTC"; an administrator can set it otherwise | Microsoft Learn, TIMEZONE |
Freshness comes only from an observed write, never from last_altered (section 6.9) | LAST_ALTERED: "Timestamp when the relation definition was last altered in any way" | Microsoft Learn, TABLES (information schema) |
| A table the inventory does not list leaves the map, its links are bridged apart (section 6.10) | "The rows returned are limited to the relations the user is privileged to interact with" | Microsoft Learn, TABLES (information schema) |
The Genie product comes from usage_metadata.genie.surface; the DBUs of GENIE_FREE_USAGE are apart, never said unpriced, and do not lower the average price of a DBU (sections 3, 4.3 and 13.4) | surface "Identifies which Genie product generated the usage"; GENIE_FREE_USAGE "does not carry a list price" | Microsoft Learn, Monitor and understand your Genie cost |
| An AI Search index sync counts as AI Search, never as a pipeline (section 4.3) | dlt_pipeline_id is filled for pipelines and the features that use them, "such as materialized views, online tables, AI Search indexing, and Lakeflow Connect" | Microsoft Learn, Billable usage system table reference |
13. Calculator: estimating a workload, new or measured
Since 0.18, the third side, "Calculator", says what a workload would cost on Azure, AWS or GCP: a new workload, described by the user, or a workload measured by the FinOps side whose number of runs, volume or way of paying for machines is changed. These are derived figures (section 1), never measurements: each page says so below its title, and the Calculator adds no figure to the FinOps screens. It runs no query: it reads the costs already loaded by the FinOps side and a snapshot of public prices embedded in the extension.
13.1 An estimate and its workloads
An estimate brings together workloads (60 at most) on one cloud, one region and one Databricks plan (Premium or Enterprise; Premium only on Azure), with two discounts. Each workload is priced on its own, then:
- each amount of a workload (DBU cost, machine cost) is rounded to the cent once; its total is their sum;
- the total of the estimate is the sum of its workloads' totals, to the cent; per year = 12 × per month;
- a workload that cannot be priced (missing price, unknown instance type, region not chosen) is never counted as zero: it is listed as "not priced" with the reason, and the total is called "partial".
Estimates (30 at most) stay on the device, checked when read (bounded numbers, checked names and ids, no prototype key), and follow the retention rule of the settings: erased when the browser closes by default, kept on disk if the user chose so. Since 0.23, an estimate also keeps the values of the prices it uses and the date of its measures: it reopens as saved, to the cent (section 13.8).
Pricing state (0.23). Each estimate has a state, with what it lacks listed workload by workload:
| State | When |
|---|---|
| priced | every workload is priced with every value it needs |
| partly priced | a part exists without a price: a DBU or machine price missing from the snapshot, a cost measured on another cloud |
| missing assumptions | a value is still to enter: the region, an instance type or size known to the snapshot, the machine cost of a measured workload or of a warehouse, DBUs per run, a current measure that cannot be read |
"Missing assumptions" wins over "partly priced". A missing region counts once, not once per workload. Two more lists come with it without changing the state: the assumptions to check (capacity already bought, section 13.3; a duration taken from a trial run; levers on runs or volume, section 13.4) and what is out of scope by rule (disks and network of classic machines, section 13.6). A serverless job or pipeline with no DBUs per run is no longer counted as 0: it is "not priced", with the value to enter.
13.2 Prices and their origin
Each input of a calculation carries its origin, shown next to the figure:
| Origin | What it is |
|---|---|
| Public price | The snapshot embedded in the extension, as of its date |
| Measured | Read in this workspace by the FinOps side: system.billing.usage (DBUs, cost, runs) and system.compute.node_timeline (machine hours) |
| Entered | Typed by the user: a price, a discount, a number of runs, DBUs per run |
The snapshot (extension/lib/prices/<cloud>.mjs, written by tools/cloud-prices.mjs, never by hand) comes from public data:
| Cloud | DBUs: instance types, DBUs per hour, Photon, price of a DBU per product and per plan | Machine prices (Linux, per hour) |
|---|---|---|
| Azure | Data from Microsoft's Azure Databricks pricing calculator | Data from Microsoft's virtual machines pricing calculator: pay as you go, spot, 1-year and 3-year reserved |
| AWS | Data from the Databricks pricing calculator (AWS) | AWS Price List (EC2, shared tenancy, no preinstalled software or license): on-demand, 1-year and 3-year standard reservations with no upfront payment; spot: data from the AWS spot pricing page |
| GCP | Data from the Databricks pricing calculator (GCP) | Not embedded: Google publishes them only through an API that needs a key (Cloud Billing Catalog API). The user enters them |
The extension never calls these services. The maintainer refreshes the snapshot with node tools/cloud-prices.mjs, which checks every name (instance types, regions) and every number (positive prices below 1,000 per hour), and discards a spot price higher than the pay as you go price of the same type in the same region (two sources that contradict each other, for example a spot page not yet updated after a price cut: two AWS GPU types in the October 15, 2026 snapshot). A weekly alert (.github/workflows/cloud-prices.yml) compares the day's public prices with the snapshot and opens an issue when they change (spot, which moves every day, is counted separately). A snapshot older than 90 days is flagged on screen.
Machines of Classic and Pro SQL warehouses. For each cloud, Databricks documents the machines of a warehouse cluster: a driver whose type follows the size, and workers all of the same type (Azure Standard_E8ds_v4, AWS i3.2xlarge, GCP n2-highmem-8):
| Size | Workers | Azure driver | AWS driver | GCP driver |
|---|---|---|---|---|
| 2X-Small | 1 | Standard_E8ds_v4 | i3.2xlarge | n2-highmem-8 |
| X-Small | 2 | Standard_E8ds_v4 | i3.2xlarge | n2-highmem-8 |
| Small | 4 | Standard_E16ds_v4 | i3.4xlarge | n2-highmem-16 |
| Medium | 8 | Standard_E32ds_v4 | i3.8xlarge | n2-highmem-32 |
| Large | 16 | Standard_E32ds_v4 | i3.8xlarge | n2-highmem-32 |
| X-Large | 32 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 2X-Large | 64 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 3X-Large | 128 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 4X-Large | 256 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
The DBUs per hour of a size (from 4 for 2X-Small to 528 for 4X-Large) come from the same public pricing data and from Microsoft's Serverless DBU consumption by SKU page.
Entered prices and discounts. An entered price (DBU of a product, machine of a type and a payment option) replaces the public price for that cloud and is shown as "entered". Two discounts, as a percentage from 0 to 90, apply to the list price: on DBUs (Databricks contract, for example prepaid units) and on machines (cloud contract). Spot and reservations already have their own price: the machine discount applies to them too, as on an invoice that discounts every meter; set it to 0 if the contract does not cover these prices.
13.3 Estimating a new workload
H, the running hours per month, can be given in three ways: as runs (exécutions par jour × jours par mois × minutes par exécution ÷ 60, that is, runs per day × days per month × minutes per run ÷ 60), as hours per day (heures par jour × jours par mois, that is, hours per day × days per month) or as hours per month (entered; 730 for a full month, the average 365 × 24 ÷ 12). Days per month default to those of an average month, 365 ÷ 12, as on the FinOps side.
| Workload | DBUs per hour | Machines per hour |
|---|---|---|
| Job, pipeline, all-purpose cluster (classic) | dbu(driver) + w × dbu(worker), × the family's Photon multiplier if checked | prix(driver, paiement du driver) + w × prix(worker, paiement des workers) |
| Classic or Pro SQL warehouse | DBU(taille) × c | (prix(driver(taille)) + n(taille) × prix(worker)) × c |
| Serverless SQL warehouse | DBU(taille) × c | 0: the machines are in the DBU price |
| Serverless job, pipeline | not applicable: DBUs per month = DBUs per run × runs | 0 |
-
w: the average number of workers (with autoscaling, the average);dbu(type): the DBUs per hour of the instance type for the workload's family (snapshot); the driver is of the same type as the workers unless chosen otherwise, as in Databricks.c: the average number of clusters of the warehouse;n(taille): its workers (table above). - DBU cost = DBUs per month × price of a DBU of the product (jobs, interactive compute, Core, Pro or Advanced pipelines, SQL Classic, Pro or serverless, serverless jobs or pipelines) × (1 − DBU discount).
-
Machine cost = machines per hour ×
H× (1 − machine discount). Total = DBU cost + machine cost. -
Spot: workers on spot, the driver pay as you go. Databricks requires it: with spot instances, "The first instance will always be on-demand (the driver node is always on-demand)" (Azure and AWS, Compute configuration reference). The driver is therefore paid pay as you go or reserved, never on spot. The same holds for a Classic or Pro SQL warehouse: its "Cost optimized" policy uses mostly spot instances and one on-demand instance (Databricks SQL release notes, February 3, 2022); the Calculator therefore pays its workers on spot and its driver pay as you go. The cloud can take back a spot machine: the work then restarts on pay-as-you-go machines. The user enters the share of hours rerun pay as you go
f(0 % by default, said on screen); a worker's hourly price becomes(1 − f) × spot price + f × pay-as-you-go price. YALineo does not guess this rate. -
Reservation, two modes, chosen on screen (since 0.20; the screen always gives the other mode alongside, with the machine cost and the unused hours per reserved machine):
-
new commitment (default): the reservation is bought for this workload. Microsoft notes that a reservation is "use-it-or-lose-it" hour by hour: each reserved machine is paid
max(H, 730)hours a month, used or not; machines that are not reserved (for example a pay-as-you-go driver) are paid their hours; -
capacity already bought (called "existing reservation" before 0.23): it is already bought and has spare hours; this workload counts its hours at the reserved rate (
Hhours). - The rule and its source. Microsoft Learn, How the Azure reservation discount is applied to virtual machines (read on October 24, 2026): a reservation discount is "use-it-or-lose-it"; it applies hour by hour, a reserved hour with no running machine is lost and is not carried forward, and usage above the reservation is paid on demand. The rule is written for Azure; on AWS and GCP, the screen says it is to be checked in the cloud's terms. The screen gives it beside the choice, with its source.
- Assumption to check. For capacity already bought, the figure assumes its spare hours are free at the hours the workload runs. YALineo does not read the hourly use of reservations: the assumption is listed "to check" in the estimate, never taken for granted; an hour not covered would be paid on demand.
-
new commitment (default): the reservation is bought for this workload. Microsoft notes that a reservation is "use-it-or-lose-it" hour by hour: each reserved machine is paid
- Photon: the snapshot gives the DBU multiplier per family (for example 2.5 for jobs on Azure, 2 for interactive compute). The speedup Photon brings depends on the workload and is not known: the user reflects it in the duration. If Photon has no multiplier for the family of the chosen type, the estimate is made without it, and the screen says so.
-
Size from the data volume: Databricks bills compute time (DBUs per machine hour), not gigabytes or rows; the volume counts through the duration and the number of workers. The ingestion type sets the workload and its use: scheduled batch, scheduled incremental Auto Loader and triggered pipeline count in runs; continuous streaming and continuous pipeline run the whole month (730 h), and it is then the number of workers that the volume decides. For a run, the duration comes from a reference run measured by the user (a test, or a comparable job: volume processed
V₀, durationT₀, workersw₀) by a proportional rule, said as such:T = T₀ × (V ÷ V₀) × (w₀ ÷ w), whereVis the volume per run andwthe workload's workers. It assumes the duration follows the volume and is shared evenly among the workers (the best case). No throughput is assumed: without the four figures, nothing is computed and the screen says what is missing. The duration is applied only on request ("Use this duration") and the step-by-step calculation says where it comes from. Since 0.23, a recap shows first: the parameter carried over (minutes per run, before and after, and the origin of the duration), the settings kept with the workload (volume, trial run, workers), the limits kept (proportional rule at best; the duration does not follow a change by itself; the cluster start counted only if it was in the trial; duration capped at 44,640 minutes) and the effect on the amount of the workload and of the estimate per month, priced as the page shows it, with the pricing state after. Nothing changes before "Confirm and apply"; the workload then keeps the whole sizing, with its date. If the volume or the workers change afterwards, the duration used does not change by itself: the step-by-step calculation no longer shows the sizing as its origin, and the help line gives the new duration to apply. -
Serverless: a serverless job or pipeline has no size. Its DBUs per run are taken from a measured serverless workload (
DBU ÷ exécutionsover the period, that is, DBUs divided by runs, "measured" origin) or entered. - The four payment options: the same workload is priced pay as you go, on spot (driver pay as you go, rerun share included), 1-year and 3-year reserved in the reservation mode chosen; the cheapest is marked and its gap with pay as you go is given. With a new commitment, a part-time workload is therefore never "the cheapest" as reserved thanks to the hourly rate alone.
- Changing cloud keeps the workloads: each instance type is replaced by the cheapest one of the new cloud with at least as many vCPUs and as much memory, and the region by the closest one in the same geography (for example East US, us-east-1, us-east4); with no close region, none is chosen and the screen asks for it. The message says so: it is a close machine (vCPUs and memory), not the same one; processor, disk and network differ, and a run's duration is to be checked with a test.
- What is missing is never replaced: an instance type unknown to the snapshot, a price missing in the region or an unknown size gives "not priced" with the reason and the input that completes it.
- Worked cases (Estimates page): six fictional situations, each an estimate ready to open with its guide (the need, what to gather, what to try, what to keep in mind). Their inputs are the example's assumptions, said in the guide and in each workload's notes; they are priced by the formulas above, with no other rule. Two durations come from a volume through the proportional rule: 40 million rows at the pace of 10 million in 18 minutes on 4 workers (72 minutes on 4 workers), and 2,000 GB at the pace of 100 GB in 25 minutes on 8 workers (250 minutes on 16 workers). On GCP, their machines ask for their price like any workload.
13.4 A measured workload and its levers
For a workload W of the FinOps side measured over N days, brought to an average month (× (365 ÷ 12) ÷ N):
- DBUs and runs: measured (section 4);
- DBU cost: its cost at list price (before the discount of the FinOps side) × (1 − DBU discount of the estimate);
-
machine hours: measured by instance type and role (driver or worker) in
system.compute.node_timeline(optional queryyalineo:vmhours), the sum of the durations of each cluster's rows. The table keeps only 90 days: the hours are read over the part of the period it covers (vm_daysdates, at most 90). Since 0.20, DBUs and their cost are read over these same dates: the workload is then brought to a month overvm_days(× (365 ÷ 12) ÷ vm_days), and its DBUs and its hours describe the same days; -
shared cluster: the hours of a cluster used by several workloads (an all-purpose cluster that also runs jobs) are shared between them in proportion to the DBUs each used on it over these dates (
hours × DBU(workload, cluster) ÷ DBU(cluster)). An hour is counted only once, and a cluster used at 51 % and 49 % is no longer given whole to the first; -
coverage: the share of the workload's DBUs used on clusters present in
node_timeline. A node that ran less than 10 minutes may be missing from the table: under 100 %, the screen says the rest has no machine hours in the figure; -
machine cost: these hours × the snapshot price for the chosen type and payment option × (1 − machine discount). On spot, the share rerun pay as you go follows section 13.3. Reserved, in the "new commitment" mode, each type and role is paid
⌈hours ÷ 730⌉ × 730hours (as many reserved machines as the hours need, paid all month); in the "existing reservation" mode, its hours. This is an estimate at public prices, not the cloud invoice (contract, disks, networking).
The levers: a runs multiplier a and a volume multiplier v. The DBUs, their cost and the machine hours of the scenario are today's × a × v, and the runs today's × a. This is a proportional rule, shown as such: it also multiplies fixed times (cluster start-up, small tables), so it gives a slightly high figure when the volume grows; a larger volume may also need another cluster size or overflow memory, which it does not foresee. It is a scenario, not a forecast.
A serverless workload has no machine hours: its DBU price includes them. A classic workload without hours read (the yalineo:vmhours query refused, or a Classic or Pro SQL warehouse, absent from node_timeline) has machines of unknown cost: the workload is "not priced", never counted as zero, until the user enters the cost of its machines over a month (cloud bill, origin "entered"). That cost then follows the levers like the DBUs (× a × v), and the machine discount applies.
Since 0.23, a measured workload also keeps the last day its measures cover and the id of its workspace: the page says "measures up to …", and "Recompute with the current data" finds the same workload (same key, same workspace) in the costs of the moment. A workload added before 0.23 has no such date: it is said to be "without a date", and found by its key alone, which the screen also says.
Billing unreadable. When system.billing.usage cannot be read with the user's rights, the Measured workloads page says "data unavailable" (no empty list shown as a result, no amount at 0), and so do the measured average price of a DBU and the measured reference for DBUs per run. An estimate keeps its last known measures, shown with their date; "Recompute with the current data" is then disabled, with the reason.
A measured workload keeps the cloud of its workspace: its list cost is that cloud's. If the estimate moves to another cloud, the workload becomes "not priced" with the reason (its cost does not hold elsewhere); it gets its price back on its own cloud, or is described as a new workload on the other one.
Measured average price of a DBU (Prices and discounts page): for each billed product (the main product of each workload, section 4), Σ coût catalogue des lignes en DBU ÷ Σ DBU (list-price cost of the DBU rows divided by DBUs) of its workloads over the period. Since 0.20, the numerator counts only rows whose unit is the DBU: usage in other units (tokens, for example) no longer inflates the price of a DBU. It serves as a reference for entering one's own price, never as a price applied silently. Since 0.28, the denominator counts billed DBUs only: free Genie DBUs (SKU GENIE_FREE_USAGE, which "does not carry a list price", section 4.3) no longer lower the average price, they are said beside it ("of which X free DBUs"); a product with free DBUs only has no measured price. A workload whose billed DBUs have no cost read (no list price) is left out, like a job that only launches other jobs. Example: a Genie line of 100 DBUs, 60 of them free and 40 billed at $0.07, gave $0.028 per DBU; it gives $0.07.
13.5 Comparing and exporting
Two to four estimates can be compared side by side, each with its own prices and discounts (the ones it kept): total per month and per year, DBUs, machines, and the gap with the cheapest. Since 0.23, the comparison shows the pricing state of each one (section 13.1) with what it lacks, its data kept, and whether it can be named the cheapest: only a fully priced estimate is ranked; a partly priced one, or one with missing assumptions, never is (neither "the cheapest" nor a gap), even when its partial total is lower. At least two priced ones are needed to name one; otherwise the page says why none is. The Calculator has no budget nor deadline: no constraint is evaluated. An estimate can be exported as CSV (one row per workload with a priced column, then the total of the priced workloads, which says how many are left out; numbers to the cent; since 0.23, two last columns: state, the state of each workload and of the estimate, and data, the data it is computed with: prices kept and the date of their snapshot, the last day of the measures, or the current data) or copied as Markdown (with its notes, a partial total said as such, and since 0.23 its state, what is missing, the assumptions to check, what is out of scope and its data); a cell that starts with =, +, -, @, a tab or a carriage return, even after blanks, is never a formula (section 6.2), and the Markdown neutralizes its formatting characters, addresses and mentions.
13.6 What the Calculator does not price
- The disks attached to machines (Azure, for example, attaches a 256 GB Premium SSD managed disk, billed by the hour, to each node of a Classic or Pro warehouse), networking, public IP addresses, data storage (except serverless default storage, Lakebase and AI Search, billed per GB, and the storage brick of "Cost a project", at the price per GB entered), licenses other than Linux, taxes.
- Negotiated prices beyond the two discounts, credits, the prices of a spending commitment (savings plan).
- Price changes after the snapshot date; spot, which changes every day.
- Autoscaling beyond an average number of workers and clusters; the startup time of a cluster, unless it is counted in the duration entered.
- GCP machines, until they are entered.
13.7 Official sources of the Calculator
- Microsoft Learn, SQL warehouse sizing, scaling, and queuing behavior (machines of a Classic or Pro warehouse by size, attached disks): https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/warehouse-behavior
- Databricks, SQL warehouse sizing, scaling, and queuing behavior, AWS: https://docs.databricks.com/aws/en/compute/sql-warehouse/warehouse-behavior and GCP: https://docs.databricks.com/gcp/en/compute/sql-warehouse/warehouse-behavior
- Microsoft Learn, Serverless DBU consumption by SKU (DBUs per hour of SQL warehouse sizes): https://learn.microsoft.com/azure/databricks/resources/pricing
- Microsoft Learn, Compute configuration reference (driver always on-demand with spot instances, driver type): https://learn.microsoft.com/azure/databricks/compute/configure; Databricks, AWS: https://docs.databricks.com/aws/en/compute/configure
- Microsoft Learn, Databricks SQL release notes 2022, February 3, 2022 (spot policy of a SQL warehouse: "Cost optimized" uses mostly spot instances and one on-demand instance): https://learn.microsoft.com/azure/databricks/sql/release-notes/2022
- Microsoft Learn, What is Photon? (Photon types consume DBUs at a different rate): https://learn.microsoft.com/azure/databricks/compute/photon
-
Microsoft Learn, Compute system tables reference (
node_timeline, nodes under 10 minutes): https://learn.microsoft.com/azure/databricks/admin/system-tables/compute - Microsoft Learn, How the Azure reservation discount is applied to virtual machines (a reservation is "use-it-or-lose-it" hour by hour, no reservation for spot): https://learn.microsoft.com/azure/cost-management-billing/manage/understand-vm-reservation-charges
- Microsoft Learn, Optimize Azure Databricks costs with a prepurchase (prepaid units discount only DBUs): https://learn.microsoft.com/azure/cost-management-billing/reservations/prepay-databricks-reserved-capacity
- Microsoft, Azure Databricks pricing: https://azure.microsoft.com/pricing/details/databricks/; Databricks, Pricing: https://www.databricks.com/product/pricing
- AWS, Amazon EC2 On-Demand Pricing: https://aws.amazon.com/ec2/pricing/on-demand/; Amazon EC2 Spot Instances Pricing: https://aws.amazon.com/ec2/spot/pricing/; AWS Price List bulk API: https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/using-ppslong.html
- Google Cloud, VM instance pricing: https://cloud.google.com/compute/vm-instance-pricing; Cloud Billing Catalog API: https://cloud.google.com/billing/docs/how-to/get-pricing-information-api
Since 0.24, for "Cost a data project" and its sizing tools (sections 13.9 and 13.10), read on October 25, 2026 unless stated otherwise:
- Microsoft Learn, Create a SQL warehouse (one cluster for every 10 concurrent queries; default auto stop of 10 minutes for serverless and 45 for Pro and Classic, interface minimum of 5 minutes for serverless and 10 for Pro and Classic; checked on October 29, 2026): https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create
- Microsoft Learn, Genie consumption guide (the compute of Genie's queries is billed by the SQL warehouse, separately): https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Microsoft Learn, Create and manage a Genie Agent (a Pro or Serverless SQL warehouse is required): https://learn.microsoft.com/azure/databricks/genie-agents/set-up
- Microsoft Learn, Manage classic compute (auto termination from 10 to 10,000 minutes or off; an idle cluster stays billed): https://learn.microsoft.com/azure/databricks/compute/clusters-manage
- Microsoft Learn, Serving concepts (provisioned concurrency = requests per second × model execution time): https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/glossary
- Microsoft Learn, Create custom model serving endpoints (Small, Medium, Large sizes, concurrency in multiples of 4, GPU replicas): https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/create-manage-serving-endpoints
- Microsoft Learn, Custom models overview (scale to zero after 30 minutes without traffic): https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/custom-models
- Microsoft Learn, Model Serving limits and regions (at most 1,024 concurrent requests per model): https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/model-serving-limits
- Microsoft Learn, Serverless DBU consumption by SKU (already cited: DBUs per hour of warehouse sizes; for Model Serving, 1 DBU per hour per concurrent request on CPU, and the DBUs per hour of a GPU replica: GPU_SMALL 10.48, GPU_LARGE 78.6, GPU_LARGE_2 157.2, GPU_LARGE_4 314.4): https://learn.microsoft.com/azure/databricks/resources/pricing
- Microsoft Learn, VACUUM (deleted files kept 7 days by default): https://learn.microsoft.com/azure/databricks/sql/language-manual/delta-vacuum
- Microsoft Learn, Work with table history (more retention, more files kept and more storage): https://learn.microsoft.com/azure/databricks/tables/history
- Little, J. D. C. (1961), A Proof for the Queuing Formula: L = λW, Operations Research 9(3), 383 to 387, DOI 10.1287/opre.9.3.383
- Amdahl, G. M. (1967), Validity of the single processor approach to achieving large scale computing capabilities, AFIPS Conference Proceedings 30, 483 to 485, DOI 10.1145/1465482.1465560
13.8 What an estimate keeps, and its two ways to reopen (0.23)
A saved estimate must give the same result again. Before 0.23, its measured workloads kept their measures, but its prices were read again at each opening: an entered price changed later, or a newer snapshot shipped with a new version, changed a saved estimate silently.
What it keeps. At each write, the estimate keeps the values of every price its workloads use: the price of a DBU per product, the price of a machine per type and way to pay, the DBUs per hour of an instance type (Photon included), the DBUs and machines of a warehouse size; each with its origin (public or entered) and the date of its snapshot. What is already kept wins; a price it did not hold yet (a workload added, another way to pay) is taken from today's snapshot and kept in turn; a price no longer used is no longer kept. A change of cloud, region or plan is a setting: the prices kept for the former no longer apply, those of the new one are kept. Its measured workloads keep their measures (section 13.4), with their last day and their workspace. The total per month at the time of the write is kept too: if the same data give another total later (the calculation changed with a version), the screen says so.
Two explicit actions.
- Reopen as saved (default): its settings, its discounts, its kept prices and its kept measures. It is the same result as when it was saved, to the cent, and the page says so.
- Recompute with the current data: its settings and discounts, today's snapshot prices with the prices entered today, and the current measures of its workloads (each measured workload found again in the costs of the moment, its levers kept). Nothing is replaced: "Keep the current data" does it on request (the measured workloads take their current measures, the estimate keeps today's prices from then on); "Reopen as saved" goes back to the kept result.
The difference, part by part. With T(settings, prices, measures) the total per month of an estimate, rounded to the cent:
-
A = T(settings when reopened, kept prices, kept measures): saved; -
B = T(current settings, kept prices, kept measures): what "as saved" shows; -
C = T(current settings, kept prices, current measures); -
D = T(current settings, current prices, current measures): with the current data.
Settings and discounts = B − A, measures = C − B, prices = D − C. Each total is rounded to the cent before the difference: the three parts add up to D − A to the cent, by construction. The settings of an estimate are kept at each change: the settings part is zero when it is reopened and counts what changes while the current data are shown. Example (the review's): a serverless workload measured at $817.49 of DBUs at list price over 30 days gives 817.49 × (365 ÷ 12) ÷ 30 = 828.8440…, that is $828.84 a month; its data then double ($1,634.98 over 30 days, 1,657.688… that is $1,657.69). Reopened as saved: $828.84. Recomputed: $1,657.69, with settings $0.00, measures +$828.85, prices $0.00 (and not $828.84: each total is rounded before the difference).
What is never a difference against zero. A part is computed only when both its totals leave out the same workloads. A current measure that cannot be read (billing not readable, costs not loaded, workload missing from the current costs or from another workspace) makes the workload "not priced" with the current data, and the measures part and the total difference "unknown". An estimate saved before 0.23, without a full record, is marked as such: its prices were not kept (today's are read instead, then kept at the next change), its prices part is "not separable", and the total difference is then settings + measures. A measured workload added before 0.23 is said to be "without a date".
Data read back as hostile. What an estimate keeps is read field by field (a known version, a known cloud, region and plan, known products, instance types by their pattern and never a prototype key, the four ways to pay, numbers only and within their bounds, 120 types at most, dates in day format); a record that is not recognised is ignored and the estimate said to be without a full record. An attack test checks it (tests/security.test.mjs).
13.9 Costing a data project (0.24)
A project is described in plain terms, block by block: ingestion, transformations, dashboards (BI), Genie, notebooks and ad hoc analysis, served model, storage, environments and discounts. YALineo turns it into Calculator workloads and prices them with the same engine (section 13.3), on the estimate's prices: the bundled public snapshot, the prices entered, the contract discounts, the reservation rules. A project is an estimate that carries a project record: it is kept, reopened as saved and recomputed with the current data like any estimate (section 13.8). The code is in extension/lib/calc-project.mjs.
The models. Five starting points: BI warehouse for a domain, Real-time e-commerce, Self-service analysts and Genie, Data science and served model, Blank project. Their values are examples to adapt, said as such on screen; none is presented as a measure. A value nobody knows in advance stays empty and the project says so: the storage price, the DBUs of a serverless notebook session, the price of a served model. The models' machine types are, per cloud, a general purpose type and a memory type present in each snapshot (for example Standard_D4ds_v5 and Standard_E8ds_v5 on Azure).
Ingestion and transformations. k identical flows or jobs, each an engine workload: in runs (runs a day × 365 ÷ 12 days × minutes ÷ 60), or always on, 730 h (continuous streaming, continuous pipeline). A serverless job or pipeline needs its DBUs per run (section 13.3). The block is k × the amount of one workload, rounded to the cent before the multiplication. The high end of the range prices the peak minutes when they are entered; otherwise it equals the expected amount.
Dashboards: a SQL warehouse described by its use. With q concurrent queries at peak, m minimum clusters (1 to 30), h open hours a day, p peak hours, a auto stop minutes and r restarts a day:
-
clusters at peak
M = min(30, max(m, ⌈q ÷ 10⌉)): Databricks recommends one cluster for every 10 concurrent queries (Create a SQL warehouse); -
stop tail
t = a ÷ 60 × rhours: an idle warehouse stays billed until it stops; -
whole day
J = min(24, h + t); off peakH = max(0, min(24 − p, h − p + t)); -
expected =
Hhours atmclusters +phours atMclusters; low =Jhours atmclusters; high =Jhours atMclusters; each part is the engine's warehouse workload (DBUs of the size × clusters, and for Pro and Classic their machines), over the days of the month entered.
Example: Small serverless, 12 DBUs an hour at $0.70, q = 15, m = 1, h = 10, p = 2, a = 10, r = 1, 22 days: M = 2, t = 1/6 h, expected (8 1/6 × 1 + 2 × 2) × 12 × 0.70 × 22 = $2,248.40, low $1,878.80, high $3,757.60.
When the user picks the warehouse type, the auto stop takes Databricks' default: 10 minutes for serverless, 45 for Pro and Classic (Create a SQL warehouse, section 13.7). The templates keep their example values (10 minutes, including for the Pro warehouse of "Self-service analysts and Genie", which is the interface minimum for Pro), said as examples to adapt.
Genie. Its SQL queries run on a Pro or Serverless warehouse (Create and manage a Genie Agent) and are billed by that warehouse (Genie consumption guide). On the BI warehouse, its concurrent queries at peak g add to the BI's; Genie carries the difference T(q + g) − T(q), for the expected amount, the low and the high end: nothing is counted twice, and a Genie that fits in the clusters already there adds nothing: the block's line shows the clusters at peak before and after Genie (for example 2 → 2). Genie only uses the hours and days open for BI: extra days are "not priced" with their number. On a Classic BI warehouse, Genie does not run: the block asks for a Pro or Serverless warehouse. Without a BI warehouse, Genie has its own serverless warehouse, priced by the same rule. The number of questions describes the need; YALineo does not read it nor turn it into a cost. The billing of Genie's own language model is out of the project's scope, said on screen; the "AI: Genie and agents" page prices it (section 13.16).
Notebooks. Shared all-purpose clusters: ⌈people ÷ people per cluster⌉ clusters, each the engine's cluster workload (hours on a day × days). Or serverless notebooks: people × sessions a day × days sessions × DBUs per session (measured on a trial and entered) × the snapshot's serverless notebooks DBU price × (1 − DBU discount). Without DBUs per session, the block has a missing assumption, never a zero.
Served model. The requests (requests a day × days) at the price entered per 1,000 requests, or the DBUs a day of the provisioned concurrency (tool of section 13.10) at a Model Serving DBU price, absent from the snapshot: entered, or taken on request from the product's measured average price (section 13.4). The DBU discount applies to both. Training is a job of so many hours a month, priced by the engine.
Storage, billed by the cloud. With S₀ GB at the start, v new GB a day, w GB rewritten a day, R retention days of the files (7 by default for VACUUM) and a horizon of N months: new data a month v × 365 ÷ 12; files kept for time travel w × R; month m holds S₀ + m × v × 365 ÷ 12 + w × R GB. The expected amount is the average month from 1 to N, S₀ + w × R + v × 365 ÷ 12 × (N + 1) ÷ 2; the low end the first month, the high end the last. Only at the price per GB and month entered (the cloud contract), never discounted; read and write operations are out of scope.
Development and test. A share d entered, 0% by default, of the compute of every block but storage: round(Σ DBU costs × d) + round(Σ machines × d), likewise for the low and high ends.
Totals, to the cent. Each block is a sum of cents; the expected total is Σ blocks + development. The "By block" and "By Databricks product" amounts (each priced part under its product, development and storage apart) add up to the total to the cent, as do DBUs + machines + storage. A year: 12 months. The range only comes from the rules above (peak minutes, warehouse autoscaling, first and last month of storage); no percentage is added by default, and only the priced parts count.
The pricing state. The estimates' (section 13.1): "priced" when every block has all its values, "partly priced" when a part exists without a price (a price absent from the snapshot, Genie days beyond BI), "missing assumptions" when a value is still to enter. An incomplete block is listed in "Not priced: value to complete", never counted as zero. What is not priced by design is listed in "Out of scope": machine disks, Genie's language model, storage operations.
Your platform and "This project would add", on the same scope. The FinOps side measures DBUs at list price (system.billing.usage × list price, section 4): no cloud machines, no storage, no discount. The platform is thus Σ DBU cost at list price of its workloads (a workload's launcher apart), over the N days loaded, brought to an average month (× (365 ÷ 12) ÷ N). The project is brought to the same scope: its DBUs at list price (no discount), development included. "This project would add" = project DBUs at list price ÷ platform DBUs at list price a month. The reconciliation is shown and holds to the cent: project total = DBUs at list price − DBU discount + machines + storage. When a DBU part is not priced, the share is said to be "at least". Without FinOps costs loaded, or with unreadable billing, the page says so and no percentage is computed.
What weighs most on the total. Each value entered in a block that is on is moved by 20% one way then the other, the others fixed; the expected total is recomputed each time with the same prices. An integer (workers, people, clusters, flows) is rounded, and each value stays within its bounds (24 h a day, 31 days, 30 clusters...): the values tried are given with the row. Rows are ranked by the larger change; a value that does not change the total by a cent has no row.
Changing cloud. As for an estimate (section 13.3): each machine type is replaced by the cheapest of the new cloud with at least as many vCPUs and as much memory; the settings kept by a sizing tool, which name types of the old cloud, are removed.
Example. The BI warehouse for a domain model on the bundled Azure snapshot (October 15, 2026), East US, Premium, no discount: $3,443.92 a month expected, from $3,000.40 to $5,427.76, of which 20% development, the storage still to enter ("missing assumptions"). A test checks it (tests/v0240-calc24.test.mjs), with each block to the cent on a snapshot of round prices.
Data read back as hostile. The project record is read field by field: a known version, known blocks and known fields (any other name ignored, never a prototype key), numbers only and within their bounds (a string is never converted), known choices, machine types by their pattern; a tool's settings by an allowlist of names. A record that is not recognised makes the estimate an ordinary one. An attack test checks it (tests/security.test.mjs).
13.10 The sizing tools of a block (0.24)
"Size this block" opens a tool that computes, step by step, a value of the block from the user's figures; each step cites its source (Microsoft Learn or a published law) or is said to be "derived". Nothing is assumed when a measured figure is missing: the tool says what to enter. "Apply to the project" first shows a recap (the values before and after, the effect on the block and on the total), like "Use this duration" (section 13.3); the block then keeps the tool's settings with the date. The code is in extension/lib/calc-size.mjs.
-
Window of a job (ingestion, transformations). A measured trial (volume
V₀, durationT₀,w₀workers ofc₀cores) gives the workT₀ × w₀ × c₀in core-minutes; the work follows the volume (proportional rule, section 13.3):T₁ = T₀ × V ÷ V₀on the trial's cores. The time available is(window × 60 − startup) × (1 − margin). A sharesthat does not parallelize caps the speed-up (Amdahl's law): cores= ⌈(1 − s) × T₁ × C₀ ÷ (available − s × T₁)⌉withC₀ = w₀ × c₀, workers= ⌈cores ÷ cores per machine⌉, duration= T₁ × (s + (1 − s) × C₀ ÷ cores) + startup. Ifs × T₁alone exceeds the time available, no number of workers is enough, and the tool says so. The cluster startup is counted only when entered (measured). The price of a run is the engine's for an hour, prorated to the minutes. -
SQL warehouse (dashboards). Queries per second at the busiest time
λ = people × queries per person and hour ÷ 3,600 × burst factor; concurrent queriesL = λ × W,Wthe mean duration of a query in seconds (Little's law; the mean, not the median); clusters= ⌈L ÷ 10⌉. The month follows the block's rule (section 13.9). A maximum of clusters entered below the need is flagged: queries will wait at peak. An auto stop below the interface minimum is flagged. -
Cluster and auto termination (notebooks). Each time the team leaves, the cluster runs idle until it stops:
min(pause, auto termination)minutes; a pause shorter than the delay is paid in full. Hours on a day= active hours + departures × idle minutes ÷ 60; idle cost a month= departures × days × idle minutes ÷ 60 × price of a cluster hour, compared between the current and the proposed delay (10 to 10,000 minutes). -
Concurrency and endpoint size (served model). Concurrency
= requests per second × model execution time in seconds, provisioned in multiples of 4 up to 1,024 per model; sizes Small (0 to 4), Medium (8 to 16), Large (16 to 64), custom beyond. Assumption, said: while the endpoint runs, its concurrency stays at 4 at least; it only goes down to 0 with scale to zero, and 30 minutes stay billed after the traffic stops. On CPU, 1 DBU an hour per concurrent request; on GPU,concurrency ÷ 4replicas, each at its DBUs an hour. DBUs a day= peak hours × peak DBU/h + off-peak hours with traffic × off-peak DBU/h + hours without traffic × DBU/h of the minimum concurrency. The Model Serving DBU price is entered (absent from the snapshot). -
Storage over time. The block's rule (section 13.9), step by step: files kept
w × R, new data a month, last month, average month, cost at the price entered.
Data read back as hostile. The settings a block keeps are read through an allowlist of names, numbers within their bounds, booleans and short plain names; an unknown tool or an unknown block is ignored (section 13.9).
13.11 Services: units, rates and sources (0.25)
Since 0.25, the Calculator holds the data to price the services billed otherwise than classic compute and SQL: Model Serving, AI Search, Foundation Model APIs, proprietary models, Lakebase, Databricks Apps, AI Parse, AI Extract, AI Classify, Unity AI Gateway, Agent Evaluation, AI Runtime, Shutterstock ImageAI, Lakeflow Connect, Zerobus Ingest, default storage and platform add-ons. This section says where the rates and prices come from, how they combine and what is not published. The screens that use them follow the same rules.
The snapshot. extension/lib/prices/services.mjs is written by tools/service-rates.mjs, never by hand, from official data read on 26 October 2026:
-
the Databricks pricing pages (
databricks.com/product/pricing/<product>): their content is published as JSON (en-pricing-assets/page-data/.../page-data.json), table by table, with the visibility rule that says which cloud each table is for; the tool reads the tables cell by cell and the FAQ sentences through fixed patterns. A sentence that no longer matches stops the tool: it is read again by hand, nothing is guessed; -
the price data of those pages (
en-pricing-assets/data/pricing/cards.json): the list price of a DBU, a DSU or a unit, per plan, cloud and region, before any promotion; - Microsoft Learn, Serverless DBU consumption by SKU: the DBU and DSU multipliers of Azure Databricks;
- Microsoft Learn, system table reference pages (billing, prices, Model Serving costs, default storage): SKU names, billed products, units; the tool checks that each text it relies on is still there;
- the Microsoft Azure Databricks calculator data, read for comparison only (see below).
The extension never calls these sources. node tools/service-rates.mjs --check reads every source again and compares every value with the snapshot: 0 (same), 3 (changed), 1 (error), like tools/cloud-prices.mjs.
The rules. A value is kept as a source gives it, with the name of its source. A Microsoft Learn figure holds for Azure only; a databricks.com table holds for the clouds its visibility rule names; a FAQ sentence without a rule holds for all three. Two sources that give the same value up to rounding: the more precise one is kept, both are cited (AI Search Storage Optimized: 18.286 DBUs an hour in the FAQ, 18.29 in the table and on Learn; the page's examples land on 18.286). Two official sources that contradict each other for the same thing, cloud and unit: the value is left out (a conflict), both are listed, and the Calculator asks for it. A rate in DBUs per unit and a public price of the unit must agree (rate × public DBU price = public unit price, to the rounding of the data: 1.5 % or $0.0015); when they diverge in most regions of a cloud, it is a conflict.
Prices and their origin. As for the other workloads (section 13.2), each answer carries its origin: entered, else account price, else public price.
-
Price of a DBU (or a DSU): entered; else the account's list price, read from
system.billing.list_pricesby theyalineo:list-pricesquery; else the public price of the region and plan. - Price of a unit (GPU hour, GB, million tokens...): entered; else rate × an entered or account DBU price (an entered rate always goes through a DBU price); else the public price of the unit when the price data gives it; else rate × public DBU price. With public data only, the price Databricks shows is thus kept as is; the rate converts the account's price.
- A value nothing gives is never 0: the answer is empty and the screen asks for it.
The yalineo:list-prices query reads, on demand only (never in a refresh), one SELECT statement on system.billing.list_prices: sku_name, cloud, currency_code, usage_unit, the list price (pricing.default), the effective list price (pricing.effective_list.default, promotions included, when the column exists; a form without it serves older schemas) and the start day, for prices that have started and not ended, one cloud or all (named parameter :cloud), 5,000 rows at most. Its rows are read back as hostile by accountPrices(): a SKU name of the documented form (capitals, digits, _ and parentheses), a known unit (DBU or DSU), a three-letter currency, a price that is a finite number from 0 to 1,000; the effective price when present, else the list price. The names __proto__ or constructor never become keys (a Map). An attack test checks it (tests/security.test.mjs).
The account's SKU. Microsoft Learn documents the form <tier>_SERVERLESS_REAL_TIME_INFERENCE_<region> (and ..._LAUNCH_... for starts after a scale to zero); the other exact names are not published. An account price thus applies by a stated rule: the sku_name starts with the plan (or with no plan), holds every word of a group taken from the SKU name the pricing pages give (for example DATABASE and SERVERLESS for "Database Serverless Compute"), no excluded word (LAUNCH), and has the right unit and currency. One price among the SKUs kept: it applies. Several: the one whose name ends with the words of the region. Still several, or none: no account price, never a guess. The name of the SKU used goes with the price.
Formulas per service type. For one line, q is the quantity in the unit of its measure.
| Type | Units | Formula |
|---|---|---|
| Model Serving | CPU node hours; concurrent request hours (Azure); GPU instance hours | q × DBUs per unit × DBU price (Serverless Real-Time Inference SKU); q = instances (replicas) × hours |
| AI Search | unit hours; thousands of reranker requests; GB-months | units = ⌈vectors × dimensions ÷ 768 ÷ capacity of a unit⌉ (2 million in Standard, 64 million in Storage Optimized); units × hours × DBUs an hour × DBU price; Standard storage above 30 GB × price of a GB-month; reranker thousands × DBUs × DBU price |
| Foundation Model APIs | million tokens (input, output, cache read); hours per block of 50 model units; hours | tokens: Σ millions × DBUs per million × DBU price; provisioned throughput: hours × (model units ÷ 50) × DBUs an hour; batch: hours × DBUs an hour; regional endpoint of a model marked ⌖: DBUs × 1.1 |
| Proprietary models | million tokens (input, output, cache read and write); hours (batch) | Σ millions × DBUs per million × DBU price of the vendor's SKU, one global price; regional: × 1.1 for a model marked ⌖ |
| Lakebase | CU hours; GB-months | q = nodes × CU × hours; price of a CU hour (price rule above); the minimum of an always-on instance (scale to zero off for more than 24 hours) at the "always-on" price, the rest at the autoscaling price; storage and snapshots GB-months × DSUs per GB-month × DSU price, or the public price of a GB-month |
| Databricks Apps | active app hours | apps × hours × DBUs an hour × DBU price (Interactive Serverless) |
| AI Parse, AI Extract, AI Classify | thousands of pages, inputs, documents | low = thousands × lowest DBUs × DBU price; high = × highest DBUs (published estimates, on jobs over 3,000 pages for AI Parse) |
| Unity AI Gateway | GB of payload; million tokens | GB × DBUs per GB × DBU price, or the public price of a GB; millions × public price of a million |
| Agent Evaluation | million tokens; questions | (input millions × DBUs + output millions × DBUs) × DBU price; questions × DBUs per question × DBU price; or the public prices |
| AI Runtime | GPU hours | GPUs × hours × public price of a GPU hour (billed in DBUs on the Model Training SKU) |
| Shutterstock ImageAI | images | images × DBUs per image × DBU price, or the public price of an image |
| Lakeflow Connect | DBUs | billable DBUs a day = max(0, DBUs of the day − 100) per workspace (100 free DBUs a day); billable DBUs × days × DBU price (Jobs Serverless); a database's ingestion gateway is a classic Advanced pipeline, priced like any pipeline (section 13.3) |
| Zerobus Ingest | GB ingested | GB × DBUs per GB × DBU price (Jobs Serverless), or the public price of a GB |
| Default storage | GB-months; thousands of operations | (GB-months × 1 + thousands of tier 1 operations × DSUs + tier 2 × DSUs) × DSU price; a month counts 730 hours |
| Platform add-ons | share of spend | share × product spend at list price, before discounts, in the workspaces where the add-on is on; Mission Critical includes Enhanced Security and Compliance (one or the other); disaster recovery replication GB × public price of a GB |
What is not published (pages checked on 26 October 2026). The Calculator asks for the value:
- Model Serving: the DBUs per concurrent request on CPU on AWS and GCP (only Azure publishes them; databricks.com gives 4 DBUs per CPU node hour for the three clouds);
- AI Search: the DSUs per GB-month on AWS and GCP; those of Storage Optimized storage and its free part, everywhere (the public price of a GB-month is published);
- Foundation Model APIs: the DBU price of Azure's dedicated SKUs (ADI service, sold by Databricks) for the Kimi, DeepSeek, Inkling and GLM models;
- Lakebase: the DBUs per CU hour on AWS and GCP, and those of the always-on minimum everywhere (the public price of a CU hour is published);
- AI Extract and AI Classify: their SKU name (their DBU price is published);
- Unity AI Gateway, Agent Evaluation, Shutterstock ImageAI: the DBUs per unit on AWS and GCP (the public prices per unit are published);
- AI Runtime: the DBUs per GPU hour, everywhere; no price on GCP;
-
Lakeflow Connect: DBUs per hour or per GB for a connector; they are measured on a trial (
system.billing.usage, productLAKEFLOW_CONNECT).
Conflicts. Two in the snapshot of 26 October 2026:
- Lakebase, point-in-time restore (PITR): 8.7 DSUs per GB-month on Microsoft Learn, 8.60 on the Lakebase page. The rate is left out; the public price of a GB-month (for example $0.200 on AWS us-east-1) applies, else the value entered.
- Unity AI Gateway, inference tables of CPU and GPU endpoints, Azure: 7.143 DBUs per GB on Microsoft Learn, while the public price is $0.100 per GB at $0.07 a DBU (that is 1.429 DBUs). The Azure rate is left out; the public price of a GB applies.
Promotions. Public prices are list prices before promotion: for example 50 % off Lakebase until 31 January 2027, 15 % instead of 30 % for Mission Critical until 30 June 2027 (kept apart in the snapshot). Some proprietary model rows carry a note of the page (promotion included or not, with its date): the snapshot keeps the note's mark (footnote) and the screen shows it. The account's effective price (effective_list) includes the promotions in force.
Comparison with Microsoft's Azure calculator (Azure Premium prices, per region, 26 October 2026): Serverless Real-Time Inference 37 regions the same; Automated Serverless 38 the same; DSU 15 the same and 26 up to rounding (3 decimals against 4); disaster recovery replication 18 the same, 21 up to rounding, 1 different (North Central US: $0.020 against $0.024); Model Training 35 the same, 2 different (Switzerland North and West: $0.85 against $0.78); Anthropic $0.105 the same; Database Serverless Compute 2 the same and 39 different, Microsoft's calculator giving the promotional price (about half, for example East Asia $0.71 against $0.36). The snapshot keeps Databricks' data; --check lists the gaps.
The rates of the snapshot. Each row: the service type, the key (model, size, mode; · separates the parts), the clouds, the DBUs (or DSUs) per unit, the key of the public unit price when there is one, and the sources (list below). Units: node-hour node hour, concurrency-hour concurrent request hour, instance-hour instance hour, unit-hour unit hour, k-requests thousand requests, gb-month GB-month, input-mtok, output-mtok, cache-read-mtok, cache-write-mtok, cache-write-1h-mtok million tokens, hour-50mu hour per block of 50 model units, cu-hour CU hour, app-hour app hour, k-pages, k-inputs, k-documents thousand pages, inputs, documents, gb GB, mtok million tokens, question, gpu-hour GPU hour, image, dbu DBU, k-ops thousand operations, share share of spend. The public prices per region and plan are in the snapshot (prices, globalPrices).
| Service | Key | Clouds | DBU (or DSU) per unit | Public price per unit | Sources |
|---|---|---|---|---|---|
| agent-evaluation | judge | azure | 2.14 / input-mtok, 8.57 / output-mtok | agent-eval-input-mtok / input-mtok, agent-eval-output-mtok / output-mtok | learnServerless, dbxCards |
| agent-evaluation | synthetic | azure | 5 / question | agent-eval-question / question | learnServerless, dbxCards |
| ai-classify | short-text | aws, azure, gcp | 3 to 6 / k-documents | dbxAiFunctions | |
| ai-classify | rental-contracts | aws, azure, gcp | 40 to 60 / k-documents | dbxAiFunctions | |
| ai-extract | short-text | aws, azure, gcp | 30 to 60 / k-inputs | dbxAiFunctions | |
| ai-extract | invoices | aws, azure, gcp | 30 to 60 / k-inputs | dbxAiFunctions | |
| ai-extract | precision-complex-reasoning | aws, azure, gcp | 400 to 725 / k-inputs | dbxAiFunctions | |
| ai-extract | precision-deep-nesting | aws, azure, gcp | 375 to 700 / k-inputs | dbxAiFunctions | |
| ai-gateway | inference-tables-gb | all | conflict | inference-tables-gb / gb | learnServerless, dbxCards |
| ai-gateway | usage-tracking-gb | azure | 1.429 / gb | usage-tracking-gb / gb | learnServerless, dbxCards |
| ai-gateway | inference-tables-mtok | all | not published | inference-tables-mtok / mtok | dbxCards |
| ai-gateway | usage-tracking-mtok | all | not published | usage-tracking-mtok / mtok | dbxCards |
| ai-parse | low-simple-text | aws, azure, gcp | 10 to 15 / k-pages | dbxAiFunctions | |
| ai-parse | low-simple-text-with-sparse-tables-or-images | aws, azure, gcp | 20 to 25 / k-pages | dbxAiFunctions | |
| ai-parse | medium-text-with-complex-tables-figures-or-captions | aws, azure, gcp | 60 to 65 / k-pages | dbxAiFunctions | |
| ai-parse | high-dense-forms-or-complex-diagrams | aws, azure, gcp | 85 to 90 / k-pages | dbxAiFunctions | |
| ai-runtime | a10 | all | not published | ai-runtime-a10-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| ai-runtime | h100 | all | not published | ai-runtime-h100-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| ai-runtime | b300 | all | not published | ai-runtime-b300-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| apps | medium | aws, azure, gcp | 0.5 / app-hour | dbxApps, learnServerless | |
| apps | large | aws, azure, gcp | 1 / app-hour | dbxApps, learnServerless | |
| apps | xlarge | aws, azure, gcp | 3 / app-hour | dbxApps | |
| default-storage | stored | aws, azure, gcp | 1 / gb-month | dbxStorage, learnServerless | |
| default-storage | tier1 | aws, gcp | 0.2174 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier1 | azure | 0.3535 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier2 | aws, gcp | 0.0174 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier2 | azure | 0.0226 / k-ops | dbxStorage, learnServerless | |
| fm-api | bge-large · batch | aws, azure, gcp | 24 / hour | dbxFoundationModels | |
| fm-api | bge-large · ppt | aws, azure, gcp | 1.429 / input-mtok | dbxFoundationModels | |
| fm-api | bge-large · pt | aws, azure, gcp | 24 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · ppt | aws, azure, gcp | 4.286 / input-mtok, 17.143 / output-mtok, 0.429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · priority | aws, azure, gcp | 7.5 / input-mtok, 30 / output-mtok, 0.75 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · pt-1m | aws, azure, gcp | 142.857 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · pt-3m | aws, azure, gcp | 128.571 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-1017 · ppt | aws, gcp | 4.286 / input-mtok, 17.143 / output-mtok, 0.1 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-1017 · ppt | azure | 4.286 / input-mtok, 17.143 / output-mtok, 0.429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-flash · ppt | aws, azure, gcp | 2 / input-mtok, 4 / output-mtok, 0.4 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-pro · ppt | aws, azure, gcp | 18.857 / input-mtok, 56.571 / output-mtok, 1.886 / cache-read-mtok | dbxFoundationModels | |
| fm-api | gemma-3-12b · batch | aws, azure, gcp | 71.429 / hour | dbxFoundationModels | |
| fm-api | gemma-3-12b · ppt | aws, azure, gcp | 2.143 / input-mtok, 7.143 / output-mtok | dbxFoundationModels | |
| fm-api | gemma-3-12b · pt | aws, azure, gcp | 71.429 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · ppt | aws, azure, gcp | 20 / input-mtok, 62.857 / output-mtok, 3.714 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · priority | aws, azure, gcp | 35 / input-mtok, 110 / output-mtok, 6.5 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · pt-1m | aws, azure, gcp | 142.857 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · pt-3m | aws, azure, gcp | 128.571 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-3-flash · ppt | aws, azure, gcp | 2.143 / input-mtok, 7.143 / output-mtok, 0.429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-3-flash · priority | aws, azure, gcp | 3.75 / input-mtok, 12.5 / output-mtok, 0.75 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-3-flash · pt-1m | aws, azure, gcp | 142.857 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-3-flash · pt-3m | aws, azure, gcp | 128.571 / hour-50mu | dbxFoundationModels | |
| fm-api | gpt-oss-120b · batch | aws, azure, gcp | 71.429 / hour | dbxFoundationModels | |
| fm-api | gpt-oss-120b · ppt | aws, azure, gcp | 2.143 / input-mtok, 8.571 / output-mtok | dbxFoundationModels | |
| fm-api | gpt-oss-120b · pt | aws, azure, gcp | 71.429 / hour-50mu | dbxFoundationModels | |
| fm-api | gpt-oss-20b · batch | aws, azure, gcp | 53.571 / hour | dbxFoundationModels | |
| fm-api | gpt-oss-20b · ppt | aws, azure, gcp | 1 / input-mtok, 4.286 / output-mtok | dbxFoundationModels | |
| fm-api | gpt-oss-20b · pt | aws, azure, gcp | 53.571 / hour-50mu | dbxFoundationModels | |
| fm-api | gte · batch | aws, azure, gcp | 100 / hour | dbxFoundationModels | |
| fm-api | gte · ppt | aws, azure, gcp | 1.857 / input-mtok | dbxFoundationModels | |
| fm-api | gte · pt | aws, azure, gcp | 100 / hour-50mu | dbxFoundationModels | |
| fm-api | inkling · ppt | aws, azure, gcp | 14.286 / input-mtok, 57.857 / output-mtok, 2.429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k2-7 · ppt | aws, azure, gcp | 13.571 / input-mtok, 57.143 / output-mtok, 2.714 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · ppt | aws, azure, gcp | 42.857 / input-mtok, 214.286 / output-mtok, 4.286 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · priority | aws, azure, gcp | 75 / input-mtok, 375 / output-mtok, 7.5 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · pt-1m | aws, azure, gcp | 142.857 / hour-50mu | dbxFoundationModels | |
| fm-api | kimi-k3 · pt-3m | aws, azure, gcp | 128.571 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-1-8b · batch | aws, azure, gcp | 53.571 / hour | dbxFoundationModels | |
| fm-api | llama-3-1-8b · ppt | aws, azure, gcp | 2.143 / input-mtok, 6.429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-3-1-8b · pt | aws, azure, gcp | 53.571 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-2-1b · batch | aws, azure, gcp | 42.857 / hour | dbxFoundationModels | |
| fm-api | llama-3-2-1b · pt | aws, azure, gcp | 42.857 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-2-3b · batch | aws, azure, gcp | 46.429 / hour | dbxFoundationModels | |
| fm-api | llama-3-2-3b · pt | aws, azure, gcp | 46.429 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-3-70b · batch | aws, azure, gcp | 85.714 / hour | dbxFoundationModels | |
| fm-api | llama-3-3-70b · ppt | aws, azure, gcp | 7.143 / input-mtok, 21.429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-3-3-70b · pt | aws, azure, gcp | 85.714 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-4-maverick · batch | aws, azure, gcp | 85.714 / hour | dbxFoundationModels | |
| fm-api | llama-4-maverick · ppt | aws, azure, gcp | 7.143 / input-mtok, 21.429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-4-maverick · pt | aws, azure, gcp | 85.714 / hour-50mu | dbxFoundationModels | |
| fm-api | openjev-qwen-3-5-4b · ppt | aws, azure, gcp | 0.6 / input-mtok | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · batch | aws, azure, gcp | 50 / hour | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · ppt | aws, azure, gcp | 0.286 / input-mtok | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · pt | aws, azure, gcp | 50 / hour-50mu | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · batch | aws, azure, gcp | 85.714 / hour | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · ppt | aws, azure, gcp | 3.143 / input-mtok, 31.429 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · priority | aws, azure, gcp | 5.5 / input-mtok, 55 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · pt | aws, azure, gcp | 85.714 / hour-50mu | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · batch | aws, azure, gcp | 104.762 / hour | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · ppt | aws, azure, gcp | 2.143 / input-mtok, 17.143 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · pt | aws, azure, gcp | 104.762 / hour-50mu | dbxFoundationModels | |
| fm-proprietary | anthropic · claude-fable-5-1 · ppt | aws, azure, gcp | 142.857 / input-mtok, 714.286 / output-mtok, 3.571 / cache-read-mtok, 178.571 / cache-write-mtok, 285.714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-fable-5-5-1 · batch | aws, azure, gcp | 357.143 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-fable-5 · ppt | aws, azure, gcp | 142.857 / input-mtok, 714.286 / output-mtok, 14.286 / cache-read-mtok, 178.571 / cache-write-mtok, 285.714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-4-5 · batch | aws, azure, gcp | 114.286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-4-5 · ppt | aws, azure, gcp | 14.286 / input-mtok, 71.429 / output-mtok, 1.429 / cache-read-mtok, 17.857 / cache-write-mtok, 28.571 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · batch | aws, azure, gcp | 21.429 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · long-context · ppt | aws, azure, gcp | 7.143 / input-mtok, 35.714 / output-mtok, 0.714 / cache-read-mtok, 8.929 / cache-write-mtok, 14.286 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · short-context · ppt | aws, azure, gcp | 1.429 / input-mtok, 7.143 / output-mtok, 0.143 / cache-read-mtok, 1.786 / cache-write-mtok, 2.857 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-4-1 · batch | aws, azure, gcp | 514.286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-4-1 · ppt | aws, azure, gcp | 214.286 / input-mtok, 1071.43 / output-mtok, 21.429 / cache-read-mtok, 267.857 / cache-write-mtok, 428.571 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-5-4-6-4-7-4-8-5 · batch | aws, azure, gcp | 178.571 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-5-4-6-4-7-4-8-5 · ppt | aws, azure, gcp | 71.429 / input-mtok, 357.143 / output-mtok, 7.143 / cache-read-mtok, 89.286 / cache-write-mtok, 142.857 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-5-5 · ppt | aws, azure, gcp | 57.143 / input-mtok, 285.714 / output-mtok, 2.857 / cache-read-mtok, 71.429 / cache-write-mtok, 114.286 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4-5-4-6 · batch | aws, azure, gcp | 214.286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4-5-4-6 · ppt | aws, azure, gcp | 42.857 / input-mtok, 214.286 / output-mtok, 4.286 / cache-read-mtok, 53.571 / cache-write-mtok, 85.714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4 · batch | aws, azure, gcp | 214.286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4 · ppt | aws, azure, gcp | 42.857 / input-mtok, 214.286 / output-mtok, 4.286 / cache-read-mtok, 53.571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-5-5-5 · batch | aws, azure, gcp | 142.857 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-5-5-5 · ppt | aws, azure, gcp | 28.571 / input-mtok, 142.857 / output-mtok, 2.857 / cache-read-mtok, 35.714 / cache-write-mtok, 57.143 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · audio-tokens · ppt | aws, azure, gcp | 5.357 / input-mtok, 0.536 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · image-tokens · ppt | aws, azure, gcp | 1.786 / input-mtok, 0.179 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · text-tokens · ppt | aws, azure, gcp | 1.786 / input-mtok, 7.143 / output-mtok, 0.179 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · audio-tokens · ppt | aws, azure, gcp | 17.857 / input-mtok, 1.786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · audio-tokens · priority | aws, azure, gcp | 32.143 / input-mtok, 3.214 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · batch | aws, azure, gcp | 125 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · image-tokens · ppt | aws, azure, gcp | 8.929 / input-mtok, 0.893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · image-tokens · priority | aws, azure, gcp | 16.071 / input-mtok, 1.607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · text-tokens · ppt | aws, azure, gcp | 8.929 / input-mtok, 53.571 / output-mtok, 0.893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · text-tokens · priority | aws, azure, gcp | 16.071 / input-mtok, 96.429 / output-mtok, 1.607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-image · image-tokens · ppt | aws, azure, gcp | 8.929 / input-mtok, 1071.43 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-image · text-tokens · ppt | aws, azure, gcp | 8.929 / input-mtok, 53.571 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite-image · image-tokens · ppt | aws, azure, gcp | 4.464 / input-mtok, 535.714 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite-image · text-tokens · ppt | aws, azure, gcp | 4.464 / input-mtok, 26.786 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · audio-tokens · ppt | aws, azure, gcp | 8.929 / input-mtok, 0.893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · audio-tokens · priority | aws, azure, gcp | 16.071 / input-mtok, 1.607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · batch | aws, azure, gcp | 89.286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · image-tokens · ppt | aws, azure, gcp | 4.464 / input-mtok, 0.446 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · image-tokens · priority | aws, azure, gcp | 8.036 / input-mtok, 0.804 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · text-tokens · ppt | aws, azure, gcp | 4.464 / input-mtok, 26.786 / output-mtok, 0.446 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · text-tokens · priority | aws, azure, gcp | 8.036 / input-mtok, 48.214 / output-mtok, 0.804 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · batch | aws, azure, gcp | 230.429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · long-context · ppt | aws, azure, gcp | 71.429 / input-mtok, 321.429 / output-mtok, 7.143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · long-context · priority | aws, azure, gcp | 128.571 / input-mtok, 578.571 / output-mtok, 12.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · short-context · ppt | aws, azure, gcp | 35.714 / input-mtok, 214.286 / output-mtok, 3.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · short-context · priority | aws, azure, gcp | 64.286 / input-mtok, 385.714 / output-mtok, 6.429 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · batch | aws, azure, gcp | 121.429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · ppt | aws, azure, gcp | 5.357 / input-mtok, 44.643 / output-mtok, 0.536 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · priority | aws, azure, gcp | 9.643 / input-mtok, 80.357 / output-mtok, 0.964 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · batch | aws, azure, gcp | 196.429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · ppt | aws, azure, gcp | 26.786 / input-mtok, 160.714 / output-mtok, 2.679 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · priority | aws, azure, gcp | 48.214 / input-mtok, 289.286 / output-mtok, 4.821 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · batch | aws, azure, gcp | 74.286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · ppt | aws, azure, gcp | 10.714 / input-mtok, 53.571 / output-mtok, 1.071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · priority | aws, azure, gcp | 19.286 / input-mtok, 96.429 / output-mtok, 1.929 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · batch | aws, azure, gcp | 74.286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · ppt | aws, azure, gcp | 10.714 / input-mtok, 53.571 / output-mtok, 1.071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · priority | aws, azure, gcp | 19.286 / input-mtok, 96.429 / output-mtok, 1.929 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-pro-image · image-tokens · ppt | aws, azure, gcp | 35.714 / input-mtok, 2142.86 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-pro-image · text-tokens · ppt | aws, azure, gcp | 35.714 / input-mtok, 214.286 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · batch | aws, azure, gcp | 71.429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · ppt | aws, azure, gcp | 35.714 / input-mtok, 178.571 / output-mtok, 1.786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · priority | aws, azure, gcp | 64.286 / input-mtok, 321.429 / output-mtok, 3.214 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · batch | aws, azure, gcp | 184.286 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · ppt | aws, azure, gcp | 25 / input-mtok, 200 / output-mtok, 2.5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · priority | aws, azure, gcp | 50 / input-mtok, 400 / output-mtok, 5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-3-codex · ppt | aws, azure, gcp | 25 / input-mtok, 200 / output-mtok, 2.5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-3-codex · priority | aws, azure, gcp | 50 / input-mtok, 400 / output-mtok, 5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · batch | aws, azure, gcp | 107.143 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · ppt | aws, azure, gcp | 10.714 / input-mtok, 64.286 / output-mtok, 1.071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · priority | aws, azure, gcp | 21.429 / input-mtok, 128.571 / output-mtok, 2.143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-nano · batch | aws, azure, gcp | 71.429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-nano · ppt | aws, azure, gcp | 2.857 / input-mtok, 17.857 / output-mtok, 0.286 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · batch | aws, azure, gcp | 1142.86 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · long-context · ppt | aws, azure, gcp | 857.143 / input-mtok, 3857.14 / output-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · short-context · ppt | aws, azure, gcp | 428.571 / input-mtok, 2571.43 / output-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · batch | aws, azure, gcp | 192.857 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · long-context · ppt | aws, azure, gcp | 71.429 / input-mtok, 321.429 / output-mtok, 7.143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · priority | aws, azure, gcp | 71.429 / input-mtok, 428.571 / output-mtok, 7.143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · short-context · ppt | aws, azure, gcp | 35.714 / input-mtok, 214.286 / output-mtok, 3.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · batch | aws, azure, gcp | 131.429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · ppt | aws, azure, gcp | 17.857 / input-mtok, 142.857 / output-mtok, 1.786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · priority | aws, azure, gcp | 35.714 / input-mtok, 285.714 / output-mtok, 3.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · batch | aws, azure, gcp | 214.286 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · long-context · ppt | aws, azure, gcp | 142.857 / input-mtok, 642.857 / output-mtok, 14.286 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · priority | aws, azure, gcp | 178.571 / input-mtok, 1071.43 / output-mtok, 17.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · short-context · ppt | aws, azure, gcp | 71.429 / input-mtok, 428.571 / output-mtok, 7.143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · batch | aws, azure, gcp | 22.857 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · long-context · ppt | aws, azure, gcp | 5.714 / input-mtok, 25.714 / output-mtok, 0.571 / cache-read-mtok, 7.143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · long-context · priority | aws, azure, gcp | 11.429 / input-mtok, 51.429 / output-mtok, 1.143 / cache-read-mtok, 14.286 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · short-context · ppt | aws, azure, gcp | 2.857 / input-mtok, 17.143 / output-mtok, 0.286 / cache-read-mtok, 3.571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · short-context · priority | aws, azure, gcp | 5.714 / input-mtok, 34.286 / output-mtok, 0.571 / cache-read-mtok, 7.143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · batch | aws, azure, gcp | 171.429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · long-context · ppt | aws, azure, gcp | 114.286 / input-mtok, 428.571 / output-mtok, 11.429 / cache-read-mtok, 142.857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · long-context · priority | aws, azure, gcp | 228.571 / input-mtok, 857.143 / output-mtok, 22.857 / cache-read-mtok, 285.714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · short-context · ppt | aws, azure, gcp | 57.143 / input-mtok, 285.714 / output-mtok, 5.714 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · short-context · priority | aws, azure, gcp | 114.286 / input-mtok, 571.429 / output-mtok, 11.429 / cache-read-mtok, 142.857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · batch | aws, azure, gcp | 153.571 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · long-context · ppt | aws, azure, gcp | 57.143 / input-mtok, 257.143 / output-mtok, 5.714 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · long-context · priority | aws, azure, gcp | 114.286 / input-mtok, 514.286 / output-mtok, 11.429 / cache-read-mtok, 142.857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · short-context · ppt | aws, azure, gcp | 28.571 / input-mtok, 171.429 / output-mtok, 2.857 / cache-read-mtok, 35.714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · short-context · priority | aws, azure, gcp | 57.143 / input-mtok, 342.857 / output-mtok, 5.714 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · batch | aws, azure, gcp | 71.429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · ppt | aws, azure, gcp | 3.571 / input-mtok, 28.571 / output-mtok, 0.357 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · priority | aws, azure, gcp | 6.429 / input-mtok, 51.429 / output-mtok, 0.643 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-nano · batch | aws, azure, gcp | 53.571 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-nano · ppt | aws, azure, gcp | 0.714 / input-mtok, 5.714 / output-mtok, 0.071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · long-context · ppt | aws, azure, gcp | 57.143 / input-mtok, 214.286 / output-mtok, 2.857 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · long-context · priority | aws, azure, gcp | 114.286 / input-mtok, 428.57 / output-mtok, 5.714 / cache-read-mtok, 142.857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · short-context · ppt | aws, azure, gcp | 28.571 / input-mtok, 142.857 / output-mtok, 1.429 / cache-read-mtok, 35.714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · short-context · priority | aws, azure, gcp | 57.143 / input-mtok, 285.71 / output-mtok, 2.857 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · batch | aws, azure, gcp | 357.143 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · long-context · ppt | aws, azure, gcp | 285.714 / input-mtok, 1071.43 / output-mtok, 28.571 / cache-read-mtok, 357.143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · long-context · priority | aws, azure, gcp | 571.429 / input-mtok, 2142.86 / output-mtok, 57.143 / cache-read-mtok, 714.286 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · short-context · ppt | aws, azure, gcp | 142.857 / input-mtok, 714.286 / output-mtok, 14.286 / cache-read-mtok, 178.571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · short-context · priority | aws, azure, gcp | 285.714 / input-mtok, 1428.57 / output-mtok, 28.571 / cache-read-mtok, 357.143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · long-context · ppt | aws, azure, gcp | 2.857 / input-mtok, 10.71 / output-mtok, 0.286 / cache-read-mtok, 3.571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · long-context · priority | aws, azure, gcp | 5.714 / input-mtok, 21.43 / output-mtok, 0.571 / cache-read-mtok, 7.143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · short-context · ppt | aws, azure, gcp | 1.429 / input-mtok, 7.143 / output-mtok, 0.143 / cache-read-mtok, 1.786 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · short-context · priority | aws, azure, gcp | 2.857 / input-mtok, 14.29 / output-mtok, 0.286 / cache-read-mtok, 3.571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · long-context · ppt | aws, azure, gcp | 57.143 / input-mtok, 214.29 / output-mtok, 5.714 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · long-context · priority | aws, azure, gcp | 114.286 / input-mtok, 428.57 / output-mtok, 11.429 / cache-read-mtok, 142.857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · short-context · ppt | aws, azure, gcp | 28.571 / input-mtok, 142.857 / output-mtok, 2.857 / cache-read-mtok, 35.714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · short-context · priority | aws, azure, gcp | 57.143 / input-mtok, 285.71 / output-mtok, 5.714 / cache-read-mtok, 71.429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-5 · image-tokens · ppt | aws, azure, gcp | 114.286 / input-mtok, 457.143 / output-mtok, 28.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-5 · text-tokens · ppt | aws, azure, gcp | 71.429 / input-mtok, 142.857 / output-mtok, 17.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-mini · image-tokens · ppt | aws, azure, gcp | 35.714 / input-mtok, 114.286 / output-mtok, 3.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-mini · text-tokens · ppt | aws, azure, gcp | 28.571 / input-mtok, 2.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1 · image-tokens · ppt | aws, azure, gcp | 142.857 / input-mtok, 571.429 / output-mtok, 35.714 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1 · text-tokens · ppt | aws, azure, gcp | 71.429 / input-mtok, 17.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-2 · image-tokens · ppt | aws, azure, gcp | 114.286 / input-mtok, 428.571 / output-mtok, 28.571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-2 · text-tokens · ppt | aws, azure, gcp | 71.429 / input-mtok, 17.857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | spacexai · grok-4-6-4-7 · batch | aws, azure, gcp | 153.571 / hour | dbxProprietary | |
| fm-proprietary | spacexai · grok-4-6-4-7 · ppt | aws, azure, gcp | 35.714 / input-mtok, 107.143 / output-mtok, 8.929 / cache-read-mtok | dbxProprietary | |
| lakebase | autoscaling | azure | 0.213 / cu-hour | lakebase-cu-hour / cu-hour | learnServerless, dbxCards |
| lakebase | always-on | all | not published | lakebase-always-on-cu-hour / cu-hour | dbxLakebase, dbxCards |
| lakebase | storage | aws, azure, gcp | 15 / gb-month | lakebase-storage-gb-month / gb-month | learnServerless, dbxLakebase, dbxCards |
| lakebase | pitr | all | conflict | lakebase-pitr-gb-month / gb-month | dbxCards |
| lakebase | snapshot | aws, azure, gcp | 3.91 / gb-month | lakebase-snapshot-gb-month / gb-month | learnServerless, dbxLakebase, dbxCards |
| lakeflow-connect | pipeline | aws, azure, gcp | 1 / dbu | dbxLakeflowConnect | |
| model-serving | cpu | aws, azure, gcp | 4 / node-hour | dbxModelServing | |
| model-serving | cpu-concurrency | azure | 1 / concurrency-hour | learnServerless | |
| model-serving | gpu-a100-40gb-x8 | aws, azure | 538.4 / instance-hour | dbxModelServing | |
| model-serving | gpu-a100-80gb-x1 | azure | 78.6 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x2 | azure | 157.2 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x4 | azure | 314.4 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x8 | aws, azure | 628 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x1 | aws, azure, gcp | 20 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x4 | aws, azure | 112 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x8 | aws, azure | 290.8 / instance-hour | dbxModelServing | |
| model-serving | gpu-h100-x1 | aws, azure | 100 / instance-hour | dbxModelServing | |
| model-serving | gpu-h100-x8 | aws, azure | 800 / instance-hour | dbxModelServing | |
| model-serving | gpu-l40s-x1 | aws | 44.86 / instance-hour | dbxModelServing | |
| model-serving | gpu-rtx-pro-6000-x1 | aws | 80 / instance-hour | dbxModelServing | |
| model-serving | gpu-rtx-pro-6000-x1 | azure | 94.29 / instance-hour | dbxModelServing | |
| model-serving | gpu-t4-x1 | aws, azure | 10.48 / instance-hour | dbxModelServing, learnServerless | |
| platform-addons | esc | aws, gcp | 0.15 / share | dbxPlatformAddons | |
| platform-addons | esc | azure | 0.1 / share | dbxPlatformAddons | |
| platform-addons | mission-critical | aws, azure | 0.3 / share | dbxPlatformAddons | |
| platform-addons | dr-replication | all | not published | dr-replication-gb / gb | dbxCards |
| shutterstock | image | azure | 0.857 / image | shutterstock-image / image | learnServerless, dbxCards |
| vector-search | standard | aws, azure, gcp | 4 / unit-hour | vs-standard-unit-hour / unit-hour | dbxAiSearch, learnServerless, dbxCards |
| vector-search | storage-optimized | aws, azure, gcp | 18.286 / unit-hour | vs-storage-optimized-unit-hour / unit-hour | dbxAiSearch, learnServerless |
| vector-search | reranker | aws, azure, gcp | 28.571 / k-requests | learnServerless, dbxAiSearch | |
| vector-search | standard-storage | azure | 10 / gb-month | vs-standard-gb-month / gb-month | learnServerless, dbxAiSearch, dbxCards |
| vector-search | storage-optimized-storage | all | not published | vs-storage-optimized-gb-month / gb-month | dbxCards |
| zerobus | standard | aws, azure, gcp | 0.143 / gb | zerobus-gb / gb | dbxLakeflowConnect, dbxCards |
| zerobus | otel | aws, azure, gcp | 0.222 / gb | zerobus-otel-gb / gb | dbxLakeflowConnect, dbxCards |
Sources (read on 2026-10-26):
-
dbxCards: Databricks: pricing pages data, list prices per product, plan, cloud and region (databricks.com), https://www.databricks.com/product/pricing (price data of the pages,cards.json) -
dbxModelServing: Databricks: Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/model-serving (page data as JSON) -
dbxFoundationModels: Databricks: Foundation Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/foundation-model-serving (page data as JSON) -
dbxProprietary: Databricks: Proprietary Foundation Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/proprietary-foundation-model-serving (page data as JSON) -
dbxAiSearch: Databricks: AI Search pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-search (page data as JSON) -
dbxLakebase: Databricks: Lakebase pricing page (databricks.com), https://www.databricks.com/product/pricing/lakebase (page data as JSON) -
dbxApps: Databricks: Databricks Apps pricing page (databricks.com), https://www.databricks.com/product/pricing/databricks-apps (page data as JSON) -
dbxLakeflowConnect: Databricks: Lakeflow Connect pricing page (databricks.com), https://www.databricks.com/product/pricing/lakeflow-connect (page data as JSON) -
dbxAiFunctions: Databricks: AI Functions pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-functions (page data as JSON) -
dbxAiGateway: Databricks: Unity Gateway pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-gateway (page data as JSON) -
dbxAgentEvaluation: Databricks: Agent Evaluation pricing page (databricks.com), https://www.databricks.com/product/pricing/agent-evaluation (page data as JSON) -
dbxAiRuntime: Databricks: AI Runtime pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-runtime (page data as JSON) -
dbxStorage: Databricks: Storage pricing page (databricks.com), https://www.databricks.com/product/pricing/storage (page data as JSON) -
dbxPlatformAddons: Databricks: Platform tiers and add-ons pricing page (databricks.com), https://www.databricks.com/product/pricing/platform-addons (page data as JSON) -
learnServerless: Microsoft Learn: Serverless DBU consumption by SKU (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/resources/pricing -
learnServingCost: Microsoft Learn: Monitor model serving costs (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/model-serving-cost -
learnBilling: Microsoft Learn: Billable usage system table reference (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/billing -
learnListPrices: Microsoft Learn: Pricing system table reference (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/pricing -
learnDefaultStorage: Microsoft Learn: Monitor default storage costs (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/usage/default-storage -
azureCalculator: Microsoft Azure: Azure Databricks pricing calculator data (azure.microsoft.com), https://azure.microsoft.com/pricing/details/databricks (data: https://azure.microsoft.com/api/v3/pricing/databricks/calculator/)
Data read back as hostile. The rows of list-prices go through accountPrices(); entered values through cleanServiceOverrides() (known names, numbers only, from 0 to 1,000 for a price, never a prototype key). The code is in extension/lib/calc-services-price.mjs; the tests in tests/v0250-rates25.test.mjs, including the published examples computed again (AI Search: 5 million vectors, 3 units, 720 hours, 8,640 DBUs, $605; Databricks Apps: 5 Medium apps for 30 days, 1,800 DBUs, $1,350).
13.12 Pricing a service in an estimate (0.25)
Since 0.25, an estimate also prices the services of section 13.11, next to its jobs, pipelines, SQL warehouses and clusters: "Service" in the add bar opens a menu in two groups, "AI and models" (Model Serving, Foundation Model APIs, proprietary models, AI Search, Agent Evaluation, Unity AI Gateway, AI Parse, AI Extract, AI Classify, AI Runtime, Shutterstock ImageAI) and "Data and platform" (Lakebase, Databricks Apps, Lakeflow Connect, Zerobus Ingest, default storage, platform add-ons). A service workload goes through the same engine as the others (estimateLine, estimateTotals): it counts in the total to the cent, in the pricing state, the comparison, the exports and the two ways to reopen an estimate. The code is in extension/lib/calc-services.mjs (engine, pure) and extension/lib/calc-services-ui.mjs (forms).
A service workload. It has a type, a rate key (a model and its mode, a size, an endpoint type; the choices are those the estimate's cloud offers in the snapshot) and quantities per month. It splits into parts, one per rate key and unit, each with its quantity q:
| Type | Quantities entered | Parts and q |
|---|---|---|
| Model Serving | instances (or nodes, or concurrent requests), hours a month | instances × hours, in the unit of the rate chosen |
| AI Search | vectors (millions), dimensions, hours, storage (GB), reranked queries (thousands) | units = ⌈vectors × dimensions ÷ 768 ÷ capacity of a unit⌉, q = units × hours; storage max(0, GB − free part); reranking in thousands of queries |
| Foundation Model APIs, proprietary models | million tokens per kind (input, output, cache); or model units and hours (provisioned throughput); or hours (batch) | one q per kind of token; hours × units ÷ 50; hours |
| Agent Evaluation | judge tokens (input, output), synthetic questions | one part per unit |
| Unity AI Gateway | GB and million tokens, inference tables and usage tracking | one part per feature and unit |
| AI Parse, AI Extract, AI Classify | thousands of pages, inputs, documents | one part, with a range |
| AI Runtime | GPUs, hours per GPU | GPUs × hours |
| Shutterstock ImageAI | images | images |
| Lakebase | nodes, minimum and maximum CU, hours at the maximum, scale to zero and active hours, storage, PITR, snapshots (GB) | see below |
| Databricks Apps | apps, active hours | apps × hours |
| Lakeflow Connect | DBUs a day per workspace (measured on a trial), workspaces, days | workspaces × max(0, DBUs a day − free part) × days |
| Zerobus Ingest | GB ingested | GB |
| Default storage | GB stored (average of the month, in GB-months), thousands of tier 1 and tier 2 operations | one part per unit |
| Platform add-ons | none (share of spend); GB replicated for disaster recovery | see below |
A main quantity left empty is still to enter: the workload is "missing assumptions", never priced at 0. An optional quantity left empty (cache read tokens, for example) counts as "not used".
The price of a unit and its origin. For each part, the rule of section 13.11, applied to the values entered in the workload: a price per unit entered; else the rate (entered, or the snapshot's) × a price per DBU (or DSU) entered or of the account (system.billing.list_prices, read on demand); else the public price of the unit when the pricing data gives it; else the rate × the public price per DBU. Cost of the part = q × unit price × factor × (1 − discount), rounded to the cent; the workload is the sum of its parts, the estimate the sum of its workloads. Each part shows its origin: entered, account price or public price, and the "Price origin" line sums them up. The DBUs (or DSUs) of a part are q × rate × factor when the rate is published; a part priced by a public price per unit alone has no known DBUs, which the screen says.
Ranges. AI Parse, AI Extract and AI Classify publish DBUs per thousand as a range (10 to 15 DBUs per thousand pages of simple text, for example). The part then has a low end q × min × price and a high end q × max × price, each rounded to the cent; its figure is the middle of the range, (low + high) ÷ 2 in cents, a rule said as such (an assumption listed "to check"). The low and high ends add up in the estimate's total ("services range") and in its year (× 12). Example: 10 thousand pages of simple text at $0.07 per DBU give $7.00 to $10.50, so $8.75.
Free parts, by a published rule.
- AI Search Standard: storage above 30 GB only (FAQ of the AI Search page: "Storage Overage for storage volumes greater than 30GB"), for the workload's index. No free part is published for Storage Optimized: all its storage is counted, and the screen says so.
- Lakeflow Connect: 100 free DBUs a day per workspace for managed connectors (FAQ of the Lakeflow Connect page). The DBUs a day of a workspace are measured on a trial; under the free part, the cost is $0, priced and said. A database gateway is a classic Advanced pipeline, to add as a pipeline.
-
Lakebase: an instance without scale to zero for more than 24 hours is "always on" (FAQ of the Lakebase page). Always on:
nodes × minimum CU × 730 hat the always-on price, thennodes × (maximum CU − minimum CU) × hours at the maximumat the autoscaling price. With scale to zero:nodes × (minimum CU × (active hours − hours at the maximum) + maximum CU × hours at the maximum)at the autoscaling price. Storage, point-in-time restore and snapshots are paid per GB-month.
In-geo uplift. A ⌖ model served from an in-geo endpoint (to keep data in a geography) costs DBUs × (1 + uplift): the uplift is entered in the workload, 10 % by default, the snapshot's value (inGeoUplift); the factor also multiplies the DBUs shown.
Platform add-ons, computed after the other workloads. Enhanced Security and Compliance (15 % on AWS and GCP Enterprise, 10 % on Azure Premium) and Mission Critical (30 % on AWS Enterprise and Azure Premium; 15 % in promotion until June 30, 2027, to check, the date shown) are a share of the product spend at list price, before discounts, of the estimate's other workloads (taken as the workloads of the workspaces where the add-on is on, an assumption of the estimate): the DBUs × the price per DBU used for a new workload, the list cost of a measured one, the cost before discount of a service workload; never the cloud's machines, nor the add-ons themselves. Another workload not priced leaves the base incomplete: the add-on is then not priced (never on a part of the spend), and the screen says how many workloads are missing. Mission Critical includes Enhanced Security and Compliance: with both, or the same one twice, the one included is to remove ("missing assumptions"). An add-on needs its plan (Enhanced Security and Compliance on AWS: Enterprise). Disaster recovery replication is paid per GB, at the public price. A range in the base gives the add-on a range.
Contract discounts, by billing unit. The two existing discounts apply this way:
| What the part bills | Discount | Why |
|---|---|---|
| DBUs (rates in DBU, or prices per unit of a service billed in DBUs: models, AI Search, Apps, Lakebase compute, AI Runtime, Zerobus, Lakeflow Connect, AI Functions, Gateway, Agent Evaluation, Shutterstock) | the DBU discount | the Databricks contract discounts DBUs |
| storage: DSU, or storage per GB-month (default storage, AI Search storage, Lakebase storage, PITR and snapshots) | none | Microsoft Learn, Optimize Azure Databricks costs with a prepurchase: the prepurchase discount "applies only to the DBU usage", storage is "charged separately" |
| a platform add-on (share of spend, replication) | none | it is computed on the spend at list price before discounts |
The machine discount never applies to a service: it has no cloud machines here. A contract that also discounts storage is reflected by an entered price per DSU. Example: 100 hours of a Medium app ($0.375 an hour on AWS us-east-1) with a 25 % DBU discount make 100 × 0.375 × 0.75 = $28.13; 1,000 GB-months of default storage at $0.023 per DSU stay $23.00.
What is not published. When nothing gives the price of a unit (section 13.11: not published, or two official sources that disagree with no public price of the unit), the part is not priced and the workload neither: "missing assumptions", with the reason (rate not published for this cloud, price per DBU of the SKU not published, conflict and its two values) and the pages checked (notPublished). The workload then offers to enter the rate in DBUs per unit (multiplied by the price per DBU), the price per DBU of its SKU, or the price of the unit itself; the value entered is kept with the workload and shows "entered". A choice that does not exist on the estimate's cloud (a GPU that is absent, Mission Critical on GCP) is said, with the request to choose another one; an estimate that changes cloud keeps its service workloads, priced for the new cloud, and the message says how many do not exist there. Without a region, nothing is priced ("region to choose"). A region the services snapshot does not cover leaves the part "not priced", with the reason.
The account's prices. A line above the workloads says how many service prices come from the account and when they were read; "Read my account's prices" runs the read-only query yalineo:list-prices when a workspace is connected. A saved estimate keeps the prices it used: reopened as saved, it keeps its public prices even after the account is read; "Recompute with the current data" takes the account's.
What an estimate keeps. For each rate key used, the estimate keeps the rate (DBUs or DSUs per unit, a number or a range), the price per DBU or DSU (public or the account's, with the account's SKU name) and the public prices of the units, each with the date of its snapshot. Reopened as saved, it gives the same total to the cent; a newer snapshot only changes it under "Recompute with the current data", the difference counted in the prices part (section 13.8). The values entered in a workload are its settings: they always apply. While the services snapshot loads, what was kept stays kept. Read back as hostile data: a known type, a key of the documented form (never __proto__ nor constructor), known units, numbers only and within their bounds (a string, NaN or a huge number is left out, never converted), known origins; a workload of an unknown type is left out. The share of a platform add-on is kept only as a number from 0 to 1; a share that is not one (another unit, a range, more than 100 %) never prices the add-on: it stays "missing assumptions" (R-140). A quantity whose rate key is missing from the data is said the same way, never counted as 0 in a priced workload (R-141). Attack tests check it (tests/security.test.mjs).
Exports. The CSV keeps its 0.23 columns (one row per workload, of kind service <type>, then the total) and adds, when the estimate has services, a second table, part by part: type, rate key, unit, quantity a month, rate and its unit, rate origin, price per DBU or DSU and its origin, unit price and its origin, discount, cost a month, low and high ends, state. The summary copied as Markdown gives the range and each service workload part by part. Every cell and every text stays inert (lib/csv.mjs, mdText).
Worked cases of services. Four cases join the six of section 13.3, with the same structure (the need, what to gather, what to try, what to keep in mind); their inputs are fictional assumptions, said in the guide and the notes, their rates and prices come from the snapshot:
- the document assistant (AI Search Standard, 2 million vectors of 1,024 dimensions, 50 GB; Llama 3.3 70B per token, 60 and 12 million tokens; one Model Serving CPU node; one Medium app 264 hours);
- supplier invoices (AI Parse, 30,000 pages; AI Extract, 20,000 invoices; a serverless job of 4 DBUs per run, one a day);
- the field technicians' app (Lakebase, 1 node from 1 to 4 CU, always on, 120 hours at the maximum, 100 GB and 50 GB of restore; two Medium apps all month): $675.49 a month on AWS us-east-1;
-
sensors and the CRM, continuously (Zerobus, 600 GB; Lakeflow Connect, 160 DBUs a day on one workspace): $668.75 a month on AWS us-east-1, of which
(160 − 100) × 365 ÷ 12 × 0.35 =$638.75 of Lakeflow Connect.
An estimate opened from a case keeps the case's key (caseId), like the six others. Its title, its notes and the names of its workloads follow the language of the page as long as the user has not renamed them, like those of the six other cases; so does the name of a workload added from the "Service" menu (the name of its type).
Costing a data project (section 13.9). A project's served model, sized in DBUs a day, takes the Model Serving price per DBU (Serverless Real-Time Inference SKU: the account's, else the public price of the region and plan) while no price is entered; the field says so, an entered price wins. Genie has no rate in the services snapshot (its language model stays out of a project's scope, section 13.9); since 0.32, the "AI: Genie and agents" page prices it from the measured DBUs per question, at the price of a DBU of that same Serverless Real-Time Inference SKU (section 13.16).
Verification. tests/v0250-svc25.test.mjs computes again each formula by type, the published examples through the estimate (AI Search: 5 million vectors, 3 units, 720 hours, 8,640 DBUs, $604.80 so $605; Storage Optimized: 50 million vectors, 1 unit, 13,166 DBUs, $921.60 so $922; Databricks Apps: 5 Medium apps 720 hours, 1,800 DBUs, $1,350; Kimi K3: $3.00 per million input tokens on AWS), the ranges, the free parts, the uplift, the add-ons, the discount rule, the totals to the cent, the kept prices and the four cases on the three clouds.
13.13 Estimate tools: account prices, tokens, Excel, file, assistant (0.25)
Since 0.25, the Calculator has five more tools. None adds a calculation rule: they read, compare or export the figures of sections 13.1 to 13.11.
SKU prices (page "SKU prices", Simulations side). "Read my account prices" runs the yalineo:list-prices query (section 13.11), only on that click; its rows go through accountPrices() and stay in the page's memory. Each SKU shows its unit, list price, effective price (promotions included, when the column exists) and first day. A SKU's family is a word of its name (the plan left out), for example JOBS, SQL, SERVERLESS. For a SKU, quantity × price = the quantity typed × the effective price (else the list price), rounded to the cent once; the total of the quantities typed is the sum of these rounded amounts. These are prices before contract discounts. Without account prices (fictional example, no workspace, read refused, no readable row), the page shows the public prices of the bundled snapshots, said as such with their date: the DBU price of each product of the cloud snapshot for the region and plan chosen, then the price of each SKU of the services snapshot (one global price for model vendors). A services SKU at the same price as a product of the cloud snapshot is not repeated; at another price, both stay, each with its source. The CSV export goes through lib/csv.mjs.
Token prices (page "Token prices"). For each model checked (served by Databricks or proprietary, from the services snapshot), a month of use is priced by the formulas of section 13.11: tokens Σ millions × DBU per million × price of a DBU; batch hours × DBU per hour × price of a DBU; provisioned throughput hours × (model units ÷ 50) × DBU per hour × price of a DBU (no reservation, reserved 1 month or 3 months); an in-geo endpoint of a model marked ⌖: DBU × (1 + 10 %). The price of a DBU follows the order of section 13.11 (entered, else the account's, else public) and its origin is shown. The cost per month is rounded to the cent once, per year = 12 × per month. The table ranks the fully priced models first, cheapest first; then the partial ones (a quantity typed with no published rate for that model, for example output tokens for an embeddings model); then those without a price or without a rate of the type chosen, with the reason. Nothing that is not published counts as zero. A DBU price that is not published names the SKU in full, as the snapshot writes it (in English, never cut nor translated), and the pages checked. "Add to the estimate", on each priced model, makes it a service workload (section 13.12): its type, its rate key for the price shown and the quantities typed (millions of tokens of each kind, or hours and model units), the in-geo endpoint when it is applied. It joins the open estimate of the same cloud, otherwise a new estimate "Compared models" (60 workloads and 30 estimates at most); it is priced there with the region, plan and discounts of the estimate, each part rounded to the cent: its cost before discount can differ from the comparator's by one cent per part at most.
Excel export ("Export as Excel", next to "Export as CSV"). A workbook of four sheets, written without a library (lib/sheet.mjs): Summary (the estimate, its cloud, region, plan, discounts, totals per month and per year, its pricing state with what is missing, the assumptions to check and what is out of scope, the data it is computed with, the dates of the snapshots and of the account prices, where the values come from); Lines (one row per workload, read generically from the result of its calculation: name, kind, description, fields, hours and runs per month, DBUs, every part of the cost, total per month and per year, state, origins, gaps, calculation step by step); Prices used (each value a workload used, with its origin and the names of its sources); Notes (the sections of this methodology). Numbers are numbers, text is inline text, never a formula; the characters XML refuses are removed. The rows add up to the total to the cent, as on screen. A service workload has its own parts there, in words (low and high of a range, list price before discount, DSUs, a quantity and not an amount), its calculation step by step and, in "Prices used", each unit price with its type, the name of its rate, its unit and the sources of the services snapshot.
Estimate file ("Export the estimate file", "Import an estimate"). To share an estimate without a server: a JSON file { format: 'yalineo-estimate', version: 1, exported, estimate }, the estimate as it is kept, with the values of its prices (section 13.8). The import reads a file the user picked as hostile data: 1 MB at most, JSON.parse only, format and version checked, then cleanEstimate field by field (known names, bounded numbers, no prototype key, 60 workloads at most); a workload of an unknown kind, or a service workload of an unknown service type, is left out and counted, never turned into another one; the workloads beyond 60 are counted apart. The imported estimate gets a new identifier, new workload identifiers and a name marked "(imported)"; the limit of 30 estimates applies. Its kept prices come from the file: "Recompute with the current data" compares them with today's prices.
Assistant (a Calculator setting, off by default). The user gives the name of a serving endpoint of their workspace (letters, digits, _, ., -, 64 characters at most) and turns it on. On an estimate's page, "Describe a workload" sends, only on the "Propose" click, a yalineo:assistant query: SELECT ai_query(:endpoint, :prompt) AS answer, two named parameters, through the read-only guard. The prompt is fixed instructions, the kinds of workload and their fields taken from the Calculator's code (allowed values from its lists, bounds from its own cleaner), the service types in the form of a service workload (the type, a rate key offered on the estimate's cloud, the inputs of the type with their bounds, its measures from the services snapshot), then the description (2,000 characters at most); it never exceeds its bound and the description is never cut. The answer is hostile data: the first JSON object or array is read (a bounded scan, JSON.parse only), 20 proposals at most, each checked field by field (known fields, finite numbers within bounds, values from the lists, instance types of the documented form, text as text) before cleanLine makes a workload of it; a service workload goes through cleanServiceProposal (a known type, a rate key offered on this cloud, never guessed when the type asks for a choice, inputs of the type within their bounds); what is left out is said, with the reason. Nothing is added without a click of the user, workload by workload or all. The description is not stored; the health journal keeps only the code of an error of this query. Databricks bills the call to the user's account and may keep the query in its history. The description goes to the endpoint named; if it serves an external model (OpenAI, Anthropic, Google...), Databricks passes it on to that provider; an endpoint without tools is the one to choose, an agent with tools could act. The screen says so.
13.14 Tune, size, buy: the tools of the Simulations by capability (0.27)
Since 0.27, the Simulations side sorts its calculations by capability (engineering, data science, analytics, dashboards, architecture) and by role. Eight tools join the five of section 13.10; their code is in extension/lib/calc-tune.mjs. Since 0.32, a ninth, "Size a data ingestion" (ingestion, section 13.14.9), follows the same rules; its code is in extension/lib/calc-ingest32.mjs and its pages were read on October 30, 2026. Each one says its formula in words, step by step, with the user's own figures; each step cites its official page (read on October 27, 2026) or is said "derived" (arithmetic on the steps before). Prices come only from the Calculator's engine: estimate for one hour of the workload (DBUs × DBU price and machines, minus the estimate's discounts), with the estimate's dated snapshot or the prices entered; the tool writes no price. It gives back each price its answer used (prices), as the estimate read it, with its origin: the product's DBU, each machine with its way to pay (the driver apart), the machines of a warehouse cluster entered, the measured cost of an hour (a job's timeout) or the storage price entered (Delta files); "Prices used and their origin" shows them (section 13.15). A measured figure that is missing is listed (missing) and nothing is computed in its place; without a price for a machine or a product (for example GCP machines, which the snapshot does not publish), the sizing is given without a cost, and the screen says so. Amounts are rounded to the cent once; a total shown as the sum of parts is the sum of those rounded parts. The examples tell fictional cases (no real company); their prices are those of the estimate's snapshot.
Inputs are read as hostile data: only own value properties are read (never an accessor, never __proto__, constructor or prototype), a number must be a finite number and is brought within its bounds, a list is read up to 200 values, a choice must belong to its list. A calculation never throws: at worst it computes nothing.
Defaults. A default is either the Databricks one, with its page (retries, interval, retention, auto stop), or a YALineo convention said as such (a 20% timeout margin, as the job window of section 13.10; 22 viewing days a month, as the blocks of section 13.9; an average month of 365 ÷ 12 days), or 0 when 0 means "not counted".
13.14.1 Timeout and retries of a job (jobTimeout)
-
Base: the measured 95th percentile of the durations. Entered, it wins; else it is computed on the list of runs by the nearest-rank method, rank
⌈0.95 × n⌉of the sorted durations (with fewer than 20 runs, that rank is the last one: the tool says so); else the longest duration, said as a wider base. -
Timeout
T = ⌈base × (1 + margin)⌉minutes. Databricks publishes no figure to choose a timeout: the margin is the user's choice (20% by default, a YALineo convention). The run duration warning proposed is the base. -
Attempts after a timeout
A = retries + 1when retry on timeout is on, else 1: by default no timeout, no retry, immediate retry and no retry after a timeout (Microsoft Learn, Jobs API 2.0, https://learn.microsoft.com/azure/databricks/reference/jobs-2.0-api, read on October 27, 2026). -
Worst total duration
T + (A − 1) × max(T, interval): the timeout applies to each retry and the interval between retries counts from the start of the failed run (Microsoft Learn, Configure and edit tasks in Lakeflow Jobs, https://learn.microsoft.com/azure/databricks/jobs/configure-task, read on October 27, 2026). -
Worst cost of a run
A × T ÷ 60 × price of an hour; the hour is that of jobs compute on demand (driver and workers, Photon when ticked), or a measured cost of an hour entered. -
Timeout too short (the current timeout
Centered): the share of runs killed is measured on the list (durations > C ÷ n); without a list, only a lower bound (at least 50% under the median, at least 5% under the 95th percentile). Cost a monthruns a month × share × A × C ÷ 60 × hour, if every attempt lasts as long as the first (said). A hang without a timeout costshang hours × hour. -
Inputs: durations come from
system.lakeflow.job_run_timeline(Microsoft Learn, Jobs system table reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/jobs, read on October 27, 2026). On serverless, auto-optimization already retries by default (Microsoft Learn, Run your Lakeflow Jobs with serverless compute for workflows, https://learn.microsoft.com/azure/databricks/jobs/run-serverless-jobs, read on October 27, 2026).
13.14.2 Minimum and maximum autoscaling workers (autoscale)
-
Workers of a level
⌈busy cores ÷ cores of a machine⌉for the low, mean and peak levels (hours a day and cores measured, for examplecpu_user_percent× cores insystem.compute.node_timeline: Microsoft Learn, Compute system tables reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/compute, read on October 27, 2026). The cores of a machine come from the Calculator's snapshot. Minimum = the lowest, maximum = the highest. -
Month with autoscaling
days × Σ hours of the level × price of an hour at its workers; month at fixed sizedays × Σ hours × price of an hour at the maximum; saving = the difference, to the cent. - What is assumed, and said: the cluster follows the load, the best case. Optimized autoscaling (Premium workspaces) goes from min to max in at most two steps and scales down only after 40 seconds underused on jobs compute, 150 seconds on all-purpose compute; the standard plan adds 8 machines first; a cluster can go below its minimum when the cloud takes machines back; autoscaling scales a Structured Streaming stream down poorly (Microsoft Learn, Compute configuration reference, https://learn.microsoft.com/azure/databricks/compute/configure, read on October 27, 2026). Jobs compute costs less than an all-purpose cluster for what runs with nobody at the screen (Microsoft Learn, Best practices for cost optimization, https://learn.microsoft.com/azure/databricks/lakehouse-architecture/cost-optimization/best-practices, read on October 27, 2026).
13.14.3 Size a streaming pipeline (streamSize)
-
Cores
⌈peak × (1 + headroom) ÷ rate of a core⌉; the rate of a core is measured in a test (rate held ÷ cores of the test workers) and assumed constant with more cores, a best case said as such. Workers⌈cores ÷ cores of a machine⌉; capacityμ = cluster cores × rate of a core; loadρ = rate ÷ μ. The cluster has a fixed size for the peak, without autoscaling (Microsoft Learn, Apache Kafka FAQ, https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/faq, read on October 27, 2026). -
Shuffle partitions: stateful, 1 to 2 times the cluster's cores, a number fixed by the checkpoint (Microsoft Learn, What is stateful streaming?, https://learn.microsoft.com/azure/databricks/structured-streaming/stateful-streaming, read on October 27, 2026); stateless, the default 200 (Microsoft Learn, Adaptive query execution, https://learn.microsoft.com/azure/databricks/optimizations/aqe, read on October 27, 2026). With Kafka, without
minPartitions, one Spark partition per topic partition (Microsoft Learn, Spark API options reference, https://learn.microsoft.com/azure/databricks/spark/api-options, read on October 27, 2026): fewer partitions than cores leaves cores waiting. -
Trigger, from the delay wanted
L: under 1 second, real-time mode; under 5 seconds, the default trigger (processingTime 0, a 3 to 5 second latency); elseprocessingTime = ⌊L ÷ (1 + ρ at peak)⌋seconds, a derived rule (an event waits at most one interval, then its batch lasts the interval × the load). Sources: Microsoft Learn, Configure Structured Streaming trigger intervals, https://learn.microsoft.com/azure/databricks/structured-streaming/triggers, read on October 27, 2026; on serverless, AvailableNow only (Microsoft Learn, Serverless compute limitations, https://learn.microsoft.com/azure/databricks/compute/serverless/limitations, read on October 27, 2026). -
Continuous
price of an hour × 730(at the tier chosen: on demand or reserved). AvailableNow batches every N minutes: a batch lastsmeasured start + N × mean ρminutes and is possible only when it lasts less thanN;365 ÷ 12 × 1,440 ÷ Nbatches a month at the on-demand price; worst freshnessN + duration of a batch. Batches are recommended only when they keep the delay wanted and cost less. Without a measured start, batches are not priced; without a mean rate, the peak stands for the mean (an upper bound, said). -
Catch-up after an outage of
Ominutes: backlogmean rate × O × 60events, caught up inbacklog ÷ (μ − mean rate)(never whenμdoes not exceed the mean rate). Volume:peak × KB ÷ 1,024MB/s;mean × KB × 86,400 ÷ 1,024²GB a day.
13.14.4 Files and partitions of a Delta table (deltaFiles)
-
Target file size (autotuning): 256 MB under 2.56 TB, then linear to 1 GB at 10 TB (
256 + (TB − 2.56) ÷ 7.44 × 768MB), 1 GB above (Microsoft Learn, Control data file size, https://learn.microsoft.com/azure/databricks/tables/tune-file-size, read on October 27, 2026). Units: 1 TB = 1,024 GB and 1 GB = 1,024 MB, as the page's row "1 TB, 256 MB, 4,096 files" implies; the page's example table can differ by a few MB between 2.56 and 10 TB (the page calls it "only an example"). Expected files⌈GB × 1,024 ÷ target⌉; today, average sizeGB × 1,024 ÷ numFiles, withsizeInBytesandnumFilesfrom DESCRIBE DETAIL (Microsoft Learn, Review table details with describe detail, https://learn.microsoft.com/azure/databricks/tables/operations/table-details, read on October 27, 2026). -
Size at the horizon
GB + growth a day × 365 ÷ 12 × months. Layout, on the larger of both sizes: under 1 TB, no partitions; from 1 to 100 TB, liquid clustering rather than partitions; from 100 TB, liquid clustering first; a partition holds at least 1 GB (Microsoft Learn, When to partition tables on Azure Databricks, https://learn.microsoft.com/azure/databricks/tables/partitions, read on October 27, 2026); fewer than 10,000 partitions, and daily maintenance for high-volume tables, weekly otherwise (Microsoft Learn, Architecture best practices for Azure Databricks, https://learn.microsoft.com/azure/well-architected/service-guides/azure-databricks, read on October 27, 2026). Liquid clustering is recommended for all new tables, four keys at most (Microsoft Learn, Use liquid clustering for tables, https://learn.microsoft.com/azure/databricks/tables/clustering, read on October 27, 2026). -
OPTIMIZE: start daily, then adjust (Microsoft Learn, Optimize data file layout, https://learn.microsoft.com/azure/databricks/tables/operations/optimize, read on October 27, 2026); above 1 TB, a scheduled OPTIMIZE on top of auto compaction (Control data file size). VACUUM: regularly, a 7-day retention by default and the recommended minimum (Microsoft Learn, Remove unused data files with vacuum, https://learn.microsoft.com/azure/databricks/tables/operations/vacuum, read on October 27, 2026); files kept for time travel
GB rewritten a day × retention, measurable with ANALYZE TABLE … COMPUTE STORAGE METRICS (Microsoft Learn, https://learn.microsoft.com/azure/databricks/sql/language-manual/sql-ref-syntax-aux-analyze-compute-storage-metrics, read on October 27, 2026). Their cost is computed only at a storage price entered (the snapshot holds none). On a managed table, predictive optimization runs OPTIMIZE, VACUUM and ANALYZE, billed as serverless jobs (Microsoft Learn, Predictive optimization for Unity Catalog managed tables, https://learn.microsoft.com/azure/databricks/optimizations/predictive-optimization, read on October 27, 2026).
13.14.5 Photon: the speed-up it needs (photonBreakEven)
- Hour without and with Photon, by the engine: Photon multiplies the machines' DBUs by the snapshot's rate for this product and machine (a Photon machine consumes DBUs at a different rate: Microsoft Learn, What is Photon?, https://learn.microsoft.com/azure/databricks/compute/photon, read on October 27, 2026); the machines cost the same. Without a Photon rate in the snapshot, nothing is computed.
-
Break-even speed-up
s* = hour with ÷ hour without; longest duration with Photon for the same costminutes ÷ s*. Month withouthour without × minutes ÷ 60 × runs; with a measured speed-ups, month withhour with × minutes ÷ s ÷ 60 × runs; the gap to the cent. No gain is assumed: without a measured speed-up, only the break-even is given. - Limits said: Photon supports neither UDFs, nor the RDD and Dataset APIs, nor stateful streaming, and does not improve queries under two seconds; it is already on for serverless and SQL warehouses (What is Photon?); it does not work on GPUs (Microsoft Learn, GPU-enabled compute, https://learn.microsoft.com/azure/databricks/compute/gpu, read on October 27, 2026).
13.14.6 Spot workers or on demand (spotRisk)
- Hours: on demand, and with spot workers and the driver on demand (the driver is always on demand; an evicted spot machine is replaced on spot, or on demand failing that: Microsoft Learn, Compute configuration reference). The DBU does not change, only the machine part goes down.
-
Extra work expected
x = share of runs hit × share redone: two inputs measured on the user's runs, never assumed, because a spot machine has no guarantee and can be taken back at any time (Azure: 30 seconds of notice, Microsoft Learn, Azure Spot Virtual Machines, https://learn.microsoft.com/azure/virtual-machines/spot-vms; AWS: two minutes, Spot Instance interruption notices, https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-instance-termination-notices.html; Google Cloud: at any time, 0 or 120 seconds, Spot VMs, https://cloud.google.com/compute/docs/instances/spot; read on October 27, 2026). -
Expected spot run
spot hour × minutes ÷ 60 × (1 + x); on demandhour × minutes ÷ 60; month = run × runs, each to the cent; saving = the difference. Spot stays cheaper whilex < on-demand hour ÷ spot hour − 1. Mean lengtheningminutes × x. The redone work is counted at the spot price (said: on on-demand replacement machines, it costs more). Spot suits workloads with lax latency requirements (Microsoft Learn, Classic compute configuration best practices, https://learn.microsoft.com/azure/databricks/compute/cluster-config-best-practices, read on October 27, 2026).
13.14.7 What a dashboard costs (dashboardRefresh)
-
Warehouse seconds a day: refreshes
scheduled × queries per refresh × mean duration(each scheduled update runs every dataset: Microsoft Learn, Manage scheduled dashboard updates and subscriptions, https://learn.microsoft.com/azure/databricks/dashboards/share/schedule-subscribe, read on October 27, 2026); viewsviewers × openings × queries per opening × mean duration × (1 − share served by the cache)(a dashboard keeps its results 24 hours, a cached result does not start the warehouse, and a dataset of at most 100,000 rows and 100 MB is filtered in the browser, with no query: Microsoft Learn, Dataset optimization and caching, https://learn.microsoft.com/azure/databricks/dashboards/caching, read on October 27, 2026). All those durations and the cache share are measured insystem.query.history(query_source.dashboard_id,total_duration_ms,from_result_cache: Microsoft Learn, Query history system table reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/query-history, read on October 27, 2026). -
Hours a month: refreshes
seconds × refresh days ÷ 3,600(an average month by default); viewsseconds × viewing days ÷ 3,600(22 by default, a convention); wake-upsstarts for this dashboard alone × auto stop ÷ 60 × days: an idle warehouse stays billed until its auto stop, 10 minutes by default on serverless, 45 on pro and classic (Microsoft Learn, Create a SQL warehouse, https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create, read on October 27, 2026). -
Cost: each part
hours × price of an hour of a cluster(the warehouse size: DBUs × DBU price, and machines for pro and classic) rounded to the cent; total = the sum of the three parts. Per refreshqueries × duration ÷ 3,600 × hour; per viewertotal ÷ viewers. Refreshes without new datamax(0, refreshes − data updates a day) × days × cost of a refresh. - Convention said: a second of a query counts as a second of one cluster, as if the dashboard's queries ran one after another. On a shared warehouse, the measured allocation of section 5.4 (hour by hour, by task time) can give less; the screen invites comparing both. The warehouse's size at busy hours is the job of the tool of section 13.10 (one cluster for every 10 concurrent queries).
13.14.8 What a training run costs (trainingRun)
-
Hour of the training compute (driver and workers, GPU or CPU, from the snapshot; jobs or all-purpose compute; workers on demand or spot, the driver on demand). A run
hour × hours a run; month: DBU partDBUs an hour × hours × runsand machine part, each to the cent, total = their sum; machine hours(1 + workers) × hours × runs. Campaign duration⌈runs ÷ runs at once⌉ × hours a run(the cost does not change). - Rules: GPU compute needs the Machine Learning runtime, Photon does not work on it, a single node is possible (Microsoft Learn, GPU-enabled compute); a scheduled training run costs less on jobs compute (Best practices for cost optimization). When the model will be served, the screen points to the "Concurrency and endpoint size" tool (section 13.10).
Sources (read on October 27, 2026), besides those cited above: the Calculator's snapshot (section 13.2) for every price, the DBUs an hour, the cores of the machines and the Photon multipliers.
13.14.9 Size a data ingestion (ingestion, 0.32)
Since 0.32, a data engineering calculation, of the size kind, for the data developer, the data architect and FinOps: how many cores, workers, hours and DBUs to load one's data, and what it costs a month. It follows the rules of this section (prices from the Calculator's engine only, each step with its page or "derived", a missing measured figure asked for and never guessed, inputs read as hostile data); its official pages were read on October 30, 2026, and Monitor managed ingestion pipeline cost read again on October 31, 2026 for the billing of managed connectors. The code is in extension/lib/calc-ingest32.mjs, its words in extension/lib/i18n-ingest32.mjs, its course in extension/lib/learn32-h.mjs.
-
Way to ingest and compute. Four ways: Auto Loader (files in cloud storage), COPY INTO (files, in batches), a Lakeflow Connect managed connector (a SaaS application, or a database with its gateway), a Kafka or Event Hubs stream. Four kinds of compute: a classic jobs cluster, serverless jobs, a classic declarative pipeline (Core, Pro or Advanced edition), a serverless declarative pipeline. A managed connector always runs in a serverless pipeline: the compute chosen does not apply, and the screen says so (Managed connector FAQs, Lakeflow Connect connector concepts). Three paces:
nloads a day, a load everyNminutes (n = 1,440 ÷ N), or continuous. The rules of each way are said under the answer, with their page: scheduled Auto Loader withTrigger.AvailableNow, file events rather than directory listing, COPY INTO that replays without duplicates and is not used in a declarative pipeline, Event Hubs read by the Kafka connector. -
Volume. A month
G × 365 ÷ 12GB,Gbeing the volume a day; loads a monthn × 365 ÷ 12; volume of a loadG ÷ n, a rule that assumes data arriving evenly through the day (said: a peak hour needs more). -
Files (Auto Loader and COPY INTO). Average size
G × 1,024 ÷ FMB forFfiles a day; files per loadF ÷ n. Under 4 MB, what Spark counts to open a file (spark.sql.files.openCostInBytes), small files are flagged; Spark packs up to 128 MB into a partition (spark.sql.files.maxPartitionBytes) (Performance Tuning, Apache Spark). Auto Loader processes at most 1,000 files per micro-batch by default (cloudFiles.maxFilesPerTrigger): beyond that, micro-batches of a load⌈files per load ÷ 1,000⌉(Configure Auto Loader for production workloads, Spark API options reference). COPY INTO suits files "in the order of thousands", Auto Loader "millions or more" (Ingest data from cloud object storage): YALineo reads that border as a million files a year, a convention said as such, and advises Auto Loader whenF × 365reaches it. The target table has its own files: the screen points to thedeltaFilescalculation (section 13.14.4). -
Stream (Kafka, Event Hubs). Peak rate
events per second × KB ÷ 1,024MB/s; mean rateG × 1,024 ÷ 86,400MB/s; a peak entered below the mean is flagged. On Event Hubs standard tier, a throughput unit serves at most 2 MB/s of egress: at leastmax(1, ⌈peak ÷ 2⌉)units (Azure Event Hubs Scalability Guide). For the delay wanted, the trigger, the partitions and the catch-up after an outage, the screen points to thestreamSizecalculation (section 13.14.3). -
Classic compute: cores and workers. The throughput of a core
d(MB read and written per second per worker core) is measured in a trial; the headroomris a choice (20% to start). Scheduled: processing secondsA = (time allowed − start) × 60; ifAis not above 0, no cluster fits, and the screen says so; rate neededvolume of a load × 1,024 ÷ AMB/s; cores= max(1, ⌈rate needed × (1 + r) ÷ d⌉). Continuous: cores= max(1, ⌈rate × (1 + r) ÷ d⌉), the rate being the peak for a stream and the mean for files. Workers= max(1, ⌈cores ÷ cores of a machine⌉), the machine's cores coming from the Calculator's snapshot; above 1,000 workers (the bound of an estimate line), nothing is priced. Work of the monthG × 365 ÷ 12 × 1,024 ÷ d ÷ 3,600core-hours, for information. Without a machine chosen, the tool gives the cores only. The rule assumes the throughput of a core stays the same with more cores, a best case said as such; for a strict window taken from a complete trial, the screen points to thejobWindowcalculation (section 13.10). -
Hours, DBUs and cost. Scheduled: duration of a load
start + volume of a load × 1,024 ÷ (workers × cores of a machine × d) ÷ 60minutes; hours a monthloads a month × duration ÷ 60. Continuous: 730 hours a month. The workload is a job (or a pipeline, at its edition) of these workers on this machine, without Photon; on spot, the workers on spot and the driver on demand; reserved, the machines at the reserved hourly price, as capacity already bought (section 13.3). The Calculator's engine (estimate) prices it: DBUs a month= DBUs an hour (driver and workers) × hours; at list price, a DBU partDBUs × DBU priceand a machine part, each rounded to the cent, total = their sum; after discounts,DBU part × (1 − DBU discount) + machine part × (1 − machine discount), each part to the cent. A start not entered (0) is neither in the duration nor in the cost, and the screen says so; loads that overlap, a time allowed longer than the interval and a start that takes at least half of a load are flagged. -
Serverless: DBUs per GB. No machine is sized: Databricks chooses the machines and bills DBUs. DBUs a month
= G × 365 ÷ 12 × DBUs per GB; the DBUs per GB are a measure (the DBUs of past runs insystem.billing.usage, divided by the GB loaded): without it, nothing is computed and the field is asked for (dbuPerGb). The workload is a serverless job or a serverless pipeline ofvolume of a load × DBUs per GBDBUs a run (continuous: one run a day ofG × DBUs per GB),nruns a day, 365 ÷ 12 days a month; costDBUs × DBU price of the product(serverless jobs or serverless pipelines, from the snapshot), after the discount× (1 − DBU discount), each to the cent. The rules also say that the standard mode of serverless consumes fewer DBUs for the same SKU but starts within 4 to 6 minutes (Run your Lakeflow Jobs with serverless compute for workflows, Configure a serverless pipeline), that a serverless pipeline requires the Advanced edition, and that serverless jobs accept onlyTrigger.AvailableNow(Serverless compute limitations). -
Lakeflow Connect managed connector: the Calculator's service line. The usage of a managed connector is billed under its own product:
billing_origin_product = 'LAKEFLOW_CONNECT',usage_typeCOMPUTE_TIME, unit DBU, with maintenance charges between updates like a Lakeflow pipeline (Monitor managed ingestion pipeline cost, read again on October 31, 2026). The managed connector FAQ speaks of serverless Lakeflow pipelines DBUs (Managed connector FAQs); YALineo follows the usage and prices the connector exactly as the Calculator'slakeflow-connectservice line (sections 13.11 and 13.12), through the engine of any line (estimateLine, which sends a service line toestimateService): DBUs a day= G × DBUs per GB(the same measure, asked for the same way), one workspace, 365 ÷ 12 days; the rule of the service line takes off the free part once, billable DBUs a day= max(0, DBUs a day − 100)(100 free DBUs a day per workspace for managed connectors, Architecture Best Practices for Azure Databricks and the services snapshot), billable DBUs a month= billable DBUs a day × 1 × 365 ÷ 12; at list priceround(billable DBUs × Lakeflow Connect DBU price), after the discountround(billable DBUs × price × (1 − DBU discount)). The price comes from the services snapshot, or from your account's prices once read, with its origin. The free part is shared among the connectors of a workspace: taking it off for this connector alone assumes it is the only one using it, and the screen says so. DBUs per GB measured over all theLAKEFLOW_CONNECTusage include the maintenance charges. Above 10,000,000 DBUs a day (the bound of a Lakeflow Connect line), nothing is priced. Without the services snapshot, the connector is not priced, never counted as zero. -
Gateway of a database connector. It runs continuously on classic compute, paid even when the ingestion pipeline does not run (Managed database connectors): a classic pipeline of the edition chosen, a driver on the machine chosen and as many workers of the same machine as the field gives (1 by default, the value of the documented compute policy; Databricks advises the smallest workers possible, so the driver's machine is an upper bound), 730 hours a month, priced as above. A driver of fewer than 8 cores is flagged (Ingest data from SQL Server). The edition billed for the gateway is not given by the pages read: it is counted at the edition chosen, and the screen asks to check it (
product_features.dlt_tierandsku_nameinsystem.billing.usage). Total a month= ingestion pipeline + gateway, at list price and after discounts, each the sum of its parts to the cent. Without a machine, the gateway is not priced, and nothing is added to the estimate. -
Backfill of history, a one-time spend.
HGB to load withinDdays, the compute running day and night. Classic: cores= max(1, ⌈H × 1,024 × (1 + r) ÷ (d × D × 86,400)⌉), workers= max(1, ⌈cores ÷ cores of a machine⌉), hours= start ÷ 60 + H × 1,024 ÷ (workers × cores of a machine × d) ÷ 3,600; cost at list priceround(DBUs an hour × DBU price × hours) + round(machines an hour × hours), after discounts each part multiplied by (1 − its discount), to the cent. Serverless: DBUs= H × DBUs per GB, costround(DBUs × DBU price), after the discountround(DBUs × DBU price × (1 − DBU discount)); for a connector, at the Lakeflow Connect DBU price, without a free part, already taken off once in the month. The backfill stays out of the month and of the lines added to the estimate. With Auto Loader,cloudFiles.includeExistingFilesistrueby default: the first start also takes the files already there (Spark API options reference). -
Assumptions to replace with a measure. Five starting values are neither published nor measured, and their field says so ("starting assumption, to replace with your measure"): 100 GB a day, 1,000 files a day, 2,000 events per second at peak, 1 KB per event, 10 MB/s per core. While the volume or the throughput per core keep their starting value, a rule recalls it under the answer. The cluster start and the DBUs per GB are measures (0 and empty to start); the tool's course gives read-only queries that read them in
system.lakeflow.job_run_timelineandsystem.billing.usage. The gateway's workers take the Databricks default, with its page. - The estimate line. "Add to the estimate" (section 13.15) adds the workload as the estimate prices it: the classic job or pipeline with its workers, its machine, its way to pay, its loads a day and the duration of a load, or 730 hours; the serverless job or pipeline with its DBUs a run (origin "measured"); for a managed connector, the Lakeflow Connect service line itself (its DBUs a day, 1 workspace, 365 ÷ 12 days), and for a database connector the gateway as well, a classic pipeline of 730 hours. The estimate gives the same month, to the cent: the free part is taken off there by the same rule, once. No line without a machine, when the time allowed is not enough, beyond the bounds, without prices, or when the gateway is not priced; the backfill is never added.
-
Example (fictional: a retailer). 900 GB a day in 36,000 files, 4 loads a day of 45 minutes at most, 6 MB/s per core measured, a 6-minute start, 20% headroom, a machine of 8 cores (
Standard_D8ds_v5on Azure). A load carries 225 GB; a file is 25.6 MB on average; 9 micro-batches a load; 2,340 seconds of processing; 98.46 MB/s needed; 20 cores, so 3 workers (24 cores); a load lasts6 + 225 × 1,024 ÷ (24 × 6) ÷ 60 = 32.67minutes. Loading 2 TB (2,048 GB) of history within 2 days takes 3 cores, 1 worker and 12.24 hours, once. The prices are those of the estimate's snapshot: at the bundled snapshot (October 15, 2026, Azure East US, Premium, list prices: $0.30 a jobs DBU, $0.452 an hour ofStandard_D8ds_v5), an hour costs4 × (2 × 0.30 + 0.452) = $4.208; 66.24 hours and 529.93 DBUs a month, $278.74 a month at list price; the backfill $25.74, once. The same volume through a SaaS connector (fictional, 0.2 DBU per GB measured): 180 DBUs a day, 80 billable after the 100 free ones, 2,433.33 billable DBUs a month; at the bundled services snapshot (October 26, 2026, Azure East US, Premium, list price $0.45 a Lakeflow Connect DBU),2,433.33 × 0.45 = $1,095.00a month, to the cent the month of the Lakeflow Connect service line for 180 DBUs a day, 1 workspace and 365 ÷ 12 days. For a database, the gateway (a driver and 1Standard_D8ds_v5worker, Core edition, 730 hours, 2,920 DBUs) adds876.00 + 659.92 = $1,535.92, so $2,630.92 a month. These amounts are the engine's on the snapshots bundled with this version, without discount; on GCP, without machine prices, the size is given without a cost.tests/v0320-ingest32.test.mjsrecomputes each figure by hand on a snapshot of round prices, and compares each connector with the service line built apart. -
Sources (read on October 30, 2026), with the Calculator's snapshot (section 13.2) for the prices, the DBUs an hour and the machines' cores:
- Microsoft Learn, What is Auto Loader?: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/
- Microsoft Learn, Ingest data from cloud object storage: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/
- Microsoft Learn, Compare Auto Loader file detection modes: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/file-detection-modes
- Microsoft Learn, Configure Auto Loader for production workloads: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/production
- Microsoft Learn, Auto Loader best practices: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/best-practices
- Microsoft Learn, Configure schema inference and evolution in Auto Loader: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/schema
- Microsoft Learn, Spark API options reference: https://learn.microsoft.com/azure/databricks/spark/api-options
- Microsoft Learn, Get started using COPY INTO to load data: https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/copy-into/
- Microsoft Learn, Lakeflow Connect connector concepts: https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/
- Microsoft Learn, Managed database connectors: https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/cdc-overview
- Microsoft Learn, Managed connector FAQs: https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/faq
-
Microsoft Learn, Monitor managed ingestion pipeline cost (read again on October 31, 2026:
billing_origin_product = 'LAKEFLOW_CONNECT',usage_typeCOMPUTE_TIME, unit DBU, maintenance charges like a Lakeflow pipeline): https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/monitor-costs - Microsoft Learn, Ingest data from SQL Server: https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/sql-server-pipeline
- Microsoft Learn, Connect to Apache Kafka: https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/
- Microsoft Learn, Authentication (Kafka connector, Azure Event Hubs): https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/authentication
- Microsoft Learn, Azure Event Hubs Scalability Guide: https://learn.microsoft.com/azure/event-hubs/event-hubs-scalability
- Microsoft Learn, Configure Structured Streaming trigger intervals: https://learn.microsoft.com/azure/databricks/structured-streaming/triggers
- Microsoft Learn, Run your Lakeflow Jobs with serverless compute for workflows: https://learn.microsoft.com/azure/databricks/jobs/run-serverless-jobs
- Microsoft Learn, Serverless compute limitations: https://learn.microsoft.com/azure/databricks/compute/serverless/limitations
- Microsoft Learn, Configure a serverless pipeline: https://learn.microsoft.com/azure/databricks/ldp/serverless
- Microsoft Learn, Triggered vs. continuous pipeline mode: https://learn.microsoft.com/azure/databricks/ldp/concepts/pipeline-mode
- Microsoft Learn, Configure pipelines (Choose a product edition): https://learn.microsoft.com/azure/databricks/ldp/configure-pipeline
- Microsoft Learn, Billable usage system table reference: https://learn.microsoft.com/azure/databricks/admin/system-tables/billing
- Microsoft Learn, Jobs system table reference: https://learn.microsoft.com/azure/databricks/admin/system-tables/jobs
- Microsoft Learn, Control data file size: https://learn.microsoft.com/azure/databricks/tables/tune-file-size
-
Apache Spark, Performance Tuning (Spark 4.3.0 documentation):
https://spark.apache.org/docs/latest/sql-performance-tuning.html - Microsoft Learn, Architecture Best Practices for Azure Databricks (Well-Architected Framework): https://learn.microsoft.com/azure/well-architected/service-guides/azure-databricks
13.15 Size and tune: the calculations by capability and by role (0.27)
The "Size and tune" page (Simulations side, between "Cost a project" and "Open estimate") gathers the size, setting, cost and buying calculations. It adds no calculation rule: each tool keeps its own (section 13.10 for the five tools of a project's blocks, section 13.14 for the settings) and the page shows them all the same way. The code is in extension/lib/calc-capabilities.mjs (the list of calculations) and extension/lib/calc-sizing-ui.mjs (the pages).
Organization. Five capabilities: data engineering (ingestion, transformations), data science (notebooks, training, served models), analytics (analysts' and dashboards' queries on a SQL warehouse, at the busiest time), dashboards (what a dashboard costs, refreshes and views included), architecture (storage, retention and buying choices that hold for the whole platform). Each calculation belongs to one capability and has a kind: cost, size, setting (timeout, auto termination, autoscaling...) or buying (on demand, spot, reserved...). Each one says the question it answers, its fields with their unit and bounds, a concrete example (fictional, said so) and its answer in one sentence. The Calculator's ten complete cases stay in "My estimates"; the page leads there ("Cost a complete case").
Who uses which calculation, and why. Each calculation names the roles that use it (its profiles list, among business, data steward or owner, data developer, data architect, FinOps lead, data scientist, BI analyst); the "Who uses what" table is read from these lists, and so is the profile of use (0.28): a profile includes the calculations that name it, "Full" includes them all, a new calculation joins by itself. Business does not estimate: a data steward or owner estimates for the analysts (the size of a SQL warehouse, the cost of a dashboard), and an estimate made for business reaches it as the estimate's Excel workbook. The fourteen calculations (the five sizing tools of section 13.10, the eight of sections 13.14.1 to 13.14.8 and, since 0.32, the ingestion of section 13.14.9):
| Calculation | Capability | Kind | Roles | Why |
|---|---|---|---|---|
Workers to fit a window (jobWindow) | Data engineering | Size | Data developer, data architect, FinOps | The developer sizes the job; the architect picks the machine and the window; FinOps reads the cost per run and per month. |
Cluster auto termination (clusterIdle) | Data science | Setting | Data developer, FinOps, data scientist | The notebooks' shared cluster is the data scientist's daily tool; the developer sets it; FinOps counts the idle time avoided. |
Concurrency and endpoint size (serving) | Data science | Size | Data architect, FinOps, data scientist | The data scientist serves the model; the architect picks CPU or GPU; FinOps wants the cost of a use before it is asked for. |
Clusters and size at peak (warehouse) | Analytics | Size | Data steward or owner, data architect, FinOps, BI analyst | The BI analyst keeps queries and dashboards fast at peak; the data steward or owner estimates for the analysts of the domain; the architect and FinOps pick the type and number of clusters. |
Growth, retention and storage (storage) | Architecture | Size | Data developer, data architect, FinOps, data steward or owner | The data steward or owner sets how many days of history to keep; the architect and the developer plan the size; FinOps the cost. |
Timeout and retries of a job (jobTimeout) | Data engineering | Setting | Data developer, data architect, FinOps | The developer sets the job's timeout and retries; the architect the common rule; FinOps prices a stuck run and a timeout too short. |
Minimum and maximum autoscaling workers (autoscale) | Data engineering | Setting | Data developer, data architect, FinOps | The developer picks the minimum and maximum; the architect the policy; FinOps the gap with a fixed size. |
Size a streaming pipeline (streamSize) | Data engineering | Size | Data developer, data architect, FinOps | The developer sizes the stream; the architect picks continuous or batches; FinOps compares both costs. |
Files and partitions of a Delta table (deltaFiles) | Data engineering | Setting | Data developer, data architect, data steward or owner, FinOps | The developer and the architect pick the file layout; the data steward or owner decides VACUUM's retention; FinOps sees the storage kept. |
Photon: the speed-up it needs (photonBreakEven) | Architecture | Buying | Data architect, FinOps, data developer | The architect and the developer decide to turn Photon on; FinOps checks the speed-up pays for it. |
Spot workers or on demand (spotRisk) | Architecture | Buying | Data architect, FinOps, data developer | The architect and the developer choose how to buy machines; FinOps weighs the saving against the work redone. |
What a dashboard costs (dashboardRefresh) | Dashboards | Cost | BI analyst, FinOps, data steward or owner | The BI analyst sets refreshes and cache; FinOps charges it back; the data steward or owner decides the freshness needed and prices the dashboard business asks for. |
What a training run costs (trainingRun) | Data science | Cost | Data scientist, FinOps, data architect | The data scientist prices the campaign; FinOps its budget; the architect the GPU or CPU choice. |
Size a data ingestion (ingestion) | Data engineering | Size | Data developer, data architect, FinOps | The developer sizes the load; the architect picks the way to ingest and the compute; FinOps reads the cost of the month and of the backfill. |
The profile of use is chosen in the settings, at the step "Your profile" (0.28, which replaces "My role"): a display preference (access), read back as data, one of the eight profiles, else "Full". A calculation the profile does not include keeps its place on the page with a padlock and opens on a page that says so; it is a convenience to focus on one's role, not an access control.
A calculation's page. The fields, each with its unit, bounds and the origin of its value (typed, measured by you, your choice); a required field left empty is "to enter", never guessed, and the answer waits for it. "Fill with this example" puts in the example's figures (on AWS and GCP, machines of the same size: 4 vCPUs and 16 GB, 8 vCPUs and 64 GB). A list of values (a job's run durations) is typed separated by commas or spaces, 200 values at most, each a number above 0 within its bound; the rest is left out. A Databricks default cites its page. When the Calculator has no price for the machine or product (GCP machines, a region not chosen), the price is said "to enter", with a link to "Prices and discounts"; nothing is assumed. A rule that sends to another calculation (sizing a SQL warehouse, an endpoint) opens it in one click. Then the answer in one sentence and the calculation step by step: each step with its formula and your figures, its result and its numbered source (an official page, a published law, the bundled snapshot) or "derived". "Prices used and their origin" gives the Calculator's base (cloud, region, plan, snapshot date, DBU and machine discounts, account prices read or not) and each price used with its origin (public price of the snapshot, entered, the account's price, measured), for all fourteen calculations; with no price used, the card says so. "Copy the calculation" copies it all as text. For a model endpoint, the price of a DBU is the one entered, else the services snapshot's (Serverless Real-Time Inference: the account's price once read, else the public price of the region and plan); cost per month = DBUs a day × 365 ÷ 12 × DBU price × (1 − DBU discount). Without a price, the month is not priced and a rule says so.
From a result to an estimate line. "Add to the estimate" first shows what will be added, each line priced as the estimate will price it (its region, plan and discounts, each amount to the cent), then adds it to the open estimate of the same cloud, else to a new estimate "Sizings" (60 workloads and 30 estimates at most); each line goes through cleanLine. The estimate rounds each part of a line (DBUs, machines) to the cent: its amount may differ from the tool's by one cent per part at most, and the recap shows the estimate's amount.
- Workers to fit a window: a classic job of these workers on this machine, the same way to pay (a reservation counted by the hour, as in the tool), the runs a day and the minutes of a run rounded to the tenth, 365 ÷ 12 days a month.
- Clusters at peak: two SQL warehouse workloads, as the dashboards block (section 13.9): the off-peak hours at the minimum of clusters, the peak hours at the number found; their sum is the tool's month.
- Auto termination: an all-purpose cluster on for the hours a day of the delay proposed (active hours and idle time).
- Endpoint size: a Model Serving service workload (section 13.12) at the processor's rate (per concurrent request on CPU, per replica on GPU), as many units as at peak, and the hours a month that give the same units × hours as the tool's day (DBUs a day × 365 ÷ 12); a price entered in the tool goes with it. Only where the services snapshot publishes that rate on that cloud (CPU per concurrent request: Azure); elsewhere, the reason is said.
- Storage: no line, storage is billed by the cloud; "Apply to a project" carries it into the storage block.
- Size a data ingestion (section 13.14.9): the answer's workload, a classic job or pipeline of these workers on this machine (loads a day and the duration of a load, or 730 hours when continuous), or a serverless job or pipeline of these DBUs a run; for a database connector, its gateway as well, a classic pipeline of 730 hours. The backfill of history is never added.
-
The eight calculations of sections 13.14.1 to 13.14.8 add no line, and the page says why under the answer (
NO_LINEincalc-tune.mjs): the timeout and retries, autoscaling and Delta files are settings (of a job, a cluster, a table), not a new workload; Photon and spot compare two ways to pay for the same workload, set in the estimate's workload; a dashboard takes a share of a SQL warehouse, priced and added by "Clusters and size at peak"; a streaming pipeline and a training run are workloads the estimate can price, with no button for now: the page asks to enter them in the estimate with the machine, workers and hours of the answer.
"Apply to a project" opens the block's tool (ingestion or transformations for a job) in the current project, with these values; "Apply to the project" there shows the recap of section 13.10 before any change.
Data read back as hostile. The address holds the open calculation (sim) and its values (si, key:value pairs separated by commas); the back and forward arrows bring them back. An unknown calculation leads back to the overview; a value is read only for a field of the calculation: a number within its bounds, a value of its list, a machine name of the documented form, else the starting value; no prototype key is read. A calculation of another shape (unknown capability, kind or role, a field without bounds) is left out of the pages, never shown by half.
13.16 AI: Genie and agents (0.32)
Since 0.32, the "AI: Genie and agents" page of the Simulations side walks through building a Genie Agent (called a Genie space before July 2026, section 4.3) or an AI agent, step by step with a checklist (8 steps for a Genie Agent, 10 for an agent, each with the official page it follows and the parts of the cost it shapes), says what a DBU is, and prices the month of the usage entered, part by part, in DBUs and in dollars, at list price then after the contract discounts. These are derived figures (section 1), never measures. The engine is extension/lib/calc-ai32.mjs (pure: no page, no network, no storage), the page extension/lib/calc-ai32-ui.mjs, its words extension/lib/i18n-ai32.mjs. Each formula of this section is the one the page shows with your figures in "The calculation step by step", each step with its official page (read on October 30, 2026; on October 31, 2026 for the cache writes and the GB of Unity AI Gateway, since 0.33), the Calculator's snapshot, or "derived".
Common rules.
-
A DBU is the normalized unit of processing power in which Databricks measures and bills consumption (Databricks technical terminology glossary). Cost
= DBUs × price of a DBU of the product × (1 − DBU discount); on classic compute (a pro warehouse), the cloud machines are added,hours × machine price × (1 − machine discount); on serverless, the price of a DBU already includes the machines (Best practices for cost optimization). -
No price is written in the engine. A Genie Agent's warehouse is priced by the Calculator's engine on the cloud's dated snapshot (section 13.2) or the prices entered; Genie's language model and each part of an agent, by the Calculator's services (sections 13.11 and 13.12): a price entered, else the account's price (
system.billing.list_prices, read on demand), else the public price of the services snapshot. The page chooses its cloud, region, plan and two discounts (at first, the Calculator's); each line keeps the origin of its prices. - What is missing is asked for. A value Databricks does not publish (the DBUs of a Genie question), a region, a price the snapshot does not hold, a model the snapshot does not have on this cloud: the part is not priced, never counted as 0; it is listed "To complete" with the value to enter, and the total is said partial.
-
Each field says the origin of its value: assumption to replace, YALineo convention, Databricks default (with its page), your choice, or to measure. Inputs are read as hostile data: only own value properties are read (never
__proto__,constructororprototype); a number must be a finite number, it is brought within its bounds, and a string,NaNor an object takes the starting value without ever being converted; an integer is rounded, a choice belongs to its list, a model has the form of an id of the services snapshot. The calculation never throws.
13.16.1 A Genie Agent: the SQL statements and the warehouse
The SQL statements Genie runs go to a pro or serverless SQL warehouse and are billed by it, apart from the language model (Create and manage a Genie Agent, Genie consumption guide). The starting values:
| Field | Start | Origin |
|---|---|---|
| Users; questions per user per day | 20; 5 | assumptions to replace |
| Days of use per month | 22 | YALineo convention (that of the blocks of section 13.9) |
| SQL statements per question; mean duration of a statement; peak factor | 1; 8 s; 1 | assumptions to replace (the duration is measured in system.query.history) |
| Warehouse type and size | Serverless (or Pro); X-Small | your choice |
| Minimum clusters | 1 | Databricks default (Create a SQL warehouse) |
| Open hours a day; peak hours; restarts a day | 8 h; 1 h; 1 | assumptions to replace |
| Auto stop | empty: 10 minutes on serverless, 45 on pro | Databricks default (Create a SQL warehouse) |
| Machines of a pro cluster, per hour | empty | to measure, only when the snapshot does not publish them (GCP) |
| Billing of the language model | users, after the promotion | your choice (Monitor and understand your Genie cost) |
| Model DBUs per question | empty | to measure |
Step by step, with U users, q questions a day, j days, s SQL statements per question, W the mean duration of a statement in seconds, f the peak factor, h the open hours (24 at most), p the peak hours, m the minimum clusters, a the auto stop in minutes and r the restarts a day:
-
Questions a month
Q = U × q × j; SQL statements a dayS = U × q × s. -
Concurrent queries at the busiest hour, by Little's law:
λ = S ÷ (h × 3,600) × fstatements per second,L = λ × W(the mean, not the median). The duration is measured insystem.query.history, columntotal_duration_ms, on the rows whosequery_source.genie_space_idis the agent's (Query history system table reference). -
Clusters at peak
M = min(30, max(m, ⌈L ÷ 10⌉)): one cluster for every 10 concurrent queries (Create a SQL warehouse). -
Share of time the warehouse computes
S × W ÷ 3,600 ÷ h(100% at most); under 10%, a rule suggests a smaller size, a shorter auto stop or a shared warehouse. -
Cluster hours a day, the rule of the dashboards block (section 13.9): stop tail
t = a ÷ 60 × rhours, peak hoursp' = min(p, h), off peakH = max(0, min(24 − p', h − p' + t)); cluster hoursH × m + p' × M. Peak hours beyond the open hours are brought back to them, and an auto stop under the interface minimum (5 minutes on serverless, 10 on pro) is flagged. -
Warehouse DBUs a month
= DBUs an hour of a cluster of the size (snapshot) × cluster hours a day × j. The engine prices two SQL warehouse workloads (section 13.3):Hhours a day atmclusters andp'hours atMclusters, overjdays; each is rounded to the cent, and the "SQL warehouse" line is the sum of their DBU costs:DBUs × price of a DBU of the product (SQL serverless or SQL Pro) × (1 − DBU discount). -
Machines of a pro warehouse, a line of their own: the price of its clusters' machines (driver and workers of the size, section 13.2), or the cost entered per hour and per cluster,
× (1 − machine discount). Disks and network stay out of the calculation (section 13.6).
Two assumptions are said: the warehouse serves Genie alone (shared with dashboards, it would cost less for Genie: a project's Genie block then counts only the difference, section 13.9); it stays on during the open hours entered, plus the auto stop after each restart. Without open hours, nothing is priced and they are asked for.
13.16.2 Genie's language model
The "Genie language model" line follows Monitor and understand your Genie cost (section 4.3):
-
Model DBUs
= Q × d,dbeing the DBUs per question. Databricks does not publish them: they are measured on a trial, the DBUs of theGENIEproduct (usage_metadata.genie.surface = GENIE_AGENTS,GENIE_FREE_USAGESKU included) insystem.billing.usage, divided by the number of questions of the period. Withoutd, the line is not priced anddis asked for. -
Three ways to be billed, to choose:
-
users, until January 31, 2027: the use of Genie One and Genie Agents is free for users (
GENIE_FREE_USAGESKU, no list price). The line costs 0; its DBUs, whendis entered, are counted and said free, and nothing is asked for whiledis missing. An assumption says it: afterwards, the allowance applies; -
users, after the promotion: each user has 150 free DBUs a month. Billed DBUs
= U × max(0, q × j × d − 150), free= Q × d − billed. The threshold150 ÷ (q × j)says from how many DBUs per question usage is billed. Two assumptions are said: questions are spread evenly among users (real usage is uneven, and the real billed share is at least this one); each user's 150 DBUs all go to this Genie Agent (Genie Code or other Genie Agents would use them up); -
service principal: everything is billed, billed DBUs
= Q × d.
-
users, until January 31, 2027: the use of Genie One and Genie Agents is free for users (
-
Cost, at the price of a DBU of the Serverless Real-Time Inference SKU, on which Databricks bills Genie usage (the price of a Model Serving DBU in the services snapshot: entered, else the account's, else public): at list price
round(billed × price), after discountsround(billed × price × (1 − DBU discount)). DBUs all within the free allowance cost 0: the line is priced, never "not priced". - The 25% promotional discount on billed usage, until January 31, 2027, is already in the measured DBUs: an assumption says so, DBUs per question measured before that date will be higher afterwards.
Here, the SQL part and the model describe the same Genie Agent and add up in the page's total. On the FinOps side (section 4.3), the Genie Agents line covers the model of all agents together: it is never added to an agent's SQL part.
13.16.3 An AI agent: its parts
Each part is a service workload of the Calculator (section 13.12), priced by its engine (estimateService) at the rate and price of the services snapshot; the rate key of a model and its mode comes from the token comparator (section 13.13). The starting values:
| Group | Fields and start | Origin |
|---|---|---|
| Usage | 100 users, 5 requests per user per day; 22 days | assumptions to replace; YALineo convention |
| Model | 3 calls per request; per call, 2,000 input tokens, 300 output, 0 read from cache | assumptions to replace, to read on the MLflow traces of a prototype |
| Model | llama-3-3-70b of the Foundation Model APIs, per token; on provisioned throughput, without commitment, 50 model units, 730 hours | your choice; 730 hours, YALineo convention |
| Proprietary model (0.33) | 0 tokens written to the cache per call; standard write | to measure (system.ai_gateway.usage); your choice |
| Search in documents | on; 0.5 million chunks of 500 tokens; 1,024 dimensions; Standard endpoint, 730 hours; 0 GB of storage; 1 search per request; no reranking; gte embeddings; 10% embedded again a month; 50 tokens per question | assumptions to replace; dimensions and endpoint, your choice; 730 hours, convention; storage, to measure |
| Server | Agent Runtime on Databricks Apps, Medium size, 1 instance (Model Serving: 1 CPU node), 730 hours | your choice; Medium, Databricks default (Configure compute resources for a Databricks app); 730 hours, convention |
| Unity AI Gateway | inference tables and usage tracking, not ticked; 0 GB of payload a month (0.33) | your choice; to measure |
| Evaluation | 4 runs a month of 50 questions; 3 judges; per judgment, 2,000 input tokens and 200 output; 0% of production requests scored; 0 synthetic questions | assumptions to replace; share scored and synthetic questions, your choice |
With R = users × requests a day × days requests a month and E = runs × questions evaluation questions (each evaluation question runs the agent once, an assumption said):
-
The model. Calls
(R + E) × calls per request; millions of input, output and cached tokens, eachcalls × tokens per call ÷ 1,000,000. Per token or priority:Σ millions × DBUs per million × price of a DBU(section 13.11); for a proprietary model, the cached tokens are cache reads (cache-read-mtok). Cache writes (0.33). A proprietary model also bills the tokens written to its prompt cache, counted apart from the input tokens:W = calls × tokens written per call ÷ 1,000,000millions, at the rate of the duration chosen,cache-write-mtok("Cache write" price, the standard write) orcache-write-1h-mtok("Cache write (1hr)" price, a one-hour cache),× price of a DBUof the vendor's SKU. The service workload carriesWincacheWriteMtokor incacheWrite1hMtok, the other staying at 0. In the services snapshot of October 26, 2026,cache-write-mtokis published for all the Anthropic models per token and for OpenAI's GPT-5.6, GPT-6 and GPT-6.1 (per token and priority),cache-write-1h-mtokfor the Anthropic models except Claude Sonnet 4; Gemini, Grok and the other OpenAI models publish none, and the Foundation Model APIs rates have no cache write measure (input, output, cache read only): the field is only asked for a proprietary model. With a model without a price for the duration chosen, these tokens are not priced and a rule says so, with their number; no price is assumed. They are measured insystem.ai_gateway.usage:token_details.cache_creation_input_tokensper call, and the lifetime incache_creation_5m_input_tokensandcache_creation_1h_input_tokens(Track model usage). Example, Azure East US, Premium, no discount, snapshot of October 26, 2026: at the starting values with Claude Haiku 4.5 and 1,000 tokens written per call,W = 33,600 × 1,000 ÷ 1,000,000 = 33.6million; standard write33.6 × 17.857 = 600.0DBUs, at $0.105 a DBU of the Anthropic SKU, that is $63.00; one-hour write33.6 × 28.571 = 960.0DBUs, that is $100.80. On provisioned throughput without commitment:hours entered × (model units ÷ 50) × DBUs an hour × price of a DBU. Reserved for 1 or 3 months: units taken by blocks of 50,max(50, ⌈units ÷ 50⌉ × 50), and 730 hours whatever hours are entered, because a reservation is billed for its full term, used or not (Reserved provisioned throughput Foundation Model APIs). A model or a mode the snapshot does not have on this cloud, or a price per DBU not published for its SKU (for example Kimi on Azure, section 13.11), is asked for. -
Embeddings (search on). Corpus
C = chunks (millions) × tokens per chunkmillion tokens; searches(R + E) × searches per request; a monthC × share embedded again + searches × tokens of a question ÷ 1,000,000million input tokens, at the embedding model's rate. The corpus's first embedding,Cmillion tokens at the same rate, is a one-time spend: it is said apart, out of the month and of the total. -
AI Search (indexed chunks). Units
⌈vectors × dimensions ÷ 768 ÷ capacity of a unit⌉(2 million vectors on Standard, 64 million on Storage Optimized), thenunits × hours × DBUs per unit-hour × price of a DBU; storage above the 30 free GB on Standard (all the storage on Storage Optimized) at the GB-month price, never discounted; reranking, when ticked,searches ÷ 1,000thousand requests× DBUs × price of a DBU. An endpoint is billed as soon as an index exists, and triggered sync is the cheapest, the only one of a Storage Optimized endpoint (AI Search cost management guide). The endpoint runs the hours entered, with or without traffic (an assumption said). -
The agent server. Agent Runtime on Databricks Apps, the way of new agents (Deploy agents on Databricks):
instances × hours × DBUs an hour of the size (Medium 0.5, Large 1, XLarge 3) × price of a DBU; the cost grows with the instances, 5 at most without asking Databricks (Horizontal scaling for Databricks apps). Model Serving, the legacy way:CPU nodes × hours × 4 DBUs per node-hour × price of a DBU. "None": no server, which is said out of the calculation. -
Unity AI Gateway. Each feature ticked, inference tables or usage tracking, has two parts in the service workload (
calc-services.mjs), each on its own quantity: the tokens at the public price per million (inference-tables-mtok,usage-tracking-mtok) and the payload at the public price per GB (inference-tables-gb,usage-tracking-gb), section 13.11. The tokens, on Foundation Model endpoints:G = millions of input + output + cache read + cache write tokensof the model's calls (evaluation included); an assumption says it: all of the model's tokens pass through the gateway. The GB (0.33): the payload, requests and responses, that the gateway logs or tracks on CPU or GPU endpoints (for example the agent server on Model Serving), entered in GB a month (to measure, 0 at the start, asked only when a feature is ticked). Microsoft Learn (Serverless DBU consumption by SKU) bills "Inference Tables for CPU, GPU endpoints" and "Usage Tracking for CPU, GPU endpoints" in DBUs "/ 1 GB of payload", each at its own rate; with public data only, the page takes the snapshot's public price per GB. With both features ticked, the same GB are counted once for each (itGbandutGb), as the tokens are (itMtokandutMtok): each feature bills the payload it processes (Log requests and responses to inference tables: Databricks charges for the requests and responses that inference tables log; Track model usage: the usage that tracking writes tosystem.ai_gateway.usage); an assumption says it. The Unity Gateway pricing page states that both features are charged in payload increments of 1 KB: the bill can be a little above the GB measured. The GB are measured on a Unity Gateway inference table, whoserequestandresponsecolumns keep the raw JSON; the query of the field's help sums them per month, in GB of 10⁹ bytes. Example, Azure East US, Premium, no discount, snapshot of October 26, 2026, at the starting values (G = 77.28million) with both features and 12.5 GB: inference tables77.28 × 0.07 = $5.41and12.5 × 0.100 = $1.25, that is $6.66; usage tracking77.28 × 0.04 = $3.09and $1.25, that is $4.34. -
Evaluation (MLflow). Judge calls
J = (E + R × share scored in production) × judges;J × tokens per judgment ÷ 1,000,000million input and output tokens, at the rate of Agent Evaluation's judges; synthetic questions× price of a question. For costly judges, Databricks advises scoring 5 to 20% of production requests (Set up production monitoring); above 20%, the rule is a warning. - Discounts, by category (section 13.12): the DBU discount on what Databricks bills in DBUs, none on storage per GB-month, never the machine discount.
-
The DBUs of a line are
q × ratewhen the rate is published; a part priced only at a public price per unit (for example Unity AI Gateway per million tokens) has unknown DBUs, and the total DBUs are then said "at least" (marked +).
13.16.4 The cost per question or per request, and rounding
-
Each part is rounded to the cent once. Genie: the warehouse's two workloads, by the Calculator's engine, DBUs and machines apart; the model,
round(billed × price)andround(billed × price × (1 − DBU discount)). Agent: each part of a service workload, by the services engine (section 13.12); a line of the page is the sum of its parts in cents. - The totals, at list price and after discounts, are the sum of the lines, to the cent; the DBUs of the month, the sum of the known DBUs; Genie's free DBUs are said apart.
-
Per question
= total after discounts ÷ Q; per request= total after discounts ÷ R: the evaluation is in the total, not inR. This quotient is a unit price, not rounded to the cent; when the total is partial, so is it. -
Examples, at the starting values, without discount, Azure East US, Premium. A Genie Agent during the promotion, on the snapshot of October 15, 2026: 2,200 questions; 100 SQL statements a day;
L = 100 ÷ (8 × 3,600) × 8 ≈ 0.028concurrent query, so 1 cluster; 7 h 10 off peak and 1 h at peak, that is(7 h 10 + 1 h) × 6 DBUs × 22 days = 1,078X-Small DBUs and $754.60 (946 and 132 DBUs at $0.70); $0.343 per question, the model being free. An agent, on the services snapshot of October 26, 2026: 11,000 requests and 200 evaluation questions, 33,600 calls, 67.2 million input tokens and 10.08 million output; the model $48.72, the embeddings (25.56 million tokens) $3.32, AI Search (1 unit, 730 hours) $204.40, the Medium server (365 DBUs) $346.75, the judges $0.25: $603.44 a month, $0.0549 per request; the first embedding (250 million tokens) costs $32.50, once. -
Verification.
tests/v0320-ai32.test.mjsrecomputes by hand a Genie Agent on a snapshot of round prices (the rule of section 13.9, the allowance, the promotion, the service principal) and an agent part by part on the services snapshot, cross-checked with the token comparator; it checks the discounts by category, the totals to the cent, what is missing, the estimate lines and hostile inputs.tests/v0320-ai32-ui.test.mjschecks the page, the estimate saved, the report and the mail draft. Since 0.33,tests/v0330-ai33.test.mjschecks the cache writes and the GB of Unity AI Gateway: each quantity changes the price by exactlyquantity × unit priceof the snapshot, the duration chosen takes its own rate, a model without a price says so, the total stays the sum of the lines to the cent, the estimate carries the same quantities and gives the same total, and hostile inputs (text,NaN, negative, huge,__proto__) are refused.
13.16.5 What is saved as an estimate, and what stays in its notes
"Add to an estimate" creates an estimate in "My estimates" (30 at most), with the page's cloud, region, plan, discounts and name; each line goes through cleanLine, as any workload (section 13.1).
-
A Genie Agent gives two SQL warehouse workloads, as the dashboards block (section 13.9): the off-peak hours
Hat the minimum of clustersm, the peak hoursp'at the clusters foundM, at the page's size, type (serverless or pro, with the cost entered for its machines) and days, pay as you go. The estimate gives the page's SQL part, to the cent. The language model has no workload kind in an estimate: it stays in its notes, with its DBUs a month and its cost after discounts (or "free during the promotion"); the estimate's total is therefore the warehouse's alone. - An agent gives its service workloads (model, embeddings, AI Search, server, Unity AI Gateway, evaluation) as section 13.12 keeps them, with the page's quantities, tokens written to the cache and the gateway's GB included; the estimate gives the same total, to the cent. The first embedding, a one-time spend, and a part waiting for a value (with the value to enter) stay in the notes.
- The notes first say the estimate comes from this page, then what no line holds; they are cut at 1,000 characters. Without any line, nothing is saved, and the screen says so. The lines are made again from the inputs when the result given is not the one of these inputs.
- Sending it, with nothing leaving YALineo: a self-contained HTML report (no script nor outside resource, with its own content security policy, every value escaped as text: the totals, each part and its calculation, each step, the inputs and their origin, the rules, the assumptions, what is out of the calculation, the checklist and its ticked boxes, the official pages with their read date); the estimate file another YALineo imports (section 13.13); a plain-text summary to paste; a mail draft opened in the user's mail program, with no recipient.
13.16.6 What is not computed
Listed under the answer, by rule:
- Genie: the authors' use of Genie Code while building (billed apart beyond their free allowance); the storage of the source tables; for a pro warehouse, the disks and network of its machines.
- Agent: the compute of its tools (SQL statements on a warehouse, Unity Catalog functions, a Genie Agent used as a tool, MCP servers), each to price with its own calculation; the storage of the source tables and the chunk tables; the index sync pipeline (no published rate; continuous mode provisions a streaming cluster); extracting the text of documents (AI Parse, for example, a service to add in an estimate); the server, with "none" (an agent launched from a job or a notebook, to price apart).
13.16.7 Official sources (read on October 30, 2026, unless said)
With the Calculator's dated snapshot (section 13.2) and the services snapshot (section 13.11) for the prices:
- Databricks, Databricks technical terminology glossary (DBUs): https://docs.databricks.com/aws/en/resources/glossary
- Microsoft Learn, Best practices for cost optimization: https://learn.microsoft.com/azure/databricks/lakehouse-architecture/cost-optimization/best-practices
- Databricks, Monitor and understand your Genie cost: https://docs.databricks.com/aws/en/genie/monitor-cost
- Microsoft Learn, Genie consumption guide: https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Databricks, Create and manage a Genie Agent: https://docs.databricks.com/aws/en/genie-agents/set-up
- Databricks, Curate an effective Genie Agent: https://docs.databricks.com/aws/en/genie-agents/best-practices
- Databricks, Tune Genie Agent quality: https://docs.databricks.com/aws/en/genie-agents/tune-quality
- Databricks, Query history system table reference: https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Microsoft Learn, Create a SQL warehouse: https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create
- Databricks, What is Agent Bricks?: https://docs.databricks.com/aws/en/generative-ai/guide/mosaic-ai-gen-ai-capabilities
- Databricks, Deploy agents on Databricks: https://docs.databricks.com/aws/en/agents/deploy/
- Databricks, Agent Runtime: https://docs.databricks.com/aws/en/agents/deploy/agent-runtime
- Microsoft Learn, Configure compute resources for a Databricks app: https://learn.microsoft.com/azure/databricks/dev-tools/databricks-apps/compute-size
- Microsoft Learn, Horizontal scaling for Databricks apps: https://learn.microsoft.com/azure/databricks/dev-tools/databricks-apps/horizontal-scaling
- Databricks, AI Search cost management guide: https://docs.databricks.com/aws/en/vector-search/vector-search-cost-management
- Databricks, Reserved provisioned throughput Foundation Model APIs: https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/reserved-provisioned-throughput
- Databricks, AI governance with Unity Gateway: https://docs.databricks.com/aws/en/ai-gateway/
-
Databricks, Track model usage (read on October 31, 2026: usage tracking is billed,
system.ai_gateway.usageand itstoken_detailscolumns): https://docs.databricks.com/aws/en/ai-gateway/usage-tracking -
Databricks, Log requests and responses to inference tables (read on October 31, 2026: Databricks charges for the requests and responses logged;
request,response,event_timecolumns): https://docs.databricks.com/aws/en/ai-gateway/inference-tables - Microsoft Learn, Serverless DBU consumption by SKU (read on October 31, 2026: "Inference Tables for CPU, GPU endpoints", 7.143 DBUs / 1 GB of payload; "Usage Tracking for CPU, GPU endpoints", 1.429 DBUs / 1 GB of payload): https://learn.microsoft.com/azure/databricks/resources/pricing
- Databricks, Unity Gateway pricing page (read on October 31, 2026: "Inference Tables and Usage Tracking are charged in payload increments of 1KB"): https://www.databricks.com/product/pricing/ai-gateway
- Microsoft Learn, Built-in LLM judges: https://learn.microsoft.com/azure/databricks/mlflow3/genai/eval-monitor/concepts/judges/
- Databricks, Set up production monitoring: https://docs.databricks.com/aws/en/mlflow3/genai/eval-monitor/production-monitoring
- Little, J. D. C. (1961), A Proof for the Queuing Formula: L = λW, Operations Research 9(3), 383 to 387, DOI 10.1287/opre.9.3.383 (a published law, no read date)
14. References
- Databricks, Billable usage system table reference: https://docs.databricks.com/aws/en/admin/system-tables/billing
- Databricks, Pricing system table reference: https://docs.databricks.com/aws/en/admin/system-tables/pricing
- Databricks, Query history system table reference: https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Databricks, Lineage system tables reference: https://docs.databricks.com/aws/en/admin/system-tables/lineage
- Databricks, Jobs system table reference: https://docs.databricks.com/aws/en/admin/system-tables/jobs
- FinOps Foundation, Allocation (models for allocating shared costs: proportional, even, fixed): https://www.finops.org/framework/capabilities/allocation/