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.
| Requirement | Secure Data Sharing | Declarative Sharing | Full Native App |
|---|---|---|---|
| Read-only tables and views | Yes | Yes | Yes, through views the setup script creates |
| UDFs | Yes | Yes | Yes |
| Stored procedures | No | Yes | Yes |
| Streamlit UI | No | Not in the supported object list | Yes |
| Setup script | None | None required | Required |
| Access to consumer objects | No | No: notebooks can't reach consumer data | Yes, 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?
A plain share cannot carry stored procedures or notebooks. Declarative Sharing bundles tables, views, stored procedures, UDFs and notebooks into one product without a setup script, so a full Native App would only add overhead the provider does not need.
“the framework handles privilege management, object resolution, and versioning automatically, with no setup script required”Source: docs.snowflake.com
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?
Correct answer: A — Secure Data Sharing
- A. Secure Data Sharing is correct because it is built for pure data-only distribution of tables and views without any packaged application logic, making it the lowest-cost and lowest-complexity option here.
- B. A full Native App with a setup script is incorrect because writing and maintaining setup script logic is unnecessary overhead when only raw tables and views need to be shared.
- C. Snowpark Container Services apps are incorrect because they exist to package containerized compute and services, which is far more complexity than a data-only distribution needs.
- D. Declarative Sharing is incorrect for this case because, while simpler than a full app, it exists to bundle code objects like notebooks or procedures alongside data, which is not required here.
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?
Correct answer: B — Declarative Sharing in the Native App Framework
- A. Secure Data Sharing is incorrect because it does not support bundling stored procedures or notebooks as shared code objects.
- B. Declarative Sharing is correct because it lets the provider define data and code objects like notebooks and procedures in a YAML manifest, with Snowflake automatically handling privilege management and versioning instead of a setup script.
- C. A full Native App with a setup script is incorrect because it requires exactly the setup script maintenance the provider wants to avoid, even though it could technically bundle the same objects.
- D. A container-based Native App is incorrect because it targets containerized services and workloads, which is unnecessary complexity for sharing procedures and notebooks.
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?
Correct answer: C — A full Snowflake Native App
- A. Secure Data Sharing is incorrect because it has no mechanism for bundling interactive UI components or complex procedural logic.
- B. Declarative Sharing is incorrect here because, while it can bundle some code objects, it is designed for simpler data-plus-code products and does not target rich interactive Streamlit experiences with monetized listings the way a full app does.
- C. A full Native App is correct because it supports setup scripts, stored procedures, embedded Streamlit UIs, and Marketplace listings with monetization, matching every stated requirement.
- D. A direct share without a listing is incorrect because it provides no path to Marketplace monetization or bundled application logic.
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.
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?
Bundled content is not copied or snapshotted, and it is not versioned. Each app reads the package every time it queries, so every version and patch sees the same live data without an upgrade.
“Because shared content isn't versioned, all versions and patches of an app see the same data.”Source: docs.snowflake.com
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;The installed app needs USAGE on the schema before SELECT on the table inside it is any use, so both the schema and the table are granted to the share in the application package.
Source: docs.snowflake.com3.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.
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;Proxy views are stateless, so they belong in a versioned schema. That way each version of the app holds only its own view definition, which matters during upgrades. Persistent state such as configuration tables goes in a normal schema instead.
Source: docs.snowflake.com4.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.
| Limit | Design consequence |
|---|---|
| No temporary tables or stages | Intermediate results go in permanent objects owned by the app |
| No failover or replication groups for packages | Business continuity can't rely on replicating the application package |
| External or Iceberg tables in the package | No Cross-Cloud Auto-Fulfillment; publish the listing in each region |
| Maximum of 15 compute pools per app | Container workloads have to fit within that pool budget |
| Declarative: 10,000 objects in shared content, no wildcards | Every 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.
Each limit removes a design option. Without temporary objects, staging needs permanent tables. Without failover, the package can't be replicated. External or Iceberg tables block Cross-Cloud Auto-Fulfillment, so the listing must be published per region. Context functions behave differently once the app is installed, so a policy that works in the provider account can still fail for consumers.
“Cross-Cloud Auto-Fulfillment is not supported for apps that share external or Iceberg tables.”Source: docs.snowflake.com
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.
Make sure every consumer has upgraded off V1. After that, V1 can be removed from the release channel, V3 created, and the app upgraded. The two-version limit applies per release channel, not per application package.
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?
Patches can never be dropped, so the only way to fix a bad patch is another release. A small fix like this one is patch-sized. Removing V2 is not allowed while consumers still run it. Code changes are not live-read the way shared data is, so a release is needed.
“Although a release channel can only contain two versions at one time, a single version can have multiple patches. Patches cannot be dropped.”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.
“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.
“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.
“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.
“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“A listing can be either free or paid.”
↩︎ Choosing between a share, Declarative Sharing and a full Native App - 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.
“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.
“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.
“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.
“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