What you will be able to do
- Locate the provider and consumer boundaries of an installed Snowflake Native App and say what each side can see by default
- Protect provider data content and IP with secure views, proxy-view policies and redaction instead of per-consumer configuration
- Choose the narrowest privilege request for a design, preferring scoped references over broad account-level privileges
- Design an admin, user and read-only application role hierarchy that separates duties
- Identify the cross-account paths through which data can leave a consumer account and who must approve them
- Layer data protection strategies for an app, matching each control to data at rest, metadata exposure or data in motion
Key concept
Closed-by-default boundary — An installed app starts with no access to consumer data, and consumers start with no view into the app's objects. Each side opens only what it explicitly grants, using Snowflake RBAC: the consumer grants to the app, and the app grants to consumers through application roles.
1.Where the provider and consumer boundaries sit
A Snowflake Native App runs inside the consumer's account, next to the consumer's data, yet the code and data inside it belong to the provider. Two boundaries keep the two sides apart. The first stops the app reaching consumer data: by default the framework gives the app no access to consumer data. The second stops the consumer looking inside the app: by default the provider's intellectual property stays protected. Each owner can loosen its own boundary on purpose, and only through explicit grants under Snowflake role-based access control.
The consumer-facing boundary is stricter than most people expect. Once an app is installed, nobody in the consumer account holds privileges on the objects inside it, and that includes ACCOUNTADMIN. A consumer role can see an object only after the app grants a privilege on it to an application role and the consumer is given that role. If the app creates an object outside itself, such as a database, roles with MANAGE GRANTS can see that object.
Redaction backs up the grants. When a consumer looks at query profiles, query history, SHOW or DESCRIBE output, or ACCESS_HISTORY for activity the app generated, the framework hides the implementation detail. Function bodies are removed, the query profile for an app's stored procedure collapses to a single empty node, and the base tables behind views the app owns are redacted. Some context functions are blocked as well. Inside shared content, CURRENT_USER and CURRENT_ROLE return null.
| Direction | Default | How it is opened |
|---|---|---|
| App → consumer data | No access to consumer data | Consumer grants privileges or binds references to specific objects |
| Consumer → app objects | No privileges, even for ACCOUNTADMIN | App grants privileges to application roles, and the app owner grants those roles onward |
| Consumer → app metadata | Query text, function bodies and base tables are redacted | Not opened. Redaction is a framework guarantee |
A data protection strategy for an app stacks controls, and each control answers a different exposure. For provider data at rest, shared objects are read-only inside the app, only the provider can change them, and consumers reach them only through views the setup script installs. For consumer data, the protection is the closed default itself: the app sees only the objects the consumer binds or grants. For data in motion, traffic leaves over HTTPS with a valid TLS certificate, and the app never stores or requires a plain text customer secret. Pick the control by asking which of those three is exposed, because a strong control on one does nothing for another.
Metadata is the exposure that gets forgotten. Redaction covers query text and function bodies, but a grant can undo it. Granting MONITOR or OPERATE on a dynamic table to an application role lets the consumer read that table's metadata, which may reveal how the app is built, and a task shows up for a consumer only once OPERATE on it is granted to a role they hold. Treat every grant to an application role as a disclosure decision: give the role the data it needs and the narrowest privilege on supporting objects, then check what SHOW and DESCRIBE would now reveal.
Checkpoint 1 of 8· Check yourself
A consumer installs a Native App. They want the app to read their SALES table, and they want their analysts to query a results table that the app creates inside itself. What has to happen for both?
Both boundaries are closed by default. Each one opens only through an explicit grant from its own owner. The consumer opens access to its data. The app opens access to its objects through application roles. Even ACCOUNTADMIN has no privileges on objects inside the app.
“Both these accesses can happen only through explicit grants from the consumer account admin and the application (as configured by the provider), respectively.”Source: docs.snowflake.com
2.Isolating provider data content from consumers
Providers often ship reference data along with their code. To do that, they grant privileges on the data to the application package. Every installed instance then reads the same content live from the package. Snowflake takes no copy or snapshot at install, and the content is not versioned. Inside the app the data is read-only, and only the provider can change it.
GRANT USAGE ON SCHEMA app_package.shared_schema
TO SHARE IN APPLICATION PACKAGE app_package;
GRANT SELECT ON TABLE app_package.shared_schema.shared_table
TO SHARE IN APPLICATION PACKAGE app_package;Consumers never query shared tables directly. Only objects the app owns can read shared content, so the provider writes a secure view in the setup script and grants consumers access to that view. That view is the provider's enforcement point. Masking and row filtering go there, because tables and views that already carry row access, masking or tag-based policies cannot be shared into the package at all. Policies on the proxy view also stay fixed. Their definition cannot be changed after installation, and code that is running during an upgrade keeps the policies that applied when its version was created.
Policies built on identity functions need testing in a consumer account. A policy that keys on CURRENT_USER can work in the provider account and then fail after a consumer installs the app, because inside shared content that function returns null.
Checkpoint 2 of 8· Check yourself
After granting SELECT on shared_table to the share in the application package, the provider hears that consumer analysts cannot query it. What design lets the analysts read this reference data?
Consumers never query shared tables directly. Only objects the app owns can read shared content. The provider exposes that content through an app-owned view granted to an application role, and the consumer then gives that role to the users who need it.
“the app can expose the data or objects to its users in the consumer account that the provider selects”Source: docs.snowflake.com
Checkpoint 3 of 8· Exam question
A provider wants to apply a data masking rule to a sensitive column that consumers should never see unmasked, regardless of which consumer account installs the app. Where should this boundary be enforced?
Correct answer: A — Inside the application package, using a secure view or masking policy owned by the provider
- A. Enforcing the masking inside objects the provider owns and ships as part of the package guarantees the rule applies consistently to every consumer, since the provider controls that boundary. This is the correct place to enforce a rule that must never depend on consumer configuration.
- B. Relying on each consumer to configure the same masking independently after install is fragile and inconsistent, and defeats the goal of a guaranteed, provider-controlled rule.
- C. The manifest declares requestable privileges, not the enforcement logic of a masking rule; a privilege grant alone does not implement or guarantee masking behavior.
- D. Delegating enforcement to the consumer's own administrative role means the provider loses control over whether the rule is actually applied, undermining the requirement that it always applies.
3.Least privilege in privilege requests
An app declares what it needs in its manifest, and the consumer approves it (Requesting privileges in the manifest (including global privileges)). The design decision is how little to ask for. Snowflake's security requirements make two separate demands. Every privilege the app needs, on every object, plus every API integration, has to be listed in the manifest. And the app should ask for only the minimum set it needs to work. A privilege missing from the manifest cannot be requested at runtime, and a privilege added "in case a later version needs it" breaks the minimum rule.
A reference gives the narrowest grant. Rather than asking for broad rights over a consumer database, the app defines a reference in the manifest that names an object type and the exact privileges it needs. The consumer then binds one object of their own to it. An app that only reads one table should request a reference with SELECT and nothing else.
references:
- consumer_table:
label: "Consumer table"
description: "A table in the consumer account that exists outside the APPLICATION object."
privileges:
- INSERT
- SELECT
object_type: TABLE
multi_valued: false
register_callback: config.register_single_reference| Object type | Privileges allowed |
|---|---|
| TABLE | SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES |
| VIEW | SELECT, REFERENCES |
| WAREHOUSE | MODIFY, MONITOR, USAGE, OPERATE |
| SECRET | USAGE, READ |
| EXTERNAL ACCESS INTEGRATION | USAGE |
Neither OWNERSHIP nor ALL PRIVILEGES appears in that table. A reference is built for a specific purpose. Account-level privileges carry more weight. Privileges granted automatically at install or upgrade cannot be revoked afterwards, so each one is a lasting commitment the consumer makes. Choose an account-level privilege only when the app has to create something itself, such as its own warehouse. When the consumer already owns the object, prefer a reference. When the access is external, prefer an app specification the consumer can decline.
The listing has a different job from the manifest. The manifest declares privileges and API integrations. The listing tells consumers what the app does with that access: every internet endpoint it calls, every external function, and any consumer data it logs or uses to train AI models.
Checkpoint 4 of 8· Check yourself
Your app's first version only reads one table in the consumer account. A product manager wants the v1 manifest to also request CREATE DATABASE and CREATE WAREHOUSE, so that features planned for v2 won't need new consumer consent. Which design meets Snowflake's requirements?
An app must ask for only the minimum privileges it needs, and the narrowest grant is a reference with just SELECT. Privileges requested 'just in case' break that rule. Automatically granted privileges cannot be revoked, so the consumer is stuck with them. A reference cannot carry ALL PRIVILEGES, and a privilege missing from the manifest cannot be requested at runtime.
“Apps should only ask for the minimum set of privileges needed for the app to function.”Source: docs.snowflake.com
Checkpoint 5 of 8· Exam question
A provider is building a Native App that only needs to read data from a single table shared via a reference at runtime. Which manifest privilege request best reflects the principle of least privilege for this use case?
Correct answer: A — Request only the SELECT privilege needed for the query the app performs on the referenced object
- A. Requesting only SELECT matches the app's actual read-only need on the referenced object, which is the minimal privilege footprint required. This is the correct least-privilege design because it grants exactly what the workload uses and nothing more.
- B. OWNERSHIP grants far more than reading rights, including the ability to modify, drop, or transfer the object, which is unnecessary and risky for a read-only workload. Requesting it purely for future flexibility violates least privilege.
- C. Account-level administrative access vastly exceeds the scope of a single-table read and would expose the consumer to unnecessary risk. Requesting broad access to avoid future prompts is the opposite of least privilege.
- D. A blanket privilege across the entire database is far broader than the single referenced table the app actually queries. This kind of over-provisioning is a common anti-pattern reviewers should flag.
Checkpoint 6 of 8· Exam question
In the Native App Framework, when must a provider declare the privileges an app may request from a consumer?
Correct answer: A — All requestable privileges must be declared in the manifest file before the app can request them at runtime
- A. The manifest is the upfront declaration surface for requestable privileges, and consumers rely on it to review what the app can ask for before approving anything. This upfront declaration is what enables informed consumer review.
- B. Undeclared runtime privilege requests would bypass consumer visibility entirely, which contradicts the framework's transparency requirements. The manifest declaration must exist first.
- C. Privileges requested from consumers after installation, not just those used during setup, must also be declared in the manifest. Limiting declaration to setup-time needs would leave later requests undisclosed.
- D. A README is documentation, not an enforced declaration mechanism that Snowflake validates. The manifest file is the actual structured location Snowflake reads for privilege declarations.
4.Designing an application role hierarchy
The provider decides which slices of the app consumers can use by defining application roles in the setup script (Application roles). Separating duties means giving each role only the objects its job needs, then nesting the roles so that the senior role inherits the junior one's grants without repeating them. A common layout has three levels. A read-only role can query selected views. A user role can also run the app's functions. An admin role can also call configuration procedures.
CREATE APPLICATION ROLE admin;
CREATE APPLICATION ROLE user;
GRANT APPLICATION ROLE user TO APPLICATION ROLE admin;
CREATE OR ALTER VERSIONED SCHEMA app_code;
GRANT USAGE ON SCHEMA app_code TO APPLICATION ROLE admin;
GRANT USAGE ON SCHEMA app_code TO APPLICATION ROLE user;
CREATE OR REPLACE PROCEDURE app_code.config_app(...)
GRANT USAGE ON PROCEDURE app_code.config_app(...)
TO APPLICATION ROLE admin;Only the app can build this hierarchy. Granting one application role to another works only inside an installed application, normally in the setup script, so the consumer cannot rearrange it. What the consumer controls is who receives each role. Application roles go automatically to the role that owns the app instance, which is the role used to install it, and that owner hands roles out to account roles. For example, the owner might give admin to a platform team and the read-only role to analysts. If the owner grants with WITH GRANT OPTION, the recipient can pass the role on again.
Two limits shape the design. An application role cannot own objects, so its only purpose is to let consumers reach objects inside the app. Application roles are also not versioned, which means dropping one or revoking its grants can break the version currently running. Get the hierarchy right before release rather than reshuffling it in a patch.
Checkpoint 7 of 8· Check yourself
At a customer site, the app's setup script created three application roles: read_only, user and admin. It nested user under admin, but it did not nest read_only under user. The customer's ACCOUNTADMIN wants anyone holding user to also inherit read_only's view grants. What can the customer do?
Granting one application role to another works only inside the installed app, normally in its setup script, so the provider decides how roles nest. The consumer decides who receives each role by granting roles to account roles. Application roles also cannot own objects.
“Both these accesses can happen only through explicit grants from the consumer account admin and the application (as configured by the provider), respectively.”Source: docs.snowflake.com
Sources2
5.Cross-account data paths and who approves them
Data crosses accounts in two directions, and they are controlled differently. Inbound, the provider's data content reaches every installed instance through the application package, and the app's own views gate it. Outbound is the riskier direction. When an app sends consumer data back to the provider or to another Snowflake account through shares and listings, the consumer must approve an app specification that names the target accounts and auto-fulfillment settings. Holding CREATE SHARE or CREATE LISTING lets the app create those objects, but it cannot send data anywhere until that approval is given.
Snowflake treats unapproved outbound data flow as harm. Its security requirements forbid functionality that results in unauthorized data egress, data leakage or data loss. They also forbid cutting consumers off from their own data, unless that is part of the app's advertised function, such as masking. Snowflake scans application packages before they are shared externally, but the scan does not replace review by the consumer. A connector that sends data to an ERP system may have a legitimate reason to do so, and the consumer's administrator still needs to check both the business justification and the destination before approving.
Checkpoint 8 of 8· Check yourself
An app's manifest requests CREATE SHARE and CREATE LISTING, and both are granted automatically at install. Its app specification asks to send usage data to three target accounts. The consumer's administrator approves two of them and declines the third. What should happen next?
CREATE SHARE and CREATE LISTING only let the app create the objects. Data reaches a target account only after the consumer approves the app specification, and that approval can be partial. The app must keep working with the accounts that were approved. The package scan does not replace the consumer's review.
“A data sharing request might be declined or only partially approved for some target accounts but not others. The app should gracefully handle these cases.”Source: docs.snowflake.com
Sources
(9)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.https://docs.snowflake.com/en/developer-guide/native-apps/consumer-guide-responsibilityOfficial docs
“Such relaxation happens through explicit actions and under Snowflake Role-Based Access Controls (RBAC).”
↩︎ Where the provider and consumer boundaries sit“the target of its external access (such as an ERP system) must be scrutinized by a consumer account administrator or their delegate before approval.”
↩︎ Cross-account data paths and who approves them“The Snowflake Native App Framework intentionally restricts what a Snowflake Native App can see and do by default.”
↩︎ Key concept“Both these accesses can happen only through explicit grants from the consumer account admin and the application (as configured by the provider), respectively.”
↩︎ Checkpoint“the app can expose the data or objects to its users in the consumer account that the provider selects”
↩︎ Checkpoint“Both these accesses can happen only through explicit grants from the consumer account admin and the application (as configured by the provider), respectively.”
↩︎ Checkpoint - 2.
“By default, the consumer has no privileges on objects created within the app.”
↩︎ Where the provider and consumer boundaries sit“The setup script can define an application role, such as READ_ONLY, to provide restricted access to select areas of data within the app.”
↩︎ Designing an application role hierarchy“Application roles cannot be granted ownership of objects.”
↩︎ Designing an application role hierarchy“Application roles defined in the setup script are automatically granted to the role owning the app instance.”
↩︎ Designing an application role hierarchy - 3.
“they are not allowed to view the objects within the application object unless a provider grants permissions on the objects using application roles.”
↩︎ Where the provider and consumer boundaries sit“Shared objects are read-only for an application object and installed Snowflake Native App.”
↩︎ Where the provider and consumer boundaries sit“Providers should use caution when granting the MONITOR or OPERATE privilege on dynamic tables to an application role.”
↩︎ Where the provider and consumer boundaries sit“Tables with defined policies (row access, masking, tag based, etc.) cannot be shared.”
↩︎ Isolating provider data content from consumers - 4.
“Apps must not store or require any plain text customer secrets.”
↩︎ Where the provider and consumer boundaries sit“Any communication between the app and the Internet should be over an HTTPS connection with a valid TLS certificate.”
↩︎ Where the provider and consumer boundaries sit“All apps must provide the following information in the manifest file: All privileges required by the app on all objects. All API integrations.”
↩︎ Least privilege in privilege requests“Unauthorized data egress, data leakage, and/or data loss”
↩︎ Cross-account data paths and who approves them“Apps should only ask for the minimum set of privileges needed for the app to function.”
↩︎ Exam trap 2“Apps should only ask for the minimum set of privileges needed for the app to function.”
↩︎ Checkpoint - 5.
“a provider creates a secure view in the setup script of an application package and grants the consumer access to the secure view.”
↩︎ Isolating provider data content from consumers“it might not work correctly in the consumer account after the consumer installs the app.”
↩︎ Isolating provider data content from consumers“Defining policies on the proxy views ensures that the definition of the policies cannot be changed after an app is installed.”
↩︎ Exam trap 1“Snowflake recommends that providers define policies on the proxy views that are specified in the setup script.”
↩︎ Prediction - 6.
“This example defines a reference named consumer_table that requires the INSERT and SELECT privileges on a table in the consumer account.”
↩︎ Least privilege in privilege requests - 7.
“After privileges are automatically granted during installation or upgrade, these privileges cannot be revoked.”
↩︎ Least privilege in privilege requests“to share data with target accounts, consumers must also approve the app specification that specifies the target accounts and auto-fulfillment settings.”
↩︎ Cross-account data paths and who approves them
Also cited
“Granting an application role to another application role can only be performed within the context of an installed application”
↩︎ Exam trap 3“A data sharing request might be declined or only partially approved for some target accounts but not others. The app should gracefully handle these cases.”
↩︎ Checkpoint