CertSafari
    Snowflake SnowPro Specialty: Native Apps· Lessons

    Domain 1 · Lesson 2/12

    Native App security boundaries, data isolation and least privilege

    Given a scenario, design security and privilege strategies.

    17 min read
    11% of exam
    9 sources
    Published 21 Oct 2026
    Docs as of 18 Oct 2026

    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.

    What each side can see by default, and how that changes
    DirectionDefaultHow it is opened
    App → consumer dataNo access to consumer dataConsumer grants privileges or binds references to specific objects
    Consumer → app objectsNo privileges, even for ACCOUNTADMINApp grants privileges to application roles, and the app owner grants those roles onward
    Consumer → app metadataQuery text, function bodies and base tables are redactedNot 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?

    Sources1234

    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.

    Sharing a schema and table into an application packagesql
    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?

    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?

    Sources53

    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.

    A manifest reference that asks for two privileges on one consumer tableyaml
    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
    Privileges a reference can carry, by object type (excerpt)
    Object typePrivileges allowed
    TABLESELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES
    VIEWSELECT, REFERENCES
    WAREHOUSEMODIFY, MONITOR, USAGE, OPERATE
    SECRETUSAGE, READ
    EXTERNAL ACCESS INTEGRATIONUSAGE

    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?

    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?

    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?

    Sources467

    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.

    Setup script: user nested under admin, with a configuration procedure only admin can runsql
    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?

    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?

    Sources741

    Sources

    (9)

    Every claim above is drawn from one of these pages, quoted as it was written on the date shown.

    1. 1.
      “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. 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. 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. 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. 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. 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. 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

    Continue to part 2 of 2

    External access in Native Apps: network rules, EAIs and secrets

    Spotted a mistake, or was something unclear? Tell us.