/

Data

How to assign data ownership for every dataset

How to assign data ownership for every dataset

Data

Data

Mahesh Chandran

Mahesh Chandran

CEO

CEO

Guide cover: How to assign data ownership. Give every dataset a named person who answers for it.

Who gets the call when the revenue table is wrong at 7 a.m. on the first of the month? If finding the answer takes longer than a minute, the table has no owner that anyone can act on.

Data ownership sounds like a governance exercise, and it is often run as one, with a spreadsheet of names that drifts out of date within a quarter. The practical version is smaller. Every dataset the business depends on needs a named person who can fix it, a named person who decides what it should say, and a record of both that alerts and reviews can find on their own.

This guide shows how to assign data ownership in that practical sense. It covers which datasets need owners first, how to find the right people from evidence in your code and warehouse, how to get them to accept the role, where to record ownership so tools can use it, and how to keep it current as people move. It includes queries for Snowflake, BigQuery and dbt, a worked example and the mistakes that most often undo the work.

The short answer

Give every Tier 1 and Tier 2 dataset two owners. A technical owner keeps the pipeline running and fixes it when it breaks. A business owner decides what the data should say and confirms when it is wrong. Find technical owners from commit history, job definitions and the warehouse’s write history, and business owners from where the data lands. Record both in the pipeline code and as tags or labels in the warehouse, so alerts, reviews and catalogs read the same names. Measure how many important datasets have both owners, and check the list every quarter and whenever someone leaves.

Key terms

  • Technical owner: the person who maintains the pipeline that builds a dataset and is first in line to fix it.

  • Business owner: the person who uses the data to make decisions, defines what correct looks like, and approves changes to its meaning.

  • Ownership record: the place where owners are written down, such as a dbt group, a warehouse tag or a catalog entry.

  • Dataset tier: a rank from 1 to 3 that records how much the business depends on a dataset. Tier 1 is the highest.

  • Ownership coverage: the share of Tier 1 and Tier 2 datasets that have both a technical and a business owner recorded.

The method at a glance

  1. List the Tier 1 and Tier 2 datasets, with what each one feeds.

  2. Find a technical owner for each from commit history, job definitions and write history.

  3. Find a business owner for each from the destination its data reaches.

  4. Agree the role with each person, with a short list of duties.

  5. Record both owners in the pipeline code and as warehouse tags or labels.

  6. Send alerts, reviews and change requests to the recorded owners.

  7. Measure ownership coverage and fix the gaps.

  8. Check the list every quarter and whenever someone changes role or leaves.

Why do datasets end up without owners?

Most datasets start with an obvious owner, the person who built them. Ownership fades through ordinary events:

  • The builder moves on. The person who wrote the pipeline changes team or leaves, and nobody takes over the table until it breaks.

  • Many teams read it. A shared table such as customers or orders is used by everyone, so each team assumes another one owns it.

  • The owner is a mailing list. A team alias receives the alerts, and every member assumes someone else has picked them up.

  • The record lives in a wiki. A page of owners written once and never updated is wrong within months, and tools cannot read it.

  • The project ended. A dataset built for a launch or an analysis keeps running after the work it supported is finished, and the people who asked for it have moved on.

Each of these leaves the same gap. When the data is wrong, nobody is clearly responsible for noticing, fixing it or telling the people who rely on it.

What does it cost when nobody owns a dataset?

The cost shows up as delay and rework, usually at the worst moment.

  • Incidents take longer. The first hour of a data incident often goes on finding out who understands the table. With an owner on record, that hour goes on fixing it.

  • Changes break readers. Without a business owner to approve changes to meaning, a column gets renamed or a definition shifts, and the dashboards and models that read it change their numbers without anyone deciding they should.

  • Copies multiply. When nobody answers questions about a table, people build their own version. Two revenue tables with slightly different logic is a common result.

  • Dead data keeps running. A dataset with no owner has nobody to decide it is no longer needed, so it keeps costing compute and storage.

The cost of bad data covers what errors in important data cost once they reach customers, finance or regulators. Ownership is one of the cheapest ways to shorten them.

What does a dataset owner do?

Ownership should come with a short, specific list of duties. A longer list makes people reluctant to accept it. The duties scale with the dataset’s tier.

Two owners for every important dataset: the technical owner keeps the pipeline running and fixes failures, the business owner defines what correct means and confirms when it is wrong.
  • Technical owner of a Tier 1 dataset: receives its alerts, fixes failures, keeps its tests current, reviews changes to its code, and tells readers when it is late or wrong.

  • Business owner of a Tier 1 dataset: defines what correct looks like, agrees on freshness and detection targets, approves changes to its meaning, and confirms whether a suspected error is real.

  • Owners of Tier 2 datasets: the same duties, with alerts during working hours.

  • Tier 3 datasets: a technical owner for retirement reviews is enough.

It helps to say what owners are not expected to do. A business owner does not need to write SQL or read pipeline code. A technical owner does not need to know every decision the data feeds. Neither has to approve every query someone runs against the table. Keeping the role this narrow is what makes it possible to fill.

Which datasets need owners first?

Start with the datasets whose errors cost the most. How to decide which datasets your business depends on shows how to rank datasets into tiers by where their data lands, such as invoices, financial reporting, customer-facing products and production models.

Assign owners in this order:

  1. Tier 1 datasets that feed money, customers or regulators directly.

  2. The upstream tables those Tier 1 datasets are built from, which inherit Tier 1.

  3. Tier 2 datasets that feed internal decisions on a regular schedule.

  4. Tier 3 datasets, with a technical owner only, as part of a retirement review.

Do not try to assign every table in the warehouse in one pass. A list of a few dozen Tier 1 datasets with confirmed owners does more good than a list of thousands where most names are guesses.

How do you find the right owners?

Technical owners

The best evidence is in the code and the warehouse. The commit history of the pipeline shows who has changed it most recently and most often. The orchestrator shows which team’s project the job sits in. The warehouse’s write history shows which service account or user writes the table.

Commit history for a single dbt model takes one command:

git log --since="1 year ago" --format='%an' -- models/billing/invoice_lines.sql \
  | sort | uniq -c | sort -rn | head -5
git log --since="1 year ago" --format='%an' -- models/billing/invoice_lines.sql \
  | sort | uniq -c | sort -rn | head -5
git log --since="1 year ago" --format='%an' -- models/billing/invoice_lines.sql \
  | sort | uniq -c | sort -rn | head -5

In Snowflake, the ACCESS_HISTORY view records which objects each query modified, in its objects_modified column. It requires Enterprise Edition or higher. This query lists who has written to a table in the last 90 days:

SELECT
  ah.user_name,
  COUNT(*) AS writes,
  MAX(ah.query_start_time) AS last_write
FROM snowflake.account_usage.access_history ah,
  LATERAL FLATTEN(input => ah.objects_modified) om
WHERE om.value:"objectName"::STRING = 'ANALYTICS.BILLING.INVOICE_LINES'
  AND ah.query_start_time >= DATEADD('day', -90, CURRENT_TIMESTAMP())
GROUP BY ah.user_name
ORDER BY writes DESC

SELECT
  ah.user_name,
  COUNT(*) AS writes,
  MAX(ah.query_start_time) AS last_write
FROM snowflake.account_usage.access_history ah,
  LATERAL FLATTEN(input => ah.objects_modified) om
WHERE om.value:"objectName"::STRING = 'ANALYTICS.BILLING.INVOICE_LINES'
  AND ah.query_start_time >= DATEADD('day', -90, CURRENT_TIMESTAMP())
GROUP BY ah.user_name
ORDER BY writes DESC

SELECT
  ah.user_name,
  COUNT(*) AS writes,
  MAX(ah.query_start_time) AS last_write
FROM snowflake.account_usage.access_history ah,
  LATERAL FLATTEN(input => ah.objects_modified) om
WHERE om.value:"objectName"::STRING = 'ANALYTICS.BILLING.INVOICE_LINES'
  AND ah.query_start_time >= DATEADD('day', -90, CURRENT_TIMESTAMP())
GROUP BY ah.user_name
ORDER BY writes DESC

In BigQuery, the INFORMATION_SCHEMA.JOBS view records the destination table and the user or service account of each job, for the past 180 days:

SELECT
  user_email,
  COUNT(*) AS writes,
  MAX(creation_time) AS last_write
FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE destination_table.dataset_id = 'billing'
  AND destination_table.table_id = 'invoice_lines'
  AND creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)
GROUP BY user_email
ORDER BY writes DESC

SELECT
  user_email,
  COUNT(*) AS writes,
  MAX(creation_time) AS last_write
FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE destination_table.dataset_id = 'billing'
  AND destination_table.table_id = 'invoice_lines'
  AND creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)
GROUP BY user_email
ORDER BY writes DESC

SELECT
  user_email,
  COUNT(*) AS writes,
  MAX(creation_time) AS last_write
FROM `region-us`.INFORMATION_SCHEMA.JOBS
WHERE destination_table.dataset_id = 'billing'
  AND destination_table.table_id = 'invoice_lines'
  AND creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)
GROUP BY user_email
ORDER BY writes DESC

Both queries usually return a service account. That points to the orchestrator project or deployment that uses it, and the team that runs that project is the starting point. The commit history then narrows it to a person.

When the evidence points to someone who has left, the person who last changed the code is usually the best place to start. When nobody has touched it in a year, the team that owns the orchestrator project takes it by default until someone better is found.

Business owners

Follow the data to where it lands. The business owner of the table behind the invoice run is whoever is accountable for invoices, usually in finance or billing. The business owner of a marketing dashboard is the person who plans spend from it. The business owner of a feature table for a production model is the person accountable for that model’s decisions.

A shared table with many destinations takes the business owner of its highest-stakes destination. The customers table that feeds billing and a marketing dashboard belongs, on the business side, to the billing owner. The other readers still get notified about changes, but the billing owner decides.

Data from outside the company

Data that arrives from a vendor, a partner or a SaaS tool still needs two owners inside the company. The technical owner runs the ingestion and watches for late or malformed files. The business owner is whoever manages the relationship with the vendor, because they are the person who can ask the vendor to fix a problem at the source.

How do you get people to accept ownership?

Most resistance comes from fear of an open-ended job. A short conversation with each candidate, with specifics, usually settles it.

  • Show them what the data feeds. A business owner who sees that a table drives the monthly invoice run understands why it needs one.

  • Give them the list of duties for its tier. Keep it to the duties above, and say how often each one comes up.

  • Agree how they will hear about problems. Tier 1 alerts go to the technical owner, with a summary to the business owner. Tier 2 alerts go to the owning team’s channel during working hours.

  • Name a fallback. Agree who covers holidays and absences, usually someone else on the same team.

  • Write it down together. Ask them to approve the pull request that adds their name. Approval in the code review is the record that they accepted.

If nobody will accept a dataset, treat that as information. Either nobody depends on it, or the person who depends on it most has not yet seen what it feeds. Both are worth knowing.

Where should ownership be recorded?

Record owners where the tools that need them can read them. A wiki page can link to the record, but it should not be the record.

In dbt

dbt groups assign a set of models to a named owner. Each group needs an owner with a name or an email, and each model can belong to one group. Setting a model’s access to private stops models in other groups from referencing it, which is useful for tables only one team should build on.

The dbt platform can email group owners about failures in their models and about test failures and warnings, while the job is still running. An administrator has to turn on group and owner notifications, and the deployment environment has to be on a release track. A meta field on each model can hold the business owner and the tier, which the group does not cover.

groups:
  - name: billing
    owner:
      name: Billing data team
      email: billing-data@example.com

models:
  - name: invoice_lines
    config:
      group: billing
      meta:
        tier: 1
        technical_owner: priya@example.com
        business_owner

groups:
  - name: billing
    owner:
      name: Billing data team
      email: billing-data@example.com

models:
  - name: invoice_lines
    config:
      group: billing
      meta:
        tier: 1
        technical_owner: priya@example.com
        business_owner

groups:
  - name: billing
    owner:
      name: Billing data team
      email: billing-data@example.com

models:
  - name: invoice_lines
    config:
      group: billing
      meta:
        tier: 1
        technical_owner: priya@example.com
        business_owner

In Snowflake

Snowflake object tags attach key-value pairs to tables and other objects. Creating and setting tags is available in every edition, and a single object can carry up to 50 tags. Tags keep ownership visible to anyone querying the warehouse, including people who never open the dbt project.

CREATE TAG IF NOT EXISTS governance.tags.tier;
CREATE TAG IF NOT EXISTS governance.tags.technical_owner;
CREATE TAG IF NOT EXISTS governance.tags.business_owner;

ALTER TABLE analytics.billing.invoice_lines SET TAG
  governance.tags.tier = '1',
  governance.tags.technical_owner = 'priya@example.com',
  governance.tags.business_owner = 'head-of-billing@example.com'

CREATE TAG IF NOT EXISTS governance.tags.tier;
CREATE TAG IF NOT EXISTS governance.tags.technical_owner;
CREATE TAG IF NOT EXISTS governance.tags.business_owner;

ALTER TABLE analytics.billing.invoice_lines SET TAG
  governance.tags.tier = '1',
  governance.tags.technical_owner = 'priya@example.com',
  governance.tags.business_owner = 'head-of-billing@example.com'

CREATE TAG IF NOT EXISTS governance.tags.tier;
CREATE TAG IF NOT EXISTS governance.tags.technical_owner;
CREATE TAG IF NOT EXISTS governance.tags.business_owner;

ALTER TABLE analytics.billing.invoice_lines SET TAG
  governance.tags.tier = '1',
  governance.tags.technical_owner = 'priya@example.com',
  governance.tags.business_owner = 'head-of-billing@example.com'

In BigQuery

BigQuery labels can be set on datasets, tables, views and reservations, with up to 64 labels on each. Keys and values can contain only lowercase letters, numbers, underscores and dashes, so an email address cannot be stored as a label value. Use a short username or a team name, and keep the mapping from that name to a person in your directory or the dbt project.

ALTER TABLE analytics.invoice_lines
SET OPTIONS (
  labels = [
    ('tier', '1'),
    ('technical_owner', 'priya_s'),
    ('business_owner', 'billing_lead')
  ]
)

ALTER TABLE analytics.invoice_lines
SET OPTIONS (
  labels = [
    ('tier', '1'),
    ('technical_owner', 'priya_s'),
    ('business_owner', 'billing_lead')
  ]
)

ALTER TABLE analytics.invoice_lines
SET OPTIONS (
  labels = [
    ('tier', '1'),
    ('technical_owner', 'priya_s'),
    ('business_owner', 'billing_lead')
  ]
)

In the catalog

If the team runs a data catalog, it should read owners from the code or the warehouse. Owners typed into the catalog by hand drift from the code. Name a person in each owner field, with the team as a fallback. A team alias on its own recreates the problem of everyone assuming someone else is looking.

How do you check ownership coverage?

Measure the share of Tier 1 and Tier 2 datasets with both owners recorded, and list the gaps. The check should run on a schedule, so gaps show up without anyone having to look.

In Snowflake, the TAG_REFERENCES view lists every tag set on every object. It can lag by up to two hours. This query lists base tables in a database that have no technical owner tag:

SELECT t.table_schema, t.table_name
FROM analytics.information_schema.tables t
LEFT JOIN snowflake.account_usage.tag_references r
  ON r.object_database = t.table_catalog
 AND r.object_schema = t.table_schema
 AND r.object_name = t.table_name
 AND r.domain = 'TABLE'
 AND r.tag_name = 'TECHNICAL_OWNER'
 AND r.object_deleted IS NULL
WHERE t.table_type = 'BASE TABLE'
  AND r.tag_name IS NULL
ORDER BY t.table_schema,

SELECT t.table_schema, t.table_name
FROM analytics.information_schema.tables t
LEFT JOIN snowflake.account_usage.tag_references r
  ON r.object_database = t.table_catalog
 AND r.object_schema = t.table_schema
 AND r.object_name = t.table_name
 AND r.domain = 'TABLE'
 AND r.tag_name = 'TECHNICAL_OWNER'
 AND r.object_deleted IS NULL
WHERE t.table_type = 'BASE TABLE'
  AND r.tag_name IS NULL
ORDER BY t.table_schema,

SELECT t.table_schema, t.table_name
FROM analytics.information_schema.tables t
LEFT JOIN snowflake.account_usage.tag_references r
  ON r.object_database = t.table_catalog
 AND r.object_schema = t.table_schema
 AND r.object_name = t.table_name
 AND r.domain = 'TABLE'
 AND r.tag_name = 'TECHNICAL_OWNER'
 AND r.object_deleted IS NULL
WHERE t.table_type = 'BASE TABLE'
  AND r.tag_name IS NULL
ORDER BY t.table_schema,

In dbt, every run writes a manifest.json file that includes each model’s group and config. A short script lists models missing an owner or a tier:

import json

manifest = json.load(open("target/manifest.json"))
required = ("tier", "technical_owner", "business_owner")

for node in manifest["nodes"].values():
    if node["resource_type"] != "model":
        continue
    meta = node.get("config", {}).get("meta", {})
    missing = [key for key in required if key not in meta]
    if not node.get("group") or missing:
        print(node["name"], node.get("group"), missing)
import json

manifest = json.load(open("target/manifest.json"))
required = ("tier", "technical_owner", "business_owner")

for node in manifest["nodes"].values():
    if node["resource_type"] != "model":
        continue
    meta = node.get("config", {}).get("meta", {})
    missing = [key for key in required if key not in meta]
    if not node.get("group") or missing:
        print(node["name"], node.get("group"), missing)
import json

manifest = json.load(open("target/manifest.json"))
required = ("tier", "technical_owner", "business_owner")

for node in manifest["nodes"].values():
    if node["resource_type"] != "model":
        continue
    meta = node.get("config", {}).get("meta", {})
    missing = [key for key in required if key not in meta]
    if not node.get("group") or missing:
        print(node["name"], node.get("group"), missing)

Report coverage for Tier 1 and Tier 2 separately. Tier 1 coverage should reach every dataset before anyone spends time on Tier 3.

How do you keep ownership current?

Ownership goes out of date as people change roles. These habits keep it accurate:

  • Check on departures. When someone leaves or changes team, list the datasets they own and reassign them before their last day. A query against the tags or the dbt manifest gives the list in seconds.

  • Review every quarter. Confirm that every Tier 1 and Tier 2 dataset still has two owners, and that each named person still works on it.

  • Require owners for new datasets. Make an owner and a tier part of the pull request that creates a new model. A dataset with no owner stays out of Tier 1 and Tier 2 alerting until it has one.

  • Fail the build on gaps. Run the coverage script in continuous integration, and fail it when a Tier 1 or Tier 2 model is missing an owner.

When an owner hands over a Tier 1 dataset, a short checklist stops knowledge leaving with them:

  • Walk the new owner through what the dataset feeds and who reads it.

  • Share the known failure modes and how each was fixed last time.

  • Transfer alert routing, on-call schedules and any vendor contacts.

  • Update the dbt meta field, the warehouse tags and the group owner in one pull request.

  • Ask the new owner to approve that pull request as their acceptance.

Datasets that nobody will own are worth a second look. Often nobody depends on them, and How to find and retire unused data pipelines shows how to check and retire them.

A worked example

Here is how the method plays out for a single table. The names and details are invented to show the steps.

A company’s invoice_lines table feeds the monthly invoice run, so it is Tier 1. Nobody is recorded as its owner. The Snowflake write history shows that a service account called TRANSFORM_PROD writes it every night. That account belongs to the analytics engineering team’s dbt deployment. The commit history of the model shows that Priya made most of the changes in the last year, and still works on the billing models.

On the business side, the invoice run belongs to the head of billing. In a fifteen-minute conversation, Priya agrees to be technical owner, with a colleague on the same team as her fallback. The head of billing agrees to be business owner, on the understanding that their duties are to define correct invoice lines, approve changes to the table’s meaning, and confirm suspected errors.

One pull request adds the billing group, the meta fields and the Snowflake tags. Both owners approve it. From the next run, dbt failures on the model email the billing group, and the coverage report shows one more Tier 1 dataset with both owners.

What mistakes should you avoid?

  • Assigning owners without asking them. A name added without agreement is a guess. The person will not act on alerts they did not expect.

  • Making the business owner a technical role. If the business owner is the head of the data team, nobody outside the team is deciding what the data should say.

  • Recording owners in one place only. Owners in a wiki do not reach alerts. Owners in dbt alone do not reach people browsing the warehouse.

  • Starting with every table. A full inventory stalls before it reaches the datasets that matter. Start with Tier 1.

  • Never revisiting the list. Ownership written once is wrong within months. The quarterly check and the departure check keep it true.

Questions people ask

Should a dataset be owned by a person or a team?

By a person, with a team as the fallback. A named person can be paged, asked and held to a decision. The team gives cover for holidays and departures.

What if nobody wants to own a dataset?

Check whether anyone depends on it. If nobody does, it is a candidate for retirement. If someone does, the person who depends on it most becomes the business owner, and the team that runs the pipeline assigns a technical owner.

Who owns raw source data?

The team that runs the ingestion owns it technically. The business owner is the owner of the source system, such as the billing platform team for raw billing data, because they know what the data should contain.

Does every dataset need an owner?

Every Tier 1 and Tier 2 dataset needs both owners. Tier 3 datasets need only a technical owner, mainly so someone can decide whether to retire them.

Is a data owner the same as a data steward?

Companies use the words differently. In many, a steward looks after data definitions and quality across a domain, while an owner is accountable for specific datasets. What matters is that each Tier 1 dataset has one named person for fixing it and one for deciding what it should say, whatever the titles are.

Should owners approve access requests?

For datasets with sensitive content, the business owner is a natural approver, because they know who needs the data. For everything else, access rules set by role are faster and do not depend on one person being available.

How long does it take to assign owners?

It depends on how many Tier 1 and Tier 2 datasets there are and how quickly people can be reached. The evidence-gathering queries run in minutes. Most of the time goes on the conversations, which is why starting with Tier 1 matters.

Where Dataring fits

We built Dataring to rank every dataset by how much the business depends on it, then act on that ranking. Owners are part of that ranking, so alerts and reviews for the data behind billing, finance and customer-facing products reach a named person. Pipelines nobody depends on are retired within limits each company sets, under its supervision.

Book a free call to see it on your data estate. For the wider process this guide fits into, read How to audit your data estate in seven steps.

Newsletter

Product news by email. We use your address for nothing else.

© 2026 ShareData Inc.Last updated October 29, 2026