Finance wants consistent revenue reporting. Marketing needs campaign-level performance. Operations wants regional order trends. All three teams rely on data in the same warehouse, but none necessarily needs access to customer identifiers, payment details, internal notes, or every raw event.
Granting everyone read access to source datasets is convenient until a new sensitive field arrives, an analyst exports an unrestricted table, or a dashboard uses a different definition of revenue. Copying a separate sanitized dataset for each department is another option, but it creates refresh dependencies and more places where data can drift.
BigQuery authorized datasets offer a third approach: place curated SQL views in a controlled dataset, authorize that dataset to read the underlying source dataset, and grant consumers access to the curated views rather than the raw tables. The benefit is a reusable publishing boundary. The risk is that every view in the authorized dataset, including future views, can potentially expose information from the shared source.

The executive question is therefore not simply whether the feature works. It is who can publish a view, what information a view is allowed to reveal, how changes are approved, and how the organization proves that direct raw access remains blocked.
The executive answer
Use authorized datasets when a group of related views must access the same protected source dataset and the organization can tightly control who creates or changes those views. Use individual authorized views when only a few views need authorization or when view-level exceptions are important. Use other BigQuery governance controls when access must be restricted dynamically by user, row, or column.
A secure design separates three responsibilities: source ownership, publishing authority, and consumer access. Source owners decide which datasets may be used by an authorized dataset. A restricted publishing role controls the SQL that determines what is disclosed. Consumers receive read access to approved views and permission to run query jobs, without inheriting direct rights to source tables.
That separation is more important than the number of datasets. Actiknow’s business intelligence and data integration services address the wider modeling and reporting architecture in which these boundaries operate.
The two datasets have different jobs
Imagine a project with `enterprise_raw.orders` and `enterprise_raw.customers`. These tables contain operational identifiers and potentially sensitive attributes. A second dataset, `finance_published`, holds a view called `monthly_revenue` that selects only approved fields and applies an agreed business definition.
Ordinarily, a person querying a standard logical view may need access to the tables referenced by its SQL. BigQuery authorization changes that relationship. The source dataset authorizes the dataset containing the views, so consumers can query approved views without obtaining direct read access to the source dataset. Authorization is applied to the source dataset’s access list, not by granting every consumer permission on the raw tables.
The direction matters: `enterprise_raw` is the shared dataset that grants access; `finance_published` is the authorized dataset whose views can use that access. It is easy to reverse those terms during implementation and accidentally configure a different access policy.
Authorization is not the same as consumer permission
There are two separate checks. First, the source dataset must authorize the publishing dataset. Second, the analyst or BI service account must have permission to query the published view, plus the necessary ability to create query jobs in an appropriate project. Granting consumer access to `finance_published` alone does not automatically authorize its views to read `enterprise_raw`. Conversely, authorizing `finance_published` does not automatically make every view readable by every employee.
Google’s authorized dataset documentation explains this access model, the source-dataset authorization step, and the additional permissions required for creating and updating views in an authorized dataset.
Current and future views are in scope
This is the defining trade-off. Authorizing a dataset allows its current and future views to access the shared source dataset. That removes the administrative work of authorizing every view individually, but makes view creation and modification a security-sensitive operation. A new view that exposes an unrestricted identifier column may be queryable by everyone who can read that view.
For this reason, an authorized dataset should not also be an unrestricted analyst sandbox. Treat it as a production publication surface, with protected deployment credentials, code review, ownership, and monitoring.
A practical architecture for departmental reporting
Separate raw, modeled, and published responsibilities
A useful pattern is `raw` for source-aligned records, `core` for validated business entities, and `published_finance` or `published_sales` for consumer-facing views. These are logical responsibilities, not a mandate to copy data three times. Where appropriate, a published view can reference a curated model rather than an ingestion table, reducing the chance that source-system quirks leak into a dashboard.
For a finance report, the published view might expose month, region, product category, recognized revenue, and order count. It should not expose customer email, payment token, or unrestricted order-level notes simply because those columns exist in the source. Define the minimum useful grain first, then implement the view.

A departmental boundary can also carry a business contract: metric definition, refresh expectation, owner, permitted consumers, known exclusions, and escalation path. This makes a published dataset useful for reporting governance rather than merely access management.
Choose one publishing dataset per coherent trust boundary
Do not put unrelated high-risk and low-risk views into one broad authorized dataset merely to save configuration work. A finance reporting dataset and a vendor-facing dataset may need different owners, approvals, and exposure rules. They should generally have separate publishing boundaries. Equally, creating a new authorized dataset for every individual dashboard can produce unnecessary policy sprawl.
A sensible grouping uses shared source access needs, data sensitivity, release ownership, and consumer population. The objective is to make it obvious who can publish and who can consume each group of views.
Design for BI tools and service accounts
A dashboard connector typically queries BigQuery using a person or service identity. Confirm which identity is used, which project pays for query jobs, and which datasets it can read. A service account that has project-wide BigQuery Data Viewer permissions can undermine a carefully restricted published dataset. Check inherited IAM grants as well as direct dataset grants.
For executive dashboards, consistent metrics and stable schemas are as important as the access policy. Actiknow’s BI dashboard development page describes its work integrating sources and building reporting interfaces; the warehouse publication boundary should be designed alongside that consumption layer.
Implementation example: from protected orders to a governed revenue view
The following example is illustrative SQL, not a client implementation. Replace project names, data types, financial rules, and access groups with validated values for your environment. Assume both datasets are in the same BigQuery location.
Step 1: create the publishing dataset
CREATE SCHEMA IF NOT EXISTS `analytics-prod.finance_published`
OPTIONS (location = ‘US’, description = ‘Approved finance reporting views’);
Create the dataset using a privileged deployment identity, not an individual analyst account. Its description should identify the purpose and ownership. Decide whether the dataset should contain only approved views; if so, keep ordinary scratch tables and exploratory objects elsewhere.
Step 2: publish a deliberately narrow view
CREATE OR REPLACE VIEW `analytics-prod.finance_published.monthly_revenue` AS
SELECT
DATE_TRUNC(order_date, MONTH) AS revenue_month,
region,
SUM(CASE WHEN order_status = ‘completed’ THEN net_revenue ELSE 0 END) AS net_revenue,
COUNTIF(order_status = ‘completed’) AS completed_orders
FROM `analytics-prod.enterprise_raw.orders`
WHERE order_date >= DATE ‘2024-01-01’
GROUP BY 1, 2;
The example deliberately omits customer identifiers. However, it is not automatically privacy-safe: a small region-month combination might still identify a single customer or reveal a commercially sensitive transaction. Evaluate minimum group sizes, suppression rules, permitted dimensions, and inference risks before approving a production view. Revenue recognition logic must be signed off by finance rather than inferred from a generic SQL example.
In the Google Cloud console, open the source dataset `enterprise_raw`, choose Sharing, then Authorize Datasets. Add `analytics-prod.finance_published`. This is a source-dataset ACL change, so it should be performed by an identity with the necessary dataset administration permissions and recorded as a controlled infrastructure change.
The `bq` command-line and API paths can also manage the authorization. For infrastructure as code, preserve other existing source-dataset access entries when applying changes; do not overwrite the entire policy with a minimal example. Consult the official documentation for the supported API structure and the exact role requirements.
Step 4: grant read access to the consumer group
Grant the finance reporting group the minimum read permissions on the published dataset or the approved views, as appropriate. Ensure the group has query-job creation rights in its designated billing project. Do not grant it `bigquery.dataViewer` on `enterprise_raw`, and do not give it permission to create or alter published views.
Step 5: test both allowed and denied behavior
Using an actual consumer identity, confirm that `SELECT * FROM analytics-prod.finance_published.monthly_revenue` succeeds. Then confirm that a direct query against `analytics-prod.enterprise_raw.orders` fails. Finally, verify that the consumer cannot create a new view in the publishing dataset or alter the SQL of an existing view. The negative tests are part of the acceptance criteria, not optional security theater.
Permissions: the most important design decision
Google documents `bigquery.datasets.get` and `bigquery.datasets.update` on the shared source dataset for adding or revoking authorized-dataset access. Creating or updating a view inside an authorized dataset has additional requirements, including relevant source-data read permissions and create or update permissions on the view. Google also distinguishes source-dataset authorization administration from day-to-day view updates. Validate the current permission matrix for the exact operation and tooling you use rather than assuming a single broad role is necessary.
This model makes view publishers privileged. They can potentially define new projections over source tables that the dataset has been authorized to access. Restrict publication rights to a small reviewed deployment path. Developers can propose SQL in version control without holding production source privileges.

Avoid project-level shortcuts
A project-wide Data Viewer grant may include source datasets outside the intended publication boundary. Inventory organization, folder, project, dataset, table, and view permissions, including group membership and service accounts. Remove conflicting broad grants before declaring the boundary effective. A successful query through a view proves functionality, not least privilege.
Use separate development and production paths
In development, engineers may need to read test source data or a sanitized fixture. In production, a deployment service account should publish approved views and the consumer identities should only query them. Keep separate datasets and controlled service accounts where needed. Avoid using production source access to compensate for inadequate test data.
Authorized datasets versus other BigQuery controls
An individual authorized view grants a specific view access to a source dataset. It is appropriate for a small number of stable published views or when each view needs distinct authorization. Authorized datasets are more efficient for a managed family of views, especially when repeated view additions would otherwise consume administrative effort and access-list entries.
Row-level access policies
A row access policy can restrict which rows a principal may see in a table. It is better suited to identity-dependent row restrictions than a single shared view whose SQL applies the same filter to every consumer. An authorized view can still implement a fixed row filter, but that does not make it a complete replacement for row-level security.
Column-level controls and data masking
Policy tags and data masking can protect columns according to permissions and data policies. A view can omit sensitive columns or expose a transformed representation, but that is a published schema contract, not a substitute for enterprise classification. Where sensitive columns are reused across many paths, centralized column policies may provide a more consistent safeguard.
Google’s data masking documentation describes the relevant policy mechanisms. Review interactions among views, policy tags, masking rules, and service identities in your environment before rollout.
Materialized tables and scheduled extracts
A physical curated table can be appropriate when a consumer needs a stable snapshot, different retention, a specific performance profile, or distribution outside the original warehouse. But it introduces a separate copy with refresh, storage, deletion, and consistency responsibilities. Authorized logical views avoid materializing another copy by default, though their queries still consume compute and depend on source availability.
Security and governance risks that require explicit controls
A safe view today can become unsafe tomorrow
Suppose a published view uses `SELECT *` from a source table. A newly added sensitive column may flow into the view depending on view schema behavior and subsequent changes. Explicit projection is safer. Require schema-change reviews and regression checks for newly introduced columns, renamed fields, and changes to join cardinality.
Aggregation can still leak information
Removing names does not automatically anonymize data. A single-store, single-day, single-product aggregation can disclose an individual’s transaction. Review sparse groups, rare categories, unique combinations, and filter interactions. For high-risk use cases, introduce minimum cell counts, broader aggregation, suppression, or another approved disclosure control.
Consumer exports are still possible
If a consumer can query a published view, they may be able to export or copy its results depending on their other permissions and organizational controls. Authorized datasets limit the source data visible through the view; they do not, by themselves, prevent redistribution of the authorized result. Review export destinations, connected applications, service-account privileges, audit logs, and applicable perimeter controls.
The source dataset’s authorized-dataset entry can remain unchanged while a published view’s SQL is modified. Therefore, an audit of authorization entries alone will miss a critical class of disclosure changes. Track SQL changes, publisher identities, deployment approvals, and resulting schema differences. A view change should be reviewed as both a data-contract change and an access-policy change.
Cross-region and replication boundaries matter
Google notes that authorized datasets can be created in different regions, but BigQuery does not support cross-region queries through this mechanism. Keep the relevant datasets in compatible locations and check secondary-replica limitations. Authorization is not a data movement feature, and it does not resolve data residency obligations.
A production-grade release and test checklist
Before the first department uses a published dataset, require evidence across five dimensions. First, functionality: approved queries return expected rows, columns, and financial totals. Second, security: direct source access and view modification are denied to consumers. Third, change control: a pull request, owner approval, deployment identity, and rollback instructions exist. Fourth, operations: query failures, unexpected schema changes, and access-denied spikes can be investigated. Fifth, accountability: each published view has a named business owner and an engineering owner.
Test representative consumer personas rather than only administrators: finance analyst, executive dashboard service account, contractor, and a revoked user. Include a newly created view in the test plan to prove that publishing rights are properly restricted. Also test an unauthorized attempt to reference a different sensitive source table from a published view.

For numerical correctness, reconcile curated aggregates to approved control totals at the intended grain. Check duplicate joins, null handling, late-arriving transactions, currency conversion, and status filters. Access controls can prevent raw-table exposure while still delivering incorrect business numbers.
Cost and performance: no free query acceleration
A standard logical view generally executes its SQL against underlying data when queried. Authorized-dataset status changes permissions, not the fundamental cost model. Repeated dashboard refreshes can still scan source data and consume BigQuery compute. Partition pruning, clustering, selective projection, query caching where applicable, and thoughtful modeling remain relevant.
Measure bytes processed, slot consumption, query duration, dashboard refresh frequency, and failure rates before and after publication. If a view joins large fact tables repeatedly, a governed materialized output or scheduled aggregate may be more suitable. Evaluate the security and freshness trade-offs alongside cost rather than assuming that virtual views are always cheaper.
Separate cost ownership from data ownership. A consumer may execute queries in a billing project different from the project hosting the source data. Document who funds repeated use and what workload limits apply. A technically secure reporting interface can still become operationally expensive if no one owns query behavior.
A 30-day rollout plan for a controlled pilot
Days 1–5: map the data and consumers
Select one department and one reporting domain. Inventory the source datasets, sensitive fields, existing broad IAM grants, BI service identities, approved metrics, and data locations. Name the source owner, publication owner, and business approver. Define what the consumer must not be able to see.
Days 6–10: design and build the publishing boundary
Create a dedicated published dataset in the correct location. Define two or three narrow views with explicit column lists and stable names. Document their grain, filters, metrics, refresh expectations, and owners. Establish a controlled path for SQL changes, with no direct production editing by consumers.
Days 11–15: configure permissions and prove denial
Authorize the published dataset on the source dataset. Grant consumer access only to approved views or the published dataset, as intended. Run positive and negative identity tests. Examine inherited IAM roles and service-account permissions for hidden raw access.
Days 16–22: validate business results and operational behavior
Reconcile key measures, test sparse-group disclosure risks, run dashboard queries, review cost, and exercise a breaking schema change. Confirm that a rejected deployment does not expose new fields. Capture query logs and document how to revoke access quickly.
Days 23–30: production approval and expansion decision
Approve the pilot only if both business and security owners accept the results. Record the dataset authorization, published view definitions, consumer groups, audit locations, and rollback process. Expand to another department only after evaluating whether it needs a distinct trust boundary.

Executive scorecard: what to measure
Track the percentage of reporting consumers without direct raw-dataset access, the share of published views with an owner and approved contract, the number of unreviewed SQL changes, negative-access-test pass rate, time to revoke an entitlement, query cost per reporting workload, and reconciliation exceptions. These are more useful governance measures than simply counting how many authorized datasets exist.
A strong pilot ends with a demonstrable statement: the department can answer its agreed questions, cannot directly query protected tables, cannot change the disclosure SQL, and has a documented route for requesting new metrics. If any of those conditions fails, the access model is incomplete.
Frequently asked questions
It is a dataset whose current and future views are authorized to access data in another dataset. Consumers can be granted access to the published views without receiving direct access to the underlying source dataset.
An authorized view is approved individually. An authorized dataset approves the group of views in that dataset, reducing repeated authorization work but increasing the importance of controlling who can create or modify views.
3. Can users query a published view without raw-table permissions?
Yes, when the source dataset has authorized the publishing dataset and the user has the necessary permissions on the view and to run query jobs. Verify this with the actual consumer identity.
No. The view’s SQL determines what it exposes. A careless view can still reveal sensitive columns, individual records, or identifiable aggregates. Classification and disclosure review remain necessary.
A restricted publishing role or deployment service account operating through review and approval. Ordinary reporting consumers should generally not have view creation or modification rights in that dataset.
They can be configured across projects where the required dataset authorization and IAM conditions are satisfied. Check location compatibility and all relevant source and consumer permissions.
A view can apply fixed row filters, but identity-dependent row restrictions may be better served by BigQuery row access policies or another explicitly designed entitlement layer.
Not inherently. A logical view still executes a query against source data. Performance and cost depend on SQL design, data layout, caching behavior, workload, and billing model.
9. What happens if a source schema changes?
The published view may fail, return changed results, or require a controlled update. Use explicit projections, schema monitoring, regression tests, and owner approval for changes to sensitive or business-critical fields.
10. How do we revoke access quickly?
Remove the relevant consumer’s access to the published dataset or view, or revoke the publishing dataset’s authorization on the source if the entire boundary must be disabled. Test the effect of revocation on BI services and downstream workloads before an incident occurs.
Not automatically. Separate datasets when owners, sensitivity, consumers, or approval requirements differ. Group views when they genuinely share a trust boundary and publishing process.
12. What is the first thing to audit in an existing implementation?
Check whether consumers or BI service accounts still have broad raw-dataset access, and whether anyone outside the approved publishing process can create or edit views inside the authorized dataset.
The bottom line
BigQuery authorized datasets can make governed data sharing simpler by replacing many view-by-view authorizations with a managed publication boundary. They do not remove the need to classify data, approve SQL, enforce least privilege, validate business metrics, or monitor what is disclosed.
Start with one source domain and one consumer group. Define the approved questions, build narrow views, deny direct source access, test both positive and negative paths, and measure operational results. Expand only when the organization can prove that its publishing process is as controlled as its dataset permissions.
If your team is designing a BigQuery reporting architecture or separating raw data from departmental dashboards, Actiknow can help assess the data model, integration points, reporting needs, and practical governance controls. Discuss your reporting requirements with Actiknow.
Technical references
Google Cloud: Authorized datasets, including access direction, permissions, limits, and operational steps.
Google Cloud: Authorized views, for the individual-view alternative.
Google Cloud: BigQuery IAM resource access controls, for dataset and principal permissions.

