Snowflake Native Apps 101—Build & Monetize Data Apps (2024)

Building and deploying data applications often comes with unnecessary complexity. Snowflake has significantly reduced this by introducing Snowflake Native Apps. Snowflake Native Apps allow you to build, run, and monetize data apps directly within the Snowflake ecosystem. No external integrations. No infrastructure headaches. Snowflake previously supported Connected Apps, which operated outside Snowflake, connected via APIs, and required manual data movement. Native Apps, by contrast, run entirely within Snowflake, leveraging its secure and scalable infrastructure. They’re built using the Snowflake Native App Framework, allowing you to develop secure, scalable, and integrated Snowflake apps that leverage Snowflake’s environment without leaving the Snowflake platform.

In this article, we will discuss the features, benefits, and inner workings of Snowflake Native Apps, and walk you through the step-by-step process of creating a Snowflake Native App and publishing and monetizing your Native Apps through the Snowflake Marketplace.

What Are Snowflake Native Applications?

Snowflake Native Apps are applications built using the Snowflake Native App Framework, which allows developers to create, test, and deploy applications directly within Snowflake's Data Cloud. These Native Apps leverage Snowflake's core features like stored procedures, user-defined functions (Snowflake UDFs), and the Snowpark API, all while keeping the data secure by running the code on your data stored in Snowflake. Native apps are available on the Snowflake Marketplace. You can discover and install them quickly, just like downloading an app on your smartphone.

Key Technical Characteristics of Snowflake Native Apps

1) Native Integration with Snowflake Services

Snowflake Native Apps work directly with Snowflake's core services. They use stored procedures, user-defined functions (Snowflake UDFs UDFs), and the Snowpark API, making them efficient and seamless.

2) Simplified Development and Testing

You can build Snowflake Native Applications using the Snowflake Native App Framework. Snowflake Native App Framework streamlines development and testing. You can create, test, and deploy Snowflake apps within Snowflake, reducing development time.

3) Monetization via Snowflake Marketplace

Providers can list and sell Snowflake apps in the Snowflake Marketplace. Consumers install these apps directly into their Snowflake accounts, simplifying deployment and making app monetization straightforward.

4) Security and Governance

Snowflake Native Applications don’t transfer data outside the platform. Providers can package their logic securely, protecting intellectual property. Users maintain control of access permissions, with data security managed by Snowflake’s encryption and governance features.

5) Data Sharing

Snowflake Native Apps leverage Snowflake’s secure data sharing. Apps can access shared datasets without creating duplicates or requiring data to leave the user’s Snowflake account.

6) Advanced Feature Support

Snowflake Native Applications use Snowflake features like:

• User-Defined Functions (Snowflake UDFs)
• Stored Procedures
• Snowpark

7) Versioning and Patching

Snowflake Native App Framework supports versioning and patching, allowing you to manage updates easily. This keeps your apps up to date.

8) Streamlit Integration

You can integrate your apps with Streamlit, which allows you to create interactive dashboards within Snowflake. While the integration is still evolving, it supports embedding visualizations in your apps for end-user analytics.

9) Encapsulation in Application Packages

Snowflake Native Apps are bundled into packages containing all necessary components (e.g., data content, application logic, metadata, and setup scripts). This makes deployment simple and reduces compatibility issues.

10) Source Control and Tool Integration

You can integrate with external tools like IDEs, CI/CD pipelines, and source control systems. This flexibility helps teams adopt DevOps practices when developing Snowflake Native Applications.

11) AI and ML Workflows

Snowflake Native Applications support machine learning and AI tasks through Snowpark. You can integrate external ML libraries, process training data, and deploy models directly within Snowflake.

12) Cross-Cloud Deployment (AWS + Azure + with limitations on GCP)

Snowflake Native Applications are compatible with multiple clouds (AWS, Azure, and limit on GCP). This feature enables users to run apps across different infrastructures, though GCP support has limitations.

Want to take Chaos Genius for a spin?

It takes less than 5 minutes.

Start Free Trial

Enter your work email

Enter your work email

Start Free Trial

What Are the Benefits of Snowflake Native Apps — For Providers?

Snowflake Native Apps offer significant advantages for providers looking to build, distribute, and monetize their applications within the Snowflake ecosystem. Here are some of the benefits:

➥ Simplified Development

Providers can use Snowflake's tools to build apps that leverage Snowflake’s high availability and scalability. This completely eliminates the need for separate infrastructure, reducing development overhead and speeding up time to market​.

Snowflake Native Apps run within customers' Snowflake accounts, meaning data stays within their environment, which minimizes the complexity of data integration and security management​.

➥ On-Platform Monetization Opportunities

Providers can easily sell and monetize their Snowflake apps directly within the Snowflake ecosystem via Snowflake Marketplace, bypassing the need for third-party systems.

➥ Easy Management

Since apps are hosted within Snowflake’s infrastructure, you don’t need to manage separate resources. Snowflake offers always-on availability, global reach, built-in governance, and secure operations.

➥ Data Protection

Snowflake Native Apps interact directly with the customer’s Snowflake account. This approach keeps customer data within their environment, reducing security risks and compliance burdens. You avoid the complexity of managing sensitive data, as Snowflake’s internal security and governance capability can handle it for you.

➥ Zero Infrastructure Management and Lower Operational Costs

Traditional Snowflake apps often require providers to pay for their own compute and storage. With Snowflake Native Applications, you leverage the customer’s compute resources, reducing your operating costs and improving profit margins.

➥ Access to New Customers

Snowflake Marketplace gives you exposure to a global Snowflake customer base. Here, customers can find, test, and purchase your apps. This built-in distribution network simplifies how you reach and onboard users while enabling seamless deployment directly into customer environments.

What Are the Benefits of Snowflake Native Apps — For Consumers?

Snowflake Native Apps offer significant advantages for end-users, enhancing their ability to integrate, utilize, and manage data applications seamlessly within the Snowflake ecosystem. Here are some of the key benefits of Native Snowflake apps for consumers:

➥ Quick and Easy Access

Consumers can easily search for Snowflake Native Applications on the Snowflake Marketplace or in private listings and directly install and use them with a single click.

➥ Secure Data Use 

Since Snowflake Native Applications run directly in the consumer’s Snowflake account, data does not need to leave the platform. This eliminates the risks associated with data transfers and ensures compliance with Snowflake’s robust governance and security controls.

➥ Enhanced Performance

Snowflake Native apps utilize the consumer’s Snowflake compute resources, which ensures optimal performance tailored to the existing workload. Consumers benefit from Snowflake’s underlying scalability and processing power, resulting in faster query execution and application responsiveness​.

➥ Streamlined Trial and Deployment

Consumers can easily test applications via trial periods. Transitioning from trial to full versions is simple, and data generated during the trial is retained for future use, making the adoption process seamless and risk-free.

➥ Simplified Application Management

Consumers can manage access privileges, event logging, and app-related tasks directly within their Snowflake account.

How Do Snowflake Native Applications Work?

Snowflake Native Applications leverage the Snowflake Native App Framework to build and deploy data-driven applications directly within the Snowflake ecosystem. These Snowflake apps harness Snowflake’s core features—secure data sharing, analytics, compute, and governance—enabling seamless integration and monetization, without requiring data to move outside the platform. The framework supports applications ranging from analytical tools to fully containerized services.

Snowflake Native App Framework allows:

• Providers to share data, business logic, and application interfaces (e.g., Streamlit apps, stored procedures) using Snowpark API, Python, SQL, and JavaScript.
• Applications to be listed as free or paid offerings on the Snowflake Marketplace or shared privately with select accounts.
• Developers to benefit from streamlined testing environments, version control via external repositories, and detailed logging for troubleshooting.
• Built-in support for structured and unstructured event logging to streamline troubleshooting and performance tracking.
• Integration with Streamlit to build interactive, user-friendly visual interfaces.

On top of that, the Snowflake Native Framework also provides an enhanced developer experience, including:

• A unified testing environment for app lifecycle management.
• Integration with version control systems for seamless code and resource management.
• Incremental app updates with versioning and patch support.

Snowflake Native Apps extend the functionality of features like Secure Data Sharing and Collaboration, ensuring providers can offer scalable, governed applications to other Snowflake users.

Architecture of the Snowflake Native App Framework

The architecture of the Snowflake Native App Framework operates on a provider-consumer model:

• Provider — Creates and shares data and application logic using the framework.
• Consumer — Installs and interacts with applications shared by providers.

Snowflake Native Applications are packaged as Application Packages, which contains the necessary logic, metadata, and configuration to deploy a Snowflake Native App. This includes:

• Manifest file: Configuration details, including setup script locations and versioning.
• Setup script: Contains SQL commands for installation and updates.

The provider publishes the Snowflake Native app via:

• Marketplace Listings — Accessible to all Snowflake users for broad distribution.
• Private Listings — Targeted sharing with specific accounts across regions.

Upon installation, Snowflake creates a corresponding database object for the app, which runs the setup script to establish necessary resources in the consumer’s account. Additional configurations like logging or privilege grants can be applied post-installation.

How do Snowflake Native Applications work with Snowpark Container Services?

For advanced use cases, Snowflake Native Applications can utilize Snowpark Container Services, which enable Snowflake apps to manage containerized workloads within Snowflake. This approach supports high-performance applications, such as machine learning and AI-driven analytics, without externalizing data.

Components unique to containerized Snowflake apps:

• Services specification file — Applications reference container images stored in the provider’s repository.
• Compute pool — A collection of virtual machine nodes where containerized workloads execute.

Features of Snowpark Container Services include:

• Support for AI/ML workloads with low latency.
• Persistent data and model storage close to compute resources for efficiency.
• Seamless deployment across GPU/CPU configurations.

Step-by-Step Guide to Create a Snowflake Native App

Now that we have covered the features, benefits, and inner workings/architecture of Snowflake Native Applications, let's dive into a step-by-step guide on how you can create a simple Snowflake Native App on Snowflake.

Before you start building a Snowflake Native App, make sure you meet these requirements:

Prerequisite:

• Snowflake CLI: Install the Snowflake CLI on your machine.
• Visual Studio Code: If you haven’t already installed VSCode, download it from here.
• ACCOUNTADMIN Role: Use the ACCOUNTADMIN role for all steps in this tutorial.
• Second Snowflake Account: If installing your app from a private listing, you need access to a second Snowflake account.
• Set a Current Warehouse: Use the USE WAREHOUSE command to specify the active warehouse.
• SQL Command Session: Run all SQL commands within the same session. The session context must remain consistent as the steps build on one another.

Let's kick off by covering the main pieces you'll be working with.

Application Package

Think of this as a container for your entire application. It holds:

• Shared data
• Application logic
• Deployment artifacts

Setup Script

The blueprint of your application's initialization. This script:

• Creates schemas
• Sets up application roles
• Defines initial objects and permissions

Manifest File

Your app's configuration metadata. It tells Snowflake:

• Which files to include
• How to structure the deployment
• Runtime behaviors

Project Definition File

Defines deployment specifics:

• Application package name
• Stages
• Artifacts to include

Step 1—Configuring the Environment

First, log into your Snowflake account and create a new database and schema for your application. You can do this using the following SQL commands:

CREATE DATABASE IF NOT EXISTS my_app_db;
USE DATABASE my_app_db;
CREATE SCHEMA IF NOT EXISTS my_app_schema;

This sets up a dedicated space for your app's data and logic.

Now make sure you have an active warehouse set for executing your SQL commands. You can create a new warehouse or use an existing one:

CREATE WAREHOUSE IF NOT EXISTS <warehouse> WITH WAREHOUSE_SIZE = 'SMALL';
USE WAREHOUSE <warehouse>;

Step 2—Setting Up Snowflake CLI

To get started, you need to install and configure Snowflake CLI. It allows users to execute SQL queries and carry out a wide range of DDL and DML operations.

To download Snowflake CLI, first download from the SnowSQL download page and then open a new terminal window. Execute the following code to test your connection:

snow connection add

Once you have done that, enter all the credentials when prompted. 

That’s it!

For detailed instructions on installing Snowflake CLI, refer to the official documentation.

Step 3—Initializing a New Project

Now that your environment is set up, you will initialize a new project folder for your app using the Snowflake CLI. Open your terminal and execute:

snow init --template app_basic snowflake_native_app_demo

This command creates a directory named snowflake_native_app_demo, which contains a basic structure for your Snowflake Native App project.

Here’s what is inside the app directory:

OR 

You can clone the starter project which is provided by Snowflake by running the following command:

git clone https://github.com/Snowflake-Labs/sfguide-getting-started-with-native-apps.git

Step 4—Creating Application Files

Navigate to the snowflake_native_app_demo directory and create several essential files:

➥ Configuring Setup Script

This SQL script runs automatically when a consumer installs your app. Modify app/setup_script.sql with the following content (add comment for now, we will update the script later on):

-- Snowflake Native App Setup script 

➥ Configuring Manifest File

This YAML file contains configuration information about your app. Create/Update app/manifest.yml with this:

➥ Configuring Project Definition File

This YAML file defines objects that can be deployed to Snowflake. Create/Update snowflake.yml in the root of your project with this:

definition_version: 2
entities:
   snowflake_native_app_demo_package:
      type: application package
      stage: stage_content.hello_snowflake_stage
      manifest: app/manifest.yml
      identifier: snowflake_native_app_demo_package
      artifacts:
         - src: app/*
           dest: ./
   demo_snowflake_native_app:
      type: application
      from:
         target: snowflake_native_app_demo_package
      debug: false

This file is central to setting up a Snowflake Native App. It specifies key details about the app’s configuration and how resources are managed within Snowflake.

To create an application package, you need the CREATE APPLICATION PACKAGE privilege. If your role doesn’t have this, you can grant it with the Snowflake CLI:

snow sql -q "GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE accountadmin" -c <connection_name>

Replace connection_name with the connection name specified in your config.toml file.

snowflake.yml file defines objects and configuration details. Here’s what it includes:

a) Application Package

Serves as the container for app-related objects. Example: snowflake_native_app_demo_package

b) Application Object

Created from the application package. Example: demo_snowflake_native_app

c) Named Stage

Holds application files. Example: stage_content.hello_snowflake_stage. The stage name is schema-qualified and created inside the application package.

It stores files for setup scripts or runtime use.

Artifacts Section

Specifies file rules for deployment. Example: Files in app/ are uploaded to the root of the stage.

Example mappings:

tutorial/app/manifest.yml → @snowflake_native_app_demo_package.stage_content.hello_snowflake_stage
tutorial/app/README.md → @snowflake_native_app_demo_package.stage_content.hello_snowflake_stage
tutorial/app/setup_script.sql → @snowflake_native_app_demo_package.stage_content.hello_snowflake_stage

Use <% ... %> syntax for dynamic referencing. Example: <% ctx.entities.pkg.identifier %> accesses the package identifier.

Debug Mode

The debug field in snowflake.yml is set to false for production. Debug mode is typically enabled by default during development.

➥ Configuring README File

This file provides a description of your application. Create app/README.md with a brief description:

This is a demo Snowflake Native App.

Step 5—Writing the Snowflake Native Application Logic

Now let’s get to the essence of Snowflake Native App development—adding application logic and installing your first app. This involves creating stored procedures, setting up application roles, and configuring privileges for seamless execution. Here's how you can achieve this:

➥ Add a Stored Procedure to the Setup Script

The setup script is central to your app’s functionality. By extending it, you can define key components like roles and stored procedures.

First let's define an Application Role. To do so, add the following to your setup_script.sql file:

CREATE APPLICATION ROLE IF NOT EXISTS snowflake_native_app_public;
CREATE SCHEMA IF NOT EXISTS native_app_core;
GRANT USAGE ON SCHEMA native_app_core TO APPLICATION ROLE snowflake_native_app_public;

As you can see, this creates an application-specific role (snowflake_native_app_public) and a schema (native_app_core) for the app. And the role is restricted to the app’s context and manages access to app-specific objects.

Next, add a stored procedure that your app can call:

CREATE OR REPLACE PROCEDURE native_app_core.HELLO()
  RETURNS STRING
  LANGUAGE SQL
  EXECUTE AS OWNER
  AS
BEGIN
  RETURN 'Demo Snowflake Native App!';
END;

This stored procedure outputs a simple greeting—useful as a test or base for more complex logic.

Finally, grant the application role permission to use the procedure:

GRANT USAGE ON PROCEDURE native_app_core.hello() TO APPLICATION ROLE snowflake_native_app_public;

Now this role can access and execute the stored procedure.

Here is how your setup_script.sql file should look like:

Once your setup script includes the necessary logic, install the app in stage dev mode using the Snowflake CLI. Dev mode lets you test app behavior before deploying it to production.

To test it, run the following Snowflake CLI command:

snow app run -c connection_name

As you can see, if the command runs successfully, it outputs a URL where you can see your app in Snowsight.

To run the stored procedure that you added to setup_script.sql in a previous section, run the following Snowflake CLI command:

snow sql -q "call demo_snowflake_native_app.native_app_core.hello()" -c connection_name

You should see the following result/output:

Step 6—Adding Data Content to Your Snowflake Native App

In this step, you’ll enhance your Snowflake Native App by incorporating shared data content. This involves creating and sharing a table within your app package and granting access to app users. Additionally, you’ll create a view for secure data access by consumers.

First, let's create a table to share with the app. To do so, you can add a table to your app package by writing a SQL script and specifying its execution in the project definition file.

So let's create and populate the table. To do that, you need to create a folder scripts and inside that folder, create a file called shared_content.sql. Then, add the following code:

USE APPLICATION PACKAGE <% ctx.entities.snowflake_native_app_demo_package.identifier %>;

CREATE SCHEMA IF NOT EXISTS shared_data;
USE SCHEMA shared_data;
CREATE TABLE IF NOT EXISTS wealthy_individuals (
    id INT,
    name VARCHAR,
    status VARCHAR
);

TRUNCATE TABLE wealthy_individuals;

INSERT INTO wealthy_individuals VALUES
    (1, 'Elon', 'Billionaire'),
    (2, 'Bernard', 'Billionaire'),
    (3, 'Jeff', 'Billionaire'),
    (4, 'Warren', 'Billionaire'),
    (5, 'Larry', 'Billionaire'),
    (6, 'Sergey', 'Billionaire'),
    (7, 'Gautam', 'Billionaire'),
    (8, 'Carlos', 'Billionaire'),
    (9, 'Mukesh', 'Billionaire'),
    (10, 'Bill', 'Millionaire'),
    (11, 'Mark', 'Millionaire'),
    (12, 'Larry', 'Millionaire'),
    (13, 'Michael', 'Millionaire'),
    (14, 'Aman', 'Millionaire'),
    (15, 'Warren', 'Billionaire');

Now, grant access to the table and schema using:

GRANT USAGE ON SCHEMA shared_data TO SHARE IN APPLICATION PACKAGE <% ctx.entities.snowflake_native_app_demo_package.identifier %>;
GRANT SELECT ON TABLE wealthy_individuals TO SHARE IN APPLICATION PACKAGE <% ctx.entities.snowflake_native_app_demo_package.identifier %>;

The placeholder <% ctx.entities.snowflake_native_app_demo_package.identifier %> dynamically resolves to your application package identifier during deployment.

Add the Script to the Project Definition File

Update the snowflake.yml file to include the new script in post-deployment hooks:

definition_version: 2
entities:
   snowflake_native_app_demo_package:
      type: application package
      stage: stage_content.hello_snowflake_stage
      manifest: app/manifest.yml
      identifier: snowflake_native_app_demo_package
      artifacts:
         - src: app/*
           dest: ./
      meta:
         post_deploy:
            - sql_script: scripts/shared_content.sql
   demo_snowflake_native_app:
      type: application
      from:
         target: snowflake_native_app_demo_package
      debug: false

Next, modify the setup_script.sql file to create a view that app consumers can use to query the data.

Create a Versioned Schema:

CREATE OR ALTER VERSIONED SCHEMA code_schema;
GRANT USAGE ON SCHEMA code_schema TO APPLICATION ROLE snowflake_native_app_public;

Create the View:

CREATE VIEW IF NOT EXISTS code_schema.accounts_view
  AS SELECT roll_number, NAME, VALUE
  FROM shared_data.wealthy_individuals;
GRANT SELECT ON VIEW code_schema.accounts_view TO APPLICATION ROLE snowflake_native_app_public;

After adding the table and view, test the updated app to make sure everything works as expected. Let’s deploy the updates:

snow app run -c connection_name

This uploads the edited files to the stage, runs scripts/shared_content.sql, and deploys the app.

Now, finally to verify the data access, fire the command below:

snow sql -q "SELECT * FROM demo_snowflake_native_app.code_schema.accounts_view" -c connection_name

The output should list the sample data from the accounts table.

Step 7—Adding Python Code to Your Snowflake Native App

Let's enhance our Snowflake Native App by incorporating Python-based logic using User-Defined Functions (Snowflake UDFs). We'll add both an inline Python UDF and one that references an external Python module.

Inline Python UDFs enable you to embed Python logic directly within your setup script. To do so, update your setup script to include the following code:

CREATE OR REPLACE FUNCTION code_schema.squareroot(i INT)
RETURNS INT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.11'
HANDLER = 'squareroot_py'
AS
$$
def squareroot_py(i):
  return i * i
$$;

GRANT USAGE ON FUNCTION code_schema.squareroot(INT) TO APPLICATION ROLE snowflake_native_app_public;

As you can see, this:

• Creates a Python UDF named squareroot in the code_schema schema.
• Uses Python 3.11 runtime.
• Grants the necessary usage privilege to the snowflake_native_app_public role.

Now let's reference a Python file for modular and reusable logic. First, let's add this code to your setup script:

CREATE OR REPLACE FUNCTION code_schema.cuberoot(i INT)
RETURNS FLOAT
LANGUAGE PYTHON
RUNTIME_VERSION = 3.11
IMPORTS = ('/python/cube_python.py')
HANDLER = 'cube_python.cuberoot';

GRANT USAGE ON FUNCTION code_schema.cuberoot(INT) TO APPLICATION ROLE snowflake_native_app_public;

Now let's add the external Python file. To do this, in the project folder, create a subdirectory: python/. Inside this folder, create a file named cube_python.py with the following content:

def cuberoot(i):
  return i * i * i

Update the project definition file to include the Python file:

artifacts:
  - src: python/cube_python.py

After adding the Python UDFs, deploy and validate their functionality.

Deploy the Updates:

snow app run -c connection_name

This uploads the updated files to the stage and deploys the app.

Test the Inline Python UDF:

snow sql -q "SELECT demo_snowflake_native_app.code_schema.squareroot(2)" -c connection_name

Output:

Test the External Python UDF:

snow sql -q "SELECT demo_snowflake_native_app.code_schema.cuberoot(2)" -c connection_name

Output:

Step 8—Adding a Streamlit App to Your Snowflake Native App

Now, let's integrate a Streamlit-based user interface into your Snowflake Native App. Streamlit is an open-source framework designed for building interactive data applications, offering features for data visualization and user interaction.

Head over to your project folder and create a subdirectory named streamlit/. Inside the streamlit folder, create a file named streamlit_app.py. Then, add the following Python code to streamlit_app.py:

# Import python packages
import streamlit as st
from snowflake.snowpark import Session

st.title("Demo Snowflake Native Application")
st.write(
    """Demo of Snowflake Native Application"""
)

# Get the current credentials
session = Session.builder.getOrCreate()

# Create an example data frame
data_frame = session.sql("SELECT * FROM code_schema.accounts_view")

# Execute the query and convert it into a Pandas data frame
queried_data = data_frame.to_pandas()

# Display the Pandas data frame as a Streamlit data frame.
st.dataframe(queried_data, use_container_width=True)

Next, add the following to the artifacts section of the project definition file:

artifacts:
  - src: streamlit/streamlit_app.py

This is how your snowflake.yml should look:

definition_version: 2
entities:
   snowflake_native_app_demo_package:
      type: application package
      stage: stage_content.hello_snowflake_stage
      manifest: app/manifest.yml
      identifier: snowflake_native_app_demo_package
      artifacts:
         - src: app/*
           dest: ./
         - src: python/cube_python.py
         - src: streamlit/streamlit_app.py       
      meta:
         post_deploy:
            - sql_script: scripts/shared_content.sql
   demo_snowflake_native_app:
      type: application
      from:
         target: snowflake_native_app_demo_package
      debug: false

Then, create the Streamlit object. To do that, add the following to the end of the setup_script.sql file:

CREATE STREAMLIT IF NOT EXISTS code_schema.snowflake_streamlit_native_app
  FROM '/streamlit'
  MAIN_FILE = '/streamlit_app.py'
;

Add the following statement to the same script to allow the application role to access the Streamlit object:

GRANT USAGE ON STREAMLIT code_schema.hello_snowflake_streamlit TO APPLICATION ROLE snowflake_native_app_public;

Deploy the updates by running the following command to update the app:

snow app run -c connection_name

After deployment, a URL will be printed in the console. Navigate to this URL to interact with the app. Click the snowflake_streamlit_native_app tab to view the Streamlit interface.

Step 9—Versioning Your Snowflake Native App

Lets formalize your Snowflake Native App by creating a version. While previous steps utilized "stage development" mode for rapid iteration, adding a version is essential for listing the application package and sharing it with other Snowflake users.

Run the following command to create version V1 for the snowflake_native_app_demo_package application package:

snow app version create v1 -c connection_name

Here is how you would check the version of the app to see whether it was added successfully or not. To do so, run the following command:

snow app version list -c connection_name

Step 10—Installing and Testing the Versioned App

To install and test the versioned app, run the following command to install the app based on the created version:

Step 11—Viewing Snowflake Native App in Snowsight

After finalizing your Snowflake Native App, you can use Snowsight, Snowflake’s web interface, to explore your app visually, instead of relying solely on SQL commands.

To start, sign in to Snowsight using your Snowflake credentials. Once logged in, switch to the ACCOUNTADMIN role to ensure you have the necessary permissions. You can do this by selecting your username from the navigation menu, opening the account menu, and switching from the current active role (e.g., PUBLIC) to ACCOUNTADMIN. Next, navigate to the Data Products section and select Apps from the menu.

Locate your application, DEMO_SNOWFLAKE_NATIVE_APP, in the list.

Clicking on it opens the Read Me tab, which displays the content of the README.md file you created earlier in this tutorial.

To view the Streamlit interface, find and select SNOWFLAKE_STREAMLIT_NATIVE_APP.

Monetization and Distribution of Snowflake Native App

Now that we have covered the detailed steps of how you can create and build Snowflake Native Applications from scratch, let's go through the process of how you can monetize your Snowflake Native Applications via Snowflake Marketplace. But before that, let's actually understand what Snowflake Marketplace is.

The Snowflake Marketplace is a platform where users can discover, evaluate, and purchase a variety of products, including third-party data, data services, Snowflake Native Apps, and AI products. It serves as a public data exchange integrated within the Snowflake Data Cloud, facilitating seamless and secure transactions between data providers and consumers.

The Snowflake marketplace offers various types of data products, such as:

• Raw datasets
• Refined and enriched data
• Historical datasets for forecasting and machine learning
• Real-time data streams (like weather or traffic updates)
• Specialized identity or audience data for analytics
• Snowflake Native Applications
• Pre-built data pipelines and transformations

Snowflake Marketplace leverages Snowflake's architecture to facilitate the secure sharing of data and applications. Transactions are managed natively, eliminating the need for third-party billing systems. Vendors can offer their products through various pricing models, such as pay-as-you-go, one-time payment, usage-based payment, or subscription-based plans, while benefiting from Snowflake's built-in analytics to track customer engagement.

Let's jump right into the juicy part of the article: a step-by-step guide to monetizing Snowflake Native Applications via Snowflake Marketplace.

Step-By-Step Monetization Process of a Snowflake Native App via Snowflake Marketplace

Step 1—Prepare Your Snowflake Native Application Package

Before monetization, make sure your Snowflake Native App meets Snowflake's submission requirements:

• The app must be fully functional upon installation, with all necessary resources and configurations included.
• It must not depend on external systems for core functionality.
• Should Leverage Snowflake-stored or shared data for operations.
• Include the following files:
  • manifest.yml (outlines app permissions and dependencies).
  • readme.md (describes app functionality, post-installation setup steps, and sample usage SQL).
  • Setup scripts and external components like Streamlit files or UDF code

Step 2—Define the Default Release Directive

Now, set the release directive to specify the app version and patch available for distribution:

List available versions and patches:

snow app version list -c connection_name

Then, set the default release directive:

snow sql -q "ALTER APPLICATION PACKAGE <your_app_package> SET DEFAULT RELEASE DIRECTIVE VERSION = v1 PATCH = 0"

As you can see, this command sets version v1 and patch 0 as the default for your app, ensuring it is ready for deployment​.

Step 3—Create and Configure a Private Listing on the Snowflake Marketplace

To share your app via the Snowflake Marketplace, start by signing in to Snowsight and navigating to Data Products > Provider Studio.

Click + Listing to create a new listing and proceed with configuration. Enter a name for the listing and specify the discovery permissions, choosing whether the listing will be public or restricted to specific consumers (e.g., select “Only specified consumers” for private sharing and select “Anyone on the Marketplace” for public listing). 

Attach the application package you prepared earlier as the core data content for the listing. Provide a detailed description outlining your app's features and usage scenarios. If creating a private listing, add the account identifiers of intended consumers in the "Add Consumer accounts" section. Finally, publish your listing for approval.

Step 4—Create and Configure a Public Paid Listing on the Snowflake Marketplace

Now, to create a public listing, you need to first contact your Snowflake business development partner to approve your paid listing. If you don’t have a business development partner, you’ll need to submit a case with Marketplace Operations. Before proceeding, verify that your role has the required privileges to create a listing.

Once everything is in place, you need to log in to Snowsight and go to Data Products > Provider Studio from the menu. Select + Listing to open the Create Listing window. Here, name your listing and set its visibility. To make the listing publicly discoverable, choose "Anyone on the Marketplace" under the discovery settings.

Next, you need to decide how consumers will access your data product: choose "Free" for no-cost access, "Personalized/Limited Trial" to offer a trial version with full access upon request, or "Paid" if you plan to charge consumers directly.

After setting the access type, click Next to generate a draft listing. Lastly, refine and configure the draft by including all necessary details to ready it for publication on the Snowflake Marketplace.

Step 5—Submit Listing for Approval

All listings on the Snowflake Marketplace must undergo a review and approval process before publication. If a listing is rejected, review the provided feedback, make the necessary updates, and resubmit it for approval.

Before publishing make sure that your listing configuration is complete, you have the ACCOUNTADMIN role or OWNERSHIP privilege for the associated data product, and all sample SQL queries in the listing are validated successfully. To submit your listing, sign in to Snowsight, navigate to Data Products ➤ Provider Studio, go to the Listings tab, select your draft listing, and click Submit for Approval.

Step 6—Final Approval and Publishing

Once submitted, Snowflake will review your listing and provide an Approved or Denied status. If denied, review the feedback, make the necessary updates, and resubmit the listing. After receiving approval, return to the Listings tab, select your approved listing, and click Publish. Upon publication, the listing will be visible to consumers in all current and future Snowflake Marketplace regions. Regional availability can be managed through cross-cloud auto-fulfillment settings, and you can create referral links for direct access to your listing.

Further Reading

• Snowflake Native Apps
• What Are Native Apps?
• About the Snowflake Native App Framework
• Snowflake Native App Framework on AWS and Azure
• Introducing the Snowflake Native App Framework
• Getting Started with Snowflake Native Apps
• Snowflake Native Apps Example

Save up to 30% on your Snowflake spend in a few minutes!

Request a Demo

Enter your work email

Enter your work email

Request a Demo

Conclusion

And that's a wrap! Snowflake Native Apps are built using the Snowflake Native App Framework. This allows developers to create, test, and launch apps right in Snowflake. The framework simplifies the process of building, launching, and integrating advanced tools. It ensures security and governance by tapping into the Snowflake ecosystem. For providers, these apps provide an easy way to sell their solutions on the Snowflake Marketplace, reaching thousands of customers. Meanwhile, consumers get instant access to the apps without needing a complex setup.

In this article, we have covered:

• What are Native Apps in Snowflake?
• Key features and characteristics of Snowflake Native Apps
• What are the benefits of Snowflake Native Apps for providers?
• What are the benefits of Snowflake Native Apps for consumers?
• How do Snowflake Native Apps work?
• Step-by-step guide to create a Snowflake Native App
• Monetization and distribution of Snowflake Native Apps
• Step-by-step monetization process via Snowflake Marketplace

… and so much more!

FAQs

What are Native Apps in Snowflake?

Snowflake Native Apps are designed specifically to operate within the Snowflake ecosystem without requiring external access or movement of sensitive data outside its environment.

How can I develop and test a Snowflake Native App locally?

Developers can set up their environments using tools like VSCode along with necessary extensions provided by Snowflakes such as CLI support.

Can I share my Snowflake Native App with other users?

Yes! Once published on the marketplace after meeting compliance requirements.

Does the Snowflake Native App framework support logging and monitoring?

Yes! Snowflake Native App framework includes telemetry tools that allow developers to monitor application performance post-deployment.

What is Streamlit's role in Snowflake Native apps?

Streamlit allows developers to create interactive web interfaces that enhance user engagement directly within their Snowflake Native Applications.

Can I update my Snowflake Native App after deployment?

Yes! Providers have control over release cycles allowing them to push updates seamlessly even after deployment.