CertSafari
    Snowflake SnowPro Specialty: Native Apps· Lessons

    Domain 1 · Lesson 1/12

    Native App architecture: choosing the model, schema layout, limits and releases

    Given a set of requirements, design Native App Architecture.

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

    What you will be able to do

    • Choose between Secure Data Sharing, Declarative Sharing in the Native App Framework and a full Snowflake Native App for a given set of requirements
    • Decide whether an app should bundle provider content, request consumer objects through references, or do both
    • Plan the schema layout up front, separating data objects from logic objects and stateless code from persistent state
    • Identify the framework limitations that force a design change before anything is built
    • Decide whether a change ships as a new version, a patch, or needs no release at all

    Key concept

    Lightest model that meets the requirement — A provider picks the simplest distribution mechanism that delivers what consumers need. A share covers read-only data, Declarative Sharing covers data plus packaged logic without a setup script, and a full Native App is for setup-script logic, a Streamlit UI and access to consumer objects.

    1.Choosing between a share, Declarative Sharing and a full Native App

    A provider can get a product into another Snowflake account in three ways. The options differ in what they can carry and in how much the provider has to build and maintain. The first architecture decision is to pick the lightest one that meets the requirements, because the schema layout, the release process and the limits you hit all depend on it.

    Secure Data Sharing is the baseline. The provider grants objects to a share, and the consumer creates a read-only database from it. No data is copied, so shared data uses no consumer storage, and consumers pay only for the warehouse compute they use to query it. A share can carry tables, dynamic, external and Iceberg tables, regular, secure, materialized and semantic views, Cortex Search services, models and UDFs. It cannot carry procedural code: no stored procedures, notebooks, UI or install-time logic. Consumers can't write anything either, because every shared object is read-only. If consumers only need read access to a curated set of tables and views, use a share. Putting the same data inside an app just adds a package, a manifest and a release process to maintain.

    Declarative Sharing in the Native App Framework sits in the middle. It bundles tables, views, stored procedures, UDFs, Cortex Agents, streams, and workspaces that contain notebooks into one data product, and the provider defines all of it in a YAML manifest. The framework manages privileges and versioning, and there is no setup script to write or maintain. Choose it when the product is data plus some procedures or notebooks and the provider does not want setup-script code. The simplicity has limits. Object types outside the supported list can't be shared. Notebooks in a shared workspace can't reach external endpoints or consumer data, and consumers can't edit or copy the files. The provider gets no audit trail of how consumers use the data. An existing data share also cannot be migrated into a Declarative app.

    A full Snowflake Native App is worth building when the product needs something only a setup script can provide. Its application package holds data content, application logic, a manifest file and a setup script that runs when the app is installed or upgraded. The logic can include a Streamlit app, stored procedures, and functions written in Snowpark, JavaScript and SQL. The app can request references to objects in the consumer account, and the provider releases versions and patches over time. Apps are distributed through listings, which can be free or paid, on the Marketplace or as private listings. So if a requirement combines multi-step business logic, an interactive Streamlit UI and a listing the provider plans to monetize, the answer is a full Native App.

    What each distribution model can deliver
    RequirementSecure Data SharingDeclarative SharingFull Native App
    Read-only tables and viewsYesYesYes, through views the setup script creates
    UDFsYesYesYes
    Stored proceduresNoYesYes
    Streamlit UINoNot in the supported object listYes
    Setup scriptNoneNone requiredRequired
    Access to consumer objectsNoNo: notebooks can't reach consumer dataYes, through references declared in the manifest

    Checkpoint 1 of 9· Check yourself

    A provider wants to give consumer accounts a set of curated tables together with several stored procedures and notebooks that analyze them. The product needs no Streamlit UI and no access to consumer objects, and the team does not want to write or maintain a setup script. Which distribution model is the lightest one that meets these requirements?

    Checkpoint 2 of 9· Exam question

    A provider wants to distribute a curated set of raw tables and views to several consumer accounts. Consumers only need read access to the data itself, with no bundled business logic, UI, or procedural code. Which distribution model best fits this requirement?

    Checkpoint 3 of 9· Exam question

    A provider wants to share tables, views, and a handful of stored procedures and notebooks as one packaged data product, but wants to avoid writing and maintaining a setup script and prefers automatic privilege management and versioning. Which approach should the provider choose?

    Checkpoint 4 of 9· Exam question

    A provider is designing a data product that must run complex multi-step business logic, present an interactive Streamlit-based UI, and eventually be listed for monetized consumption on the Snowflake Marketplace. Which architecture should the provider select?

    Sources12345

    2.Provider-supplied content, consumer references, or both

    In a full Native App, the app runs in the consumer account but stays isolated from the consumer's objects unless access is granted (Provider/consumer security boundaries and data isolation). At design time this leaves one question: where does the data the app works on come from? There are three possible answers. The provider bundles it, the consumer supplies it, or the app combines both.

    Bundled provider content is granted to the application package, and every installed instance of the app shares it. Snowflake does not copy or snapshot it at install. The app reads the package on every query, so when the provider inserts rows into a shared table, every app sees them on its next query. Because shared content is not versioned, every version and patch of the app reads the same data. Consumer roles can't query this content directly. Only objects the app owns, such as views, procedures and functions, can read it. Bundling fits data the provider owns that is the same for every consumer, for example reference or enrichment data, because the provider can keep updating it in one place.

    Adding a schema and table to an application package so installed apps can read themsql
    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;

    References cover the opposite case, where the app has to work on data the consumer already has. The provider declares the references in the manifest file. After installation, the consumer binds each reference to one of their own objects by its fully qualified name. The provider writes code against a logical name and never needs to know the consumer's database, schema or object names. If a requirement says consumers bind their own tables at install time instead of the provider shipping copies of their data, use references. Many products need both: provider reference data bundled in the package, and the consumer's transactional tables bound as references.

    Checkpoint 5 of 9· Check yourself

    An enrichment app bundles a provider-owned reference table in its application package. Some consumers still run version V1 and others have upgraded to V2. The provider then inserts new rows into the shared table. What do the installed apps see?

    Checkpoint 6 of 9· Fill the gap

    This sample makes a schema and table in the application package readable by installed apps. Which privilege belongs in the first grant?

    GRANT  ?  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;

    Sources67

    3.Data objects, logic objects and the schema layout

    Both kinds of app make you decide on schemas before you build. In Declarative Sharing the rule is enforced. Data objects (tables and views) are shared by reference, so the consumer reads the provider's live object. Logic objects (UDFs, stored procedures and Cortex Agents) are shared by copy. The two kinds must live in separate schemas, for example a DATA_SCHEMA for tables and views and a LOGIC_SCHEMA for UDFs. A design that mixes a lookup table and the function that reads it in one schema has to be reorganized before it can ship. The manifest also requires each object to be named explicitly. Wildcards aren't allowed, schema mapping isn't supported, and overlapping schema names from multiple databases aren't allowed. Settle the database and schema names before you write the manifest.

    In a full Native App, the split is between stateless code and persistent state (Versioned schemas vs regular schemas). At design time, sort every planned object into one of two groups. Procedures, functions and the views that expose shared data are stateless and belong in a versioned schema, so each version carries its own definitions. Configuration tables, and data the app collects while it runs, must survive upgrades, so they belong in a normal schema that the setup script creates only if it doesn't already exist. If a stateful table ends up in the versioned schema, or a procedure ends up in the stateful schema, upgrades will go wrong.

    Setup script: a proxy view over shared content, created in a versioned schema and granted through an application rolesql
    CREATE APPLICATION ROLE app_user;
    
    CREATE OR ALTER VERSIONED SCHEMA inst_schema;
    GRANT USAGE ON SCHEMA inst_schema
      TO APPLICATION ROLE app_user;
    
    CREATE VIEW IF NOT EXISTS inst_schema.shared_view
      AS SELECT c1, c2, c3, c4
      FROM shared_schema.shared_table;
    
    GRANT SELECT ON VIEW inst_schema.shared_view
      TO APPLICATION ROLE app_user;

    The example uses three layers. shared_schema sits in the application package and holds unversioned data. inst_schema is versioned and holds the view each version exposes. The application role is how consumers reach that view. Because the view lists its columns explicitly, a column the provider later adds to shared_table stays hidden until a release updates the view. Snowflake recommends putting row access or masking policies on these proxy views rather than on the shared tables, so a policy can't be changed after installation and running code keeps the policies of its own version during an upgrade.

    Checkpoint 7 of 9· Fill the gap

    In a full Native App, the setup script below exposes shared content through a proxy view, so each app version carries its own view definition. Which keyword completes the schema declaration?

    CREATE APPLICATION ROLE app_user;
    
    CREATE OR ALTER  ?  SCHEMA inst_schema;
    GRANT USAGE ON SCHEMA inst_schema
      TO APPLICATION ROLE app_user;
    
    CREATE VIEW IF NOT EXISTS inst_schema.shared_view
      AS SELECT c1, c2, c3, c4
      FROM shared_schema.shared_table;
    
    GRANT SELECT ON VIEW inst_schema.shared_view
      TO APPLICATION ROLE app_user;

    Sources386

    4.Framework limits that change the design

    Some framework limits do more than add a footnote. They take a whole design option off the table, so check them against the requirements before you choose an architecture.

    Object support. Native Apps don't support temporary tables or stages, so staging work needs permanent objects in a schema the app manages. Tables shared in a package cannot be temporary, volatile or transient. Their virtual columns and policies, and any view definition, cannot call Java, Python or JavaScript, which rules out policy logic written in those languages. Storage lifecycle policies and Snowflake ML functions such as Top Insights aren't supported. Some Streamlit features are unsupported as well.

    Behaviour in the consumer account. Functions that policies often use, such as CURRENT_USER, behave differently once the app is installed in a consumer account. A policy that passes every test in the provider account can therefore fail for consumers, which is another reason to define policies on proxy views in the setup script. Shared content is visible only to objects the app owns, so every consumer-facing path has to go through something the setup script creates and grants.

    Operations and reach. Native Apps don't support failover. An application package cannot be added to a replication or failover group, so business continuity has to come from somewhere else. Sharing external or Iceberg tables blocks Cross-Cloud Auto-Fulfillment, which means publishing the listing in each region separately, and it can add egress costs if the object store sits in a different region. Government regions only allow listings within the provider's organization, DoD regions are not supported, and VPS deployments need Native Apps enabled by Snowflake Support and support only private listings.

    Limits and the design change each one forces
    LimitDesign consequence
    No temporary tables or stagesIntermediate results go in permanent objects owned by the app
    No failover or replication groups for packagesBusiness continuity can't rely on replicating the application package
    External or Iceberg tables in the packageNo Cross-Cloud Auto-Fulfillment; publish the listing in each region
    Maximum of 15 compute pools per appContainer workloads have to fit within that pool budget
    Declarative: 10,000 objects in shared content, no wildcardsEvery object is listed explicitly in manifest.yml

    Checkpoint 8 of 9· Match them up

    Match each Native App Framework limit to the design change it forces.

    Tap a term, then the definition that fits it.

    Sources56

    5.New version or patch

    Before deciding between a version and a patch, ask whether the change needs a release at all. New or updated rows in shared data content reach every installed app on its next query. A release is needed only when the app's own code or object definitions change, and the size of that change sets the type of release.

    A patch is for small updates to an existing version, with security fixes as the typical case. A fixed security bug in a published version, or a view definition updated so it exposes a column that was just added, both fit within a patch. Consumers stay on the version they already run and pick up the fix. A new version is for major updates: new features and changed functionality. A large feature set that changes how the app behaves ships as a new version, not as a series of patches.

    Releases are limited in three ways, and each affects planning. First, each release channel holds at most two versions at a time. Adding a third means making sure every consumer has upgraded off one version, removing it from the channel, and only then creating the new one. Second, a version can have many patches, but patches can never be dropped. Third, every version and every patch carries its own manifest file and setup script, so even a one-line patch ships a complete, working setup script.

    Checkpoint 9 of 9· Check yourself

    Patch 3 of version V2 is live in the DEFAULT release channel. It contains a small bug in a stored procedure, and consumers on V2 are already running it. What is the correct way to deal with the bad patch?

    Sources96

    Sources

    (9)

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

    1. 1.
      “The only charges to consumers are for the compute resources (i.e. virtual warehouses) used to query the imported data.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “All database objects shared between accounts are read-only”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “User-defined functions (UDFs) (secure and non-secure)”
      ↩︎ Exam trap 1
      “User-defined functions (UDFs) (secure and non-secure)”
      ↩︎ Prediction
    2. 2.
      “the framework handles privilege management, object resolution, and versioning automatically, with no setup script required.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “the framework handles privilege management, object resolution, and versioning automatically, with no setup script required.”
      ↩︎ Key concept
      “the framework handles privilege management, object resolution, and versioning automatically, with no setup script required”
      ↩︎ Checkpoint
    3. 3.
      “All other object types are not supported for sharing in Declarative Sharing in Native Apps.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “Notebooks in a shared workspace can’t access external endpoints or consumer data when running in consumer accounts.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “Migration support for switching from data shares to Declarative Sharing in the Native App framework is unavailable.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “You must use separate schemas for data objects (shared by reference: tables and views)”
      ↩︎ Data objects, logic objects and the schema layout
      “logic objects (shared by copy: UDFs, stored procedures, Cortex Agents)”
      ↩︎ Data objects, logic objects and the schema layout
      “Object names must be explicitly specified; wildcard or regular expression matching is not supported.”
      ↩︎ Data objects, logic objects and the schema layout
      “You must use separate schemas for data objects (shared by reference: tables and views)”
      ↩︎ Exam trap 3
    4. 4.
      “The business logic of an application can include a Streamlit app, stored procedures, and functions written using Snowpark API, JavaScript, and SQL.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
    5. 5.
      “A maximum of 15 compute pools per application is allowed.”
      ↩︎ Choosing between a share, Declarative Sharing and a full Native App
      “Temporary tables or stages are not supported.”
      ↩︎ Framework limits that change the design
      “Snowflake Native Apps do not support failover for business continuity.”
      ↩︎ Framework limits that change the design
      “Department of Defense (DoD) regions are not supported.”
      ↩︎ Framework limits that change the design
      “Only private listings are supported for applications published inside the VPS.”
      ↩︎ Framework limits that change the design
    6. 6.
      “Data content that providers share with an application package is shared across all installed instances of the app.”
      ↩︎ Provider-supplied content, consumer references, or both
      “Snowflake doesn’t copy or snapshot shared content when a consumer installs or upgrades an app.”
      ↩︎ Provider-supplied content, consumer references, or both
      “Roles in the consumer account can’t query shared content directly.”
      ↩︎ Provider-supplied content, consumer references, or both
      “each version of the Snowflake Native App contains only the definition of the view for that version”
      ↩︎ Data objects, logic objects and the schema layout
      “Snowflake recommends that providers define policies on the proxy views that are specified in the setup script.”
      ↩︎ Data objects, logic objects and the schema layout
      “View definitions or virtual columns associated with them such as policies cannot contain calls to Java, Python, or JavaScript.”
      ↩︎ Framework limits that change the design
      “behave differently in the context of an app installed in a consumer account”
      ↩︎ Framework limits that change the design
      “Cross-Cloud Auto-Fulfillment is not supported for apps that share external or Iceberg tables.”
      ↩︎ Framework limits that change the design
      “To expose new columns, create a new version or patch of the app that updates the view definition.”
      ↩︎ New version or patch
      “Shared data content is not versioned, which means that all versions of an app use the same data.”
      ↩︎ Exam trap 2
      “Because shared content isn't versioned, all versions and patches of an app see the same data.”
      ↩︎ Checkpoint
      “the app sees the change the next time that it queries the object, without an upgrade”
      ↩︎ Prediction
    7. 7.
      “A provider defines the references that the app requests in the manifest file.”
      ↩︎ Provider-supplied content, consumer references, or both
      “A reference allows a provider to create the app without having to know the specific name of the object”
      ↩︎ Provider-supplied content, consumer references, or both
    8. 8.
      “These types of objects must reside in a normal database schema and they should be created to persist during initial installation and upgrades.”
      ↩︎ Data objects, logic objects and the schema layout
    9. 9.
      “Unlike versions, patches should only contain small updates such as security fixes.”
      ↩︎ New version or patch
      “Versions generally introduce new features and changed functionality for an app.”
      ↩︎ New version or patch
      “each release channel only allows two versions of an app at a time.”
      ↩︎ New version or patch
      “Each version and patch must have its own manifest file and setup script.”
      ↩︎ New version or patch
      “Patches cannot be dropped.”
      ↩︎ Exam trap 4
      “Although a release channel can only contain two versions at one time, a single version can have multiple patches. Patches cannot be dropped.”
      ↩︎ Checkpoint

    Ready to test yourself?

    Practise the 38 questions on this subdomain.

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