TL;DR. Data FinOps is FinOps with a smaller unit: the table, pipeline, dashboard or model, not the cloud service. Most major engines now attribute cost inside themselves, and each stops at its own boundary and leaves a remainder no query owns. In a worked model of one shared Snowflake warehouse, 82% of the credits are idle, and splitting that idle in proportion to usage misprices both data products by more than 5x. The fix is a rule: report the unowned remainder as its own number, then assign it by cause.

Data FinOps is the practice of pricing, owning and cutting data platform spend per data product (a table, a pipeline, a dashboard, a model) instead of per cloud service. Cloud FinOps stops at the invoice line; data spend is decided one level below it, by whoever schedules a job or keeps a dashboard alive.

The FinOps Foundation defines FinOps as "an operational framework and cultural practice which maximizes the business value of technology". Its FinOps for Data Cloud Platforms scope names the allocation problem in one line: "multiple teams, workloads, or products consume pooled warehouses or clusters." This post shows what that does to a cost number, and which three numbers to get first.

Data FinOps vs cloud FinOps: the unit changes from service to data product

Cloud FinOps answers "which team owns this account, service or tagged resource". That works when one resource serves one team. A data platform breaks it, because the expensive resources are shared by design.

Cloud FinOpsData FinOps
Unit of costAccount, service, tagged resourceTable, pipeline, dashboard, model, agent
Usage signalResource utilizationQueries, jobs and reads per data product
Typical wasteIdle instances, unattached volumesOutputs nobody reads, refreshes nobody opens, idle tails between jobs
Who decides the changeResource ownerOwner of the data product, approved by its reader

A tag on a warehouse tells you who pays for it, not which product spent the money. AWS's own RDS guide says cost allocation tags let you "organize your AWS bill to reflect your own cost structure", and they attach to resources such as a DB instance or snapshot. One Postgres instance serving three products is one tagged line. Splitting it takes a usage key from inside the database, for example total_exec_time per statement and per userid in pg_stat_statements.

Why the invoice line is the wrong grain: native attribution stops inside each engine

The engines now ship their own attribution: on November 9, 2026, Google shipped compute cost attribution for BigQuery and AWS shipped system tables for Athena. Each engine reaches a different depth, and none crosses into the next one.

EngineFinest native cost grainWhere it stops
SnowflakeQuery, in QUERY_ATTRIBUTION_HISTORYExcludes warehouse idle time, cloud services, serverless features, storage, data transfer and AI tokens; queries of about 100 ms or less are left out
BigQuery editionsQuery project, with compute cost attribution (Preview since November 9, 2026, opt in)Without it, the administration project "is billed for the committed slots" and query projects are not billed for the slots
DatabricksJob, through job_id in system.billing.usagejob_id "does not populate for jobs run on all-purpose compute"; budgets price usage at list price
Amazon AthenaQuery, with the tables it references, in the new query_executions system tableBytes scanned per query, not split by table; an opt-in feature, enabled per account and Region
RDS for PostgreSQLDB instance, by tagNothing per query on the bill; split with pg_stat_statements yourself

Layer stack of data platform cost from the invoice line down to the consumer. Native attribution reaches the DB instance on RDS, the job on Databricks, the query project on BigQuery, and the query on Snowflake and Athena. No native view reaches the table, pipeline or consumer layers, which are the units data FinOps needs.

Two gaps follow from the table. First, cost per data product is a join across engines: the ingestion load, the warehouse build and the BI refresh for one dashboard sit in three systems, and our data pipeline cost model found no single billing view showing more than 45% of one pipeline. Second, every engine leaves a remainder that no query owns. How you treat that remainder decides whose product looks expensive.

A shared warehouse split by usage charges the wrong team for idle time

Consider a hypothetical Snowflake account with one Medium warehouse (4 credits an hour on Gen1, per Snowflake's warehouse size table), AUTO_SUSPEND at its default of 600 seconds, and two data products:

  • Product A, a finance mart: a nightly build that runs queries back to back from 01:00 to 03:00.
  • Product B, a dashboard extract: a 20-second query every 15 minutes from 06:00 to 21:45, 64 runs a day.

Snowflake bills per second with a 60-second minimum each time the warehouse resumes. Each run of B resumes the warehouse, works for 20 seconds, then idles 600 seconds before it suspends, since the next run is 900 seconds away. QUERY_ATTRIBUTION_HISTORY attributes the span "from the start of the first query to the end of the last query" in each minute; time after the last query "and minutes in which no queries run, are idle time and aren't attributed."

Over 30 days, in credits (the model ignores the roughly 30-second suspend poll and any cloud services charge):

ProductAttributed to its queriesIdle it causesAllocated in proportion to usageAllocated by cause
A, nightly finance build240.020.01,343.8260.0
B, 15-minute extract42.71,280.0238.91,322.7
Warehouse total282.71,300.0 (82.1%)1,582.71,582.7

The inputs: A runs 2 hours a day at 4 credits an hour (8.0 credits) plus one 600-second tail (0.667). B runs 64 × 20 seconds (1.422 credits) and leaves 64 tails of 600 seconds (42.667 credits). A holds 84.9% of the attributed credits, so a usage split hands it 84.9% of the idle.

The usage split bills the finance team 5.2 times what its build causes, and shows the extract at less than a fifth of its real cost. B causes 30 credits of idle for every credit of query work. Under the proportional rule it looks like the cheap product; by cause it is 84% of the warehouse.

The cut belongs to the owner of B. At AUTO_SUSPEND = 60, each run bills 80 seconds instead of 620, and the month drops from 1,582.7 to 412.7 credits, 73.9% less. Moving B to its own X-Small warehouse, or batching it hourly, is the same decision. None of that shows if the finance team gets the bill.

This model is built to show the mechanism, so its idle share is extreme. Real warehouses mix many workloads whose tails overlap, and your share comes from CREDITS_USED_COMPUTE minus CREDITS_ATTRIBUTED_COMPUTE_QUERIES in WAREHOUSE_METERING_HISTORY, as in query 3 of our Snowflake cost optimization guide. That view is hourly, so assigning idle by cause is an approximation: give each hour's idle to the workloads whose last query preceded the gap. The attributed column is NULL for Adaptive Warehouses, where this method does not apply.

Three numbers to measure first: cost per data product, spend with no reader, cost per consumer

  1. Cost per data product or pipeline. Sum, per product, the attributed cost from each engine it touches (query or job cost, load fees, BI refresh) plus its share of idle assigned by cause. Mark the idle share as a separate column so nobody mistakes it for query work.
  2. Share of spend with no reader in 90 days. Join each product's output tables to read logs: Snowflake's ACCESS_HISTORY covers the last 365 days but "requires Enterprise Edition (or higher)"; Athena's system table lists the tables each query references. If B's dashboard had no viewer in 90 days, all 1,322.7 credits in the model are this number. Our Snowflake access history post has the query.
  3. Cost per consumer. Give every dashboard service account, model and agent its own user or tag, so USER_NAME and QUERY_TAG in QUERY_ATTRIBUTION_HISTORY carry its name. AI agents need one more line: Snowflake's per-query cost excludes "costs for tokens processed by AI services", so an agent's model spend sits in a separate meter and must be added per task.

The strongest objection comes from the FinOps Foundation itself. Its allocation capability lists shared costs "allocated to central budgets or platform teams directly and not charged back" as a Crawl trait, and shared costs "split using an appropriate distribution model(s) (proportional, fixed, even-split)" at Walk. A full split is the right goal when finance needs every dollar on a cost center. The model shows why the split needs a cause-based key on data platforms: a proportional key reconciles to the invoice and still sends the fix to the wrong team. Report the unowned number first, then split it.

Who owns each line of the data bill: platform, domain and finance

Ownership follows control. A team should own a cost line only if it can change it without asking another team.

LinePlatform teamDomain team (product owner)Finance
Warehouse, cluster and instance settings (size, auto-suspend, scaling)OwnsConsultedInformed
Idle remainder per warehouseOwns, assigns by causeInformed of its shareApproves the rule
Cost of each data product across enginesBuilds the reportOwns, decides to keep, tune or stopInformed
Outputs with no readerFinds themDecides with the readersInformed
Rates, commitments, negotiated discountsConsultedInformedOwns
Budgets and alertsSets themOwns its product's thresholdApproves totals

Budgets are guards, not allocation. Databricks says its budgets "do not factor in any billing credits or negotiated discounts" and compute spend by "multiplying usage by the SKU list price", so finance still reconciles to the invoice.

A monthly data FinOps review in five steps

  1. Reconcile. Pull each engine's attributed cost and its unattributed remainder for the month, and check the sum against the invoices.
  2. Assign the remainder by cause, with the hourly idle method above or your engine's equivalent, and publish the rule.
  3. Rank data products by cost, with the no-reader flag beside each one.
  4. Send each top product to its owner with one proposed change (stop, batch, resize, move warehouse), written as a reviewable change to the job or warehouse definition, not a ticket.
  5. Re-measure next month against the same three numbers, so a cut that moved cost to another engine shows up.

The limits: the worked model uses Snowflake's documented rules and has not been run on an account, and it holds one workload per product. Cost per data product also needs lineage from output tables back to the jobs that build them, which no billing view provides. For the wider list of waste the review will surface, see cloud waste in data infrastructure.

Datapace is building one map of your data estate with usage and cost attached, and agents that propose changes as pull requests your team reviews and merges. To see what the first review could find on your platform, book a call.