Welcome to the Zero to Snowflake Quickstart! This guide is a consolidated journey through key areas of the Snowflake AI Data Cloud. You will start with the fundamentals of warehousing and data transformation, build an automated data pipeline, then see how you can experiment with LLMs using the Cortex Playground to compare different models for summarizing text, use AISQL Functions to instantly analyze customer review sentiment with a simple SQL command, and harness Cortex Search for intelligent text discovery, and utilize Cortex Analyst for conversational business intelligence. Finally, you will learn to secure your data with powerful governance controls and enrich your analysis through seamless data collaboration.

We'll apply these concepts using a sample dataset from our fictitious food truck, Tasty Bytes, to improve and streamline their data operations. We'll explore this dataset through several workload-specific scenarios, demonstrating the benefits Snowflake provides to businesses.

Our mission is to provide unique, high-quality food options in a convenient and cost-effective manner, emphasizing the use of fresh ingredients from local vendors. Their vision is to become the largest food truck network in the world with a zero carbon footprint.

In this Quickstart, we will use Snowflake Workspaces to organize, edit, and run all the SQL scripts required for this course. We will create a dedicated SQL file for the setup and each vignette. This will keep our code organized and easy to manage.

Let's walk through how to create your first SQL file, add the necessary setup code, and run it.

First, we need a place to put our setup script.

1. Navigate to Workspaces: In the left-hand navigation menu of the Snowflake UI, click on Projects » Workspaces. This is the central hub for all your SQL files.
2. Create a New SQL File: Find and click the + Add New button in the top-left corner of the Workspaces area, then select SQL File. This will generate a new, blank SQL file.
3. Rename the SQL File: Your new SQL file will have a name based on the timestamp it was created. Give it a descriptive name like Zero To Snowflake - Setup.

Now that you have your SQL file, it's time to add the setup SQL and execute it.

1. Copy the SQL Code: Click the link for the setup file and copy it to your clipboard.
2. Paste into your SQL File: Return to your Zero To Snowflake Setup SQL file in Snowflake and paste the entire script into the editor.
3. Run the Script: To execute all the commands in the SQL file sequentially, click the "Run All" button located at the top-left of the editor. This will perform all the necessary setup actions, such as creating roles, schemas, and warehouses that you will need for the upcoming vignettes.

The process you just completed for creating a new SQL file is the exact same workflow you will use for every subsequent vignette in this course.

For each new vignette, you will:

1. Create a new SQL file.
2. Give it a descriptive name (e.g., Vignette 1 - Getting Started with Snowflake).
3. Copy and paste the SQL script for that specific vignette.
4. Each SQL file has all of the necessary instructions and commands to follow along.

Within this Vignette, we will learn about core Snowflake concepts by exploring Virtual Warehouses, using the query results cache, performing basic data transformations, leveraging data recovery with Time Travel, and monitoring our account with Resource Monitors and Budgets.

Copy and paste the SQL code from this file in a new SQL File to follow along in Snowflake. Note that once you've reached the end of the SQL File you can skip to Step 10 - Simple Data Pipeline

Virtual Warehouses are the dynamic, scalable, and cost-effective computing power that lets you perform analysis on your Snowflake data. Their purpose is to handle all your data processing needs without you having to worry about the underlying technical details.

First, lets set our session context. To run the queries, highlight the three queries at the top of your SQL file and click the "► Run" button.

Let's create our first warehouse! This command creates a new X-Small warehouse that will initially be suspended.

Now that we have a warehouse, we must set it as the active warehouse for our session. Execute the next statement.

If you try to run the query below, it will fail, because the warehouse is suspended and does not have AUTO_RESUME enabled.

Let's resume it and set it to auto-resume in the future.

Now, try the query again. It should execute successfully.

Warehouses in Snowflake are designed for elasticity. We can scale our warehouse up on the fly to handle a more intensive workload. Let's scale our warehouse to an X-Large.

With our larger warehouse, let's run a query to calculate total sales per truck brand.

This is a great place to demonstrate another powerful feature in Snowflake: the Query Result Cache. When you first ran the 'sales per truck' query, it likely took several seconds. If you run the exact same query again, the result will be nearly instantaneous. This is because the query results were cached in Snowflake's Query Result Cache.

Run the same 'sales per truck' query from the previous step. Note the execution time in the query details pane. It should be much faster.

We will now be working with smaller datasets, so we can scale our warehouse back down to an X-Small to conserve credits.

In this section, we will see some basic transformation techniques to clean our data and use Zero-Copy Cloning to create development environments. Our goal is to analyze the manufacturers of our food trucks, but this data is currently nested inside a VARIANT column.

First, let's take a look at the truck_build column.

This table contains data about the make, model and year of each truck, but it is nested, or embedded in a special data type called a VARIANT. We can perform operations on this column to extract these values, but first we'll create a development copy of the table.

Let's create a development copy of our truck_details table. Snowflake's Zero-Copy Cloning lets us create an identical, fully independent copy of the table instantly, without using additional storage.

Now that we have a safe development table, let's add columns for year, make, and model. Then, we will extract the data from the truck_build VARIANT column and populate our new columns.

Let's run a query to see the distribution of truck makes.

Did you notice anything odd about the results from the last query? We can see a data quality issue: 'Ford' and 'Ford_' are being treated as separate manufacturers. Let's easily fix this with a simple UPDATE statement.

Here we're saying we want to set the row's make value to Ford wherever it is Ford_. This will ensure none of the Ford makes have the underscore, giving us a unified make count.

Our development table is now cleaned and correctly formatted. We can instantly promote it to be the new production table using the SWAP WITH command. This atomically swaps the two tables.

Now that the swap is complete, we can drop the unnecessary truck_build column from our new production table. We also need to drop the old production table, which is now named truck_dev. But for the sake of the next lesson, we will "accidentally" drop the main table.

Oh no! We accidentally dropped the production truck_details table. Luckily, Snowflake's Time Travel feature allows us to recover it instantly. The UNDROP command restores dropped objects.

If you run a DESCRIBE command on the table, you will get an error stating it does not exist.

Let's restore the truck_details table to the exact state it was in before being dropped.

Verify the table was successfully restored by selecting from it. Then, we can safely drop the actual development table, truck_dev.

Monitoring compute usage is critical. Snowflake provides Resource Monitors to track warehouse credit usage. You can define credit quotas and trigger actions (like notifications or suspension) when thresholds are reached.

Let's create a resource monitor for my_wh. This monitor has a monthly quota of 100 credits and will send notifications at 75% and suspend the warehouse at 90% and 100% of the quota. First, ensure your role is accountadmin.

With the monitor created, apply it to my_wh.

While Resource Monitors track warehouse usage, Budgets provide a more flexible approach to managing all Snowflake costs. Budgets can track spend on any Snowflake object and notify users when a dollar amount threshold is reached.

Let's first create the budget object in SQL.

Let's take a look at the Budget Page on Snowsight.

Navigate to Admin » Cost Management » Budgets.

Key:

1. Warehouse Context
2. Cost Management Navigation
3. Time Period Filter
4. Key Metrics Summary
5. Spend and Forecast Trend Chart
6. Budget Details

Configuring a budget is done through the Snowsight UI.

1. Make sure your account role is set to ACCOUNTADMIN. You can change this in the bottom left corner.
2. Click on the MY_BUDGET budget we created.
3. Click Budget Details to open the Budget details panel, then click Edit in the Budget Details panel on the right.
4. Set the Spending Limit to 100.
5. Enter a verified notification email address.
6. Click + Tags & Resources and add the TB_101.ANALYTICS schema and the TB_DE_WH warehouse to be monitored.
7. Click Save Changes.
   

Universal Search allows you to easily find any object in your account, plus explore data products in the Marketplace, relevant Snowflake Documentation, and Community Knowledge Base articles.

Let's try it now.

1. Click Search in the Navigation Menu on the left.
2. Enter truck into the search bar.
3. Observe the results. You will see categories of objects on your account, such as tables and views, as well as relevant documentation.

You can also use natural language. For example, search for: Which truck franchise has the most loyal customer base? Universal search will return relevant tables and views, even highlighting columns that might help answer your question, providing an excellent starting point for analysis.

Within this vignette, we will learn how to build a simple, automated data pipeline in Snowflake. We will start by ingesting raw, semi-structured data from an external stage, and then use the power of Snowflake's Dynamic Tables to transform and enrich that data, creating a pipeline that automatically stays up-to-date as new data arrives.

Copy and paste the SQL from this file in a new SQL File to follow along in Snowflake. Note that once you've reached the end of the SQL File you can skip to Step 16 - Snowflake Cortex AI.

Our raw menu data currently sits in an Amazon S3 bucket as CSV files. To begin our pipeline, we first need to ingest this data into Snowflake. We will do this by creating a Stage to point to the S3 bucket and then using the COPY command to load the data into a staging table.

First, let's set our session context to use the correct database, role, and warehouse. Execute the first few queries in your SQL file.

A Stage is a Snowflake object that specifies an external location where data files are stored. We'll create a stage that points to our public S3 bucket. Then, we'll create the table that will hold this raw data.

With the stage and table in place, let's load the data from the stage into our menu_staging table using the COPY INTO command.

Snowflake excels at handling semi-structured data like JSON using its native VARIANT data type. One of the columns we ingested, menu_item_health_metrics_obj, contains JSON. Let's explore how to query it.

Let's look at the raw JSON. Notice it contains nested objects and arrays.

We can use special syntax to navigate the JSON structure. The colon (:) accesses keys by name, and square brackets ([]) access array elements by index. We can also cast results to explicit data types using the CAST function or the double-colon shorthand (::).

The FLATTEN function is a powerful tool for un-nesting arrays. It produces a new row for each element in an array. Let's use it to create a list of every ingredient for every menu item.

Our franchises are constantly adding new menu items. We need a way to process this new data automatically. For this, we can use Dynamic Tables, a powerful tool designed to simplify data transformation pipelines by declaratively defining the result of a query and letting Snowflake handle the refreshes.

We'll start by creating a dynamic table that extracts all unique ingredients from our staging table. We set a LAG of '1 minute', which tells Snowflake the maximum amount of time this table's data can be behind the source data.

Let's see the automation in action. One of our trucks has added a Banh Mi sandwich, which contains new ingredients for French Baguette and Pickled Daikon. Let's insert this new menu item into our staging table.

Now, query the harmonized.ingredient table. Within a minute, you should see the new ingredients appear automatically.

Now we can build a multi-step pipeline by creating more dynamic tables that read from other dynamic tables. This creates a chain, or a Directed Acyclic Graph (DAG), where updates automatically flow from the source to the final output.

Let's create a lookup table that maps ingredients to the menu items they are used in. This dynamic table reads from our harmonized.ingredient dynamic table.

Let's simulate an order of two Banh Mi sandwiches by inserting records into our order tables.

Finally, let's create our final dynamic table. This one joins our order data with our ingredient lookup tables to create a summary of monthly ingredient usage per truck. This table depends on the other dynamic tables, completing our pipeline.

Now, let's query the final table in our pipeline. After a few minutes for the refreshes to complete, you will see the ingredient usage for two Banh Mis from the order we inserted in a previous step. The entire pipeline updated automatically.

Finally, let's visualize our pipeline's Directed Acyclic Graph, or DAG. The DAG shows how our data flows through the tables, and it can be used to monitor the health and lag of our pipeline.

To access the DAG in Snowsight:

1. Navigate to Data » Database.
2. In the database object explorer, expand your database TB_101 and the schema HARMONIZED.
3. Click on Dynamic Tables.
4. Select any of the dynamic tables you created (e.g., INGREDIENT_USAGE_BY_TRUCK).
5. Click on the Graph tab in the main window.

You will now see a visualization of your pipeline, showing how the base tables flow into your dynamic tables.

Welcome to the Zero to Snowflake Hands-on Lab focused on Snowflake Cortex AI!

Within this lab, we will explore Snowflake’s complete AI platform through a progressive journey from experimentation into unified business intelligence. We’ll learn AI capabilities by building a comprehensive customer intelligence system using Cortex Playground for AI experimentation, Cortex AISQL Functions for production-scale analysis, Cortex Search for semantic text searching and Cortex Analyst for natural language analytics.

Through this journey, you’ll construct a complete intelligence customer analytics platform:

Phase 1: AI Foundation

Phase 2: Intelligent Development & Discovery

Phase 3: Conversational Intelligence

As a data analyst at Tasty Bytes, you need to rapidly explore customer feedback using AI models to identify service improvement opportunities. Traditionally, AI experimentation is complex and time-consuming. Snowflake Cortex Playground solves this by offering a quick, secure environment directly within Snowflake's UI to experiment with diverse AI models, compare their performance on real business data, and export successful approaches as production-ready SQL. This lab guides you through using Cortex Playground for rapid prototyping and seamless integration of AI into your data workflows.

Let's begin by connecting directly to customer review data within Cortex Playground. This keeps your data secure within Snowflake while allowing you to analyze feedback using AI models.

Navigation steps:

1. Navigate to AI & ML → Studio → Cortex Playground.
2. Select Role: TB_DEV and Warehouse: TB_DEV_WH.
3. Click "+Connect your data" in the prompt box.
4. Select data source:
   • Database: TB_101
   • Schema: HARMONIZED
   • Table: TRUCK_REVIEWS_V
5. Click Let's go
6. Select text column: REVIEW
7. Select filter column: TRUCK_BRAND_NAME
8. Click Done.
9. In the system prompt box, apply a filter using the TRUCK_BRAND_NAME dropdown. There are multiple reviews available for each truck brand. For instance, you can select "Better Of Bread" to narrow down the reviews. If "Better Of Bread" isn't available, please choose any other truck brand from the dropdown and proceed with one of its reviews.

Now, let's analyze customer reviews to extract specific operational insights and compare how different AI models perform on this business task.

Setup Model Comparison:

1. Click "Compare" to enable side-by-side model comparison.
2. Set the left panel to "claude-3-5-sonnet" and the right panel to "snowflake-llama-3.3-70b".

Enter this strategic prompt:

Analyze this customer review across multiple dimensions: sentiment score with confidence level, key theme extraction, competitive positioning insights, operational impact assessment, and priority ranking for management action

With our optimal model identified, we now need to fine-tune its behavior for different business scenarios. The same model can produce vastly different results depending on its settings—let’s optimize this for our specific analytical requirements.

We want to observe how adjusting parameters, especially "temperature," affects the AI model's responses. Does it lead to more consistent or more creative answers?

How to Set Up This Temperature Test:

1. First, make sure both panels are set to "claude-3-5-sonnet." We're comparing the same model, just with different settings.
2. Next, click "Change Settings" right next to where it says "Compare."
3. Now, let's adjust those parameters for each side:
   • Left Panel:
     • Set Temperature to 0.1. This will generally make the model give you really consistent, predictable answers.
     • Set Max-tokens to 200. This just keeps the responses from getting too long.
   • Right Panel:
     • Set Temperature to 0.8. This should make the model's answers a bit more creative and varied.
     • Set top_p to 0.8. This is another setting that helps encourage a wider range of words in the response.
     • Set Max-tokens to 200. Again, keeping the length in check.
4. Finally, use the exact same strategic prompt you used in Step 2.

Give that a try and see how the responses differ! It's pretty cool to see how these small tweaks can change the AI's "personality."

Observe the Impact:

Notice how adjusting the temperature parameter fundamentally changes the analytical output, even with the same AI model and data.

While temperature influences token choice, top_p (set to 0.8 on the right) restricts possible tokens. max_tokens simply sets the maximum response length; be mindful small values can truncate results. This gives you precise control over AI creativity versus consistency, letting you match the AI’s behavior to your analytical objectives.

Now that we’ve mastered model selection and parameter optimization, let's examine the technology foundation that makes this experimentation possible. Understanding this will help us transition from playground testing to production deployment.

In this section, let's explore the core technology that takes your AI insights from the playground to production.

Every AI insight you generate in Cortex Playground isn't just magic; it's backed by SQL. Click "View Code" after any model response, and you'll see the exact SQL query, complete with your specified settings like temperature. This isn't just for show—this code is ready for action! You can run it directly in a Workspace SQL file, automate it with streams and tasks, or integrate it with a dynamic table for live data processing. It's also worth noting that the functionalities of this Cortex Complete can be accessed programmatically via Python or a REST API, offering flexible integration options.

Behind every prompt you've run, the SNOWFLAKE.CORTEX.COMPLETE function is hard at work. This is Snowflake Cortex's powerful function providing direct access to industry-leading large language models for text completion. The Cortex Playground simply offers an intuitive interface to test and compare these models before you embed them directly into your SQL. (Heads up: this will evolve to AI_COMPLETE in future releases.)

This seamless integration means your AI experimentation directly translates into production-ready workflows within Snowflake.

The Cortex Playground is an invaluable tool for experimenting with individual reviews, but true large-scale customer feedback analysis demands specialized AI functions. The prompt patterns and model selections you've refined here lay the groundwork for building scalable solutions. Our next step involves processing thousands of reviews using purpose-built AI SQL Functions like SENTIMENT(), CLASSIFY(), EXTRACT_ANSWER(), and AI_SUMMARIZE_AGG(). This systematic approach ensures that AI-driven insights seamlessly become a core part of our operational strategy.

You've experimented with AI models in Cortex Playground to analyze individual customer reviews. Now, it's time to scale! This Quickstart shows you how to use AI SQL Functions to process thousands of reviews, turning experimental insights into production-ready intelligence. You'll learn to:

1. USE SENTIMENT() to score and label truck customer reviews.
2. Use AI_CLASSIFY() to categorize reviews by themes.
3. Use EXTRACT_ANSWER() to pull specific complaints or praise.
4. Use AI_SUMMARIZE_AGG() to generate quick summaries per truck brand.

Copy and paste the SQL from this file in a new SQL File to follow along in Snowflake.

Note: Once you've reached the end of the SQL File, you can skip to Step 19 - Cortex Search.

First, let's set our session context. We will assume the role of a TastyBytes data analyst with the intention of leveraging AISQL functions to gain insights from customer reviews.

Analyze customer sentiment across all food truck brands to identify which trucks are performing best and create fleet-wide customer satisfaction metrics. In Cortex Playground, we analyzed individual reviews manually. Now we’ll use the SENTIMENT() function to automatically score customer reviews from -1 (negative) to +1 (positive), following Snowflake's official sentiment ranges.

Business Question: “How do customers feel about each of our truck brands overall?”

Please execute this query to analyze customer sentiment across our food truck network and categorize feedback.

Now, let's categorize all reviews to understand what aspects of our service customers are talking about most. We'll use the AI_CLASSIFY() function, which automatically categorizes reviews into user-defined categories based on AI understanding, rather than simple keyword matching. In this step, we will categorize customer feedback into business-relevant operational areas and analyze their distribution patterns.

Business Question: “What are customers primarily commenting on - food quality, service, or delivery experience?"

Execute the Classification Query:

Next, to gain precise answers from unstructured text, we'll utilize the EXTRACT_ANSWER() function. This powerful function enables us to ask specific business questions about customer feedback and receive direct answers. In this step, our goal is to identify precise operational issues mentioned in customer reviews, highlighting specific problems that require immediate attention.

Business question: “What specific improvement or complaint is mentioned in this review?"

Let's execute the next query:

Finally, to create concise summaries of customer feedback, we'll use the AI_SUMMARIZE_AGG() function. This powerful function generates short, coherent summaries from lengthy unstructured text. In this step, our goal is to distill the essence of customer reviews for each truck brand into digestible summaries, providing quick overviews of overall sentiment and key points.

Business Question: “What are the key themes and overall sentiment for each truck brand?”

Execute the Summarization Query:

We've successfully demonstrated the transformative power of AI SQL functions, shifting customer feedback analysis from individual review processing to systemic, production-scale intelligence. Our journey through these four core functions clearly illustrates how each serves a distinct analytical purpose, transforming raw customer voices into comprehensive business intelligence—systematic, scalable, and immediately actionable. What once required individual review analysis now processes thousands of reviews in seconds, providing both the emotional context and specific details crucial for data-driven operational improvements.

While AI-powered tools excel at generating complex analytical queries, a common daily challenge for customer service teams is quickly finding specific customer reviews for complaints or compliments. Traditional keyword search often falls short, missing the nuances of natural language.

Snowflake Cortex Search solves this by providing low-latency, high-quality "fuzzy" search over your Snowflake text data. It quickly sets up hybrid (vector and keyword) search engines, handling embeddings, infrastructure, and tuning for you. Under the hood, Cortex Search combines semantic (meaning-based) and lexical (keyword-based) retrieval with intelligent re-ranking to deliver the most relevant results. In this lab, you will configure a search service, connect it to customer review data, and run semantic queries to proactively identify key customer feedback.

1. Open Snowsight and navigate to the AI & ML Studio, then select Cortex Search.
2. Click Create to begin setup.

This opens the search service configuration interface, where you’ll define how Snowflake indexes and interprets your text data.

In the New service configuration screen:

1. Select Database and Schema:
   • Choose TB_101 from the Databases dropdown
   • Choose HARMONIZED from the Schemas dropdown
2. Enter the Service name: customer_feedback_intelligence
3. Click the Next button at the bottom right to proceed.

The wizard will now guide you through several configuration screens. Follow these steps:

1. Select data screen:

   • From the Views dropdown, select TRUCK_REVIEWS_V
   • Click Next

2. Select search column screen:

   • Choose REVIEW (this is the text column that will be semantically searched)
   • Click Next

3. Select attributes screen:

   • Select columns for filtering results: TRUCK_BRAND_NAME, PRIMARY_CITY, REVIEW_ID
   • Click Next

4. Select columns screen:

   • Choose other columns to include in search results such as DATE, LANGUAGE, etc.
   • Click Next

5. Configure indexing screen:

   • Warehouse: Select COMPUTE_WH from the dropdown
   • Accept the other default settings
   • Click Create to build the search service

1. From the left-hand menu in Snowsight, navigate to AI & ML, then click on Cortex Search.
2. In the Cortex Search view, locate the dropdown filter (as highlighted in the image below, showing TB_101 / HARMONIZED). Select or ensure this filter is set to TB_101 / HARMONIZED.
3. In the list of "Search services" that appears, click on the pre-built service named TASTY_BYTES_REVIEW_SEARCH.
4. Once inside the service's details page, click on Playground in the top right corner to begin using the search service for the lab.

When the service shows as "Active", click on Playground and enter the natural language prompt in the search bar:

Prompt - 1: Customers getting sick

Now try another query:

Prompt - 2: Angry customers

Ultimately, Cortex Search transforms how Tasty Bytes analyzes customer feedback. It empowers the customer service manager to move beyond simply sifting through reviews, to truly understand and proactively act upon the voice of the customer at scale, driving better operational decisions and enhancing customer loyalty.

In the next module - Cortex Analyst - you’ll use natural language to query structured data.

A business analyst at Tasty Bytes needs to enable self-service analytics, allowing the business team to ask complex questions in natural language and get instant insights without relying on data analysts to write SQL. While previous AI tools helped with finding reviews and complex query generation, the demand now is for conversational analytics that directly transforms structured business data into immediate insights.

Cortex Analyst empowers business users to ask sophisticated questions directly, seamlessly extracting value from their analytics data through natural language interaction. This lab will guide you through designing a semantic model, connecting it to your business data, configuring relationships and synonyms, and then executing advanced business intelligence queries using natural language.

Let's begin by navigating to Cortex Analyst in Snowsight and configuring our semantic model foundations.

1. Navigate to Cortex Analyst under AI & ML Studio in Snowsight.

2. Set Role and Warehouse:

   • Change role to TB_DEV.
   • Set Warehouse to TB_CORTEX_WH.
   • Click Create new model.

3. On the Getting Started page, configure the following:

   • DATABASE: TB_101
   • SCHEMA: SEMANTIC_LAYER
   • Name: tasty_bytes_business_analytics
   • Description: Semantic model for Tasty Bytes executive analytics, covering customer loyalty and order performance data for natural language querying
   • Click Next.

In the Select tables step, let's choose our analytics views.

1. Select the core business tables:

   • DATABASE: TB_101
   • SCHEMA: SEMANTIC_LAYER
   • VIEWS: Select Customer_Loyalty_Metrics_v and Orders_v.
   • Click Next.

2. On the Select columns page, ensure both selected tables are active, then click Create and Save.

Now, let's add table synonyms and a primary key for better natural language understanding.

1. In the customer_loyalty_metrics_v table, copy and paste the following synonyms into the Synonyms box:

   Customers, customer_data, loyalty, customer_metrics, customer_info
   

2. Set the Primary Key to customer_id from the dropdown.

3. For the orders_v table, copy and paste the following synonyms:

   Orders, transactions, sales, purchases, order_data
   

4. After making these changes, click Save in the top right corner.

After creating the semantic model, let's establish the relationship between our logical tables.

1. Click Relationships in the left-hand navigation.

2. Click Add relationship.

3. Configure the relationship as follows:

   • Relationship name: orders_to_customer_loyalty_metrics
   • Left table: ORDERS_V
   • Right table: CUSTOMER_LOYALTY_METRICS_V
   • Join columns: Set CUSTOMER_ID = CUSTOMER_ID.

4. Click Add relationship

Upon completion, simply use the Save option at the top of the UI. This will finalize your semantic view, making your semantic model ready for sophisticated natural language queries.

To access the Cortex Analyst chat interface in fullscreen mode, you would:

1. Click the three-dot menu (ellipsis) next to the "Share" button at the top right.
2. From the dropdown menu, select "Enter fullscreen mode."

With our semantic model and relationships active, let's demonstrate sophisticated natural language analysis by running our first complex business query.

1. Navigate to the Cortex Analyst query interface.

2. Enter the following prompt:

   Show customer groups by marital status and gender, with their total spending per customer and average order value. Break this down by city and region, and also include the year of the orders so I can see when the spending occurred. In addition to the yearly breakdown, calculate each group’s total lifetime spending and their average order value across all years. Rank the groups to highlight which demographics spend the most per year and which spend the most overall.
   

Having seen basic segmentation, let's now demonstrate enterprise-grade SQL that showcases the full power of conversational business intelligence.

1. Clear the context by clicking the refresh icon.

2. Enter the following prompt:

   I want to understand our customer base better. Can you group customers by their total spending (high, medium, low spenders), then show me their ordering patterns differ? Also compare how our franchise locations perform versus company-owned stores for each spending group.
   

Through these rigorous steps, we've forged a robust Cortex Analyst semantic model. This isn't just an improvement; it's a transformative tool designed to liberate users across various industries from the constraints of SQL, enabling them to surface profound business intelligence through intuitive natural language queries. Our multi-layered analyses, while showcased through the Tasty Bytes use case, powerfully illustrate how this model drastically cuts down on the time and effort traditionally needed for deep insights, thereby democratizing access to data and fueling a culture of informed, agile decision-making on a broad scale.

The Chief Operating Officer at Tasty Bytes receives dozens of fragmented reports each week: customer satisfaction dashboards, revenue analytics, operational performance metrics, and market analysis. Critical business insights remain buried across separate systems: customer sentiment lives in review platforms, sales data sits in financial dashboards, and operational metrics exist in isolated performance tools.

When the COO needs to understand why Q3 revenue dropped, connecting customer feedback sentiment with actual financial performance requires hours of manual analysis, SQL expertise, and cross-referencing multiple data sources. This is a significant hurdle for executives and other non-technical roles.

In this section, we'll demonstrate how Snowflake Intelligence tackles this challenge by combining the capabilities of Cortex Search and Cortex Analyst, which are made available through the setup. This integration allows for a single conversational AI agent. You'll see how executives and other non-technical roles can ask natural language questions and receive immediate answers with visualizations. This kind of insight would normally take weeks of analyst work across multiple teams.

Prerequisites:

Before starting this module, your environment includes pre-configured AI services that power Snowflake Intelligence:

To enable business analytics capabilities in Snowflake Intelligence, you need to upload the pre-built semantic model file to your Snowflake stage. You can download the necessary YAML file directly by clicking this link: Cortex Analyst Semantic Model

Important: If clicking the link opens the file in your browser instead of downloading it, please right-click on the link and select "Save Link As" to download the YAML file to your local machine.

Here's how to upload the semantic model:

1. Navigate to Cortex Analyst: In Snowsight, go to AI & ML Studio and then select Cortex Analyst.

2. Set Role and Warehouse:

   • Change your role to TB_DEV.
   • Set the warehouse to TB_CORTEX_WH.

3. Upload your YAML file: Click the Upload your yaml file button.

4. Configure Upload Details: In the upload file screen, set the following:

   • Database: Tb_101
   • Schema: semantic_layer
   • Stage: semantic_model_stage

5. Click Upload: This YAML file contains the pre-configured semantic model that defines the business analytics layer, including customer loyalty metrics and order data.

6. Save the YAML file: After clicking upload, save the YAML file. The semantic model will then appear in the Cortex Analyst panel, in the semantic models section.

With your AI services pre-configured, you can now create a Cortex Agent that combines these capabilities into a single, unified intelligence interface.

1. In Snowsight, navigate to the AI & ML Studio, then select Agents.
2. Click Create Agent.
3. In the "Create New Agent" window, click Create agent.
4. Initial Configuration:
   • Platform integration: Ensure "Create this agent for Snowflake Intelligence" is checked.
   • Database and schema: This will default to SNOWFLAKE_INTELLIGENCE.AGENTS.
   • Agent object name: Enter tasty_bytes_intelligence_agent.
   • Display name: Enter Tasty Bytes Business Intelligence Agent.
5. Click Create agent.

After creating the agent, click on its name from the agent list to open the details page, then click Edit to begin configuring it.

Now, let's add the semantic model we uploaded in Step 1:

Add the Cortex Analyst Tool:

1. Click Add next to "Cortex Analyst."
2. Select the Semantic model file radio button.
3. Configure the semantic model location:
   • Schema: Choose TB_101.SEMANTIC_LAYER.
   • Stage: Choose SEMANTIC_MODEL_STAGE.
   • File Selection: Pick your uploaded YAML file from the list.
4. Configure tool details:
   • Name: Enter tasty_bytes_business_analytics.
   • Description:

5. Configure execution settings:
   • Warehouse: Select Custom and choose TB_CORTEX_WH.
   • Query timeout: Enter 300.
6. Click Add.

Add the Cortex Search Services Tool:

1. Click Add next to "Cortex Search Services."
2. Configure tool details:
   • Name: tasty_bytes_review_search.
   • Description:

3. Configure data source location:
   • Schema: Choose TB_101.HARMONIZED.
   • Search service: Choose TB_101.HARMONIZED.TASTY_BYTES_REVIEW_SEARCH.
4. Configure search result columns:
   • ID column: Select Review
   • Title column: Select TRUCK_BRAND_NAME
5. Configure search filters (optional):
   • Click Add filter to add up to 5 optional filters.
6. Click Add.

Your unified intelligence agent is now ready to provide conversational business intelligence through the Snowflake Intelligence interface.

With your intelligence agent created, we can now access the Snowflake Intelligence interface that provides unified natural language business intelligence.

Access the interface:

1. Open Snowsight and navigate to the AI & ML Studio, then select Snowflake Intelligence
2. Select our created agent: tasty_bytes_intelligence_agent
3. Select the sources: select tasy_byets_review_search and tasty_bytes_business_analytics

You are now ready to demonstrate unified business intelligence through natural language.

Let's deep dive into our highest-earning markets by mapping their financial success to the voice of their customers.

Prompt:

Key insight: This analysis really shows off what Snowflake Intelligence can do! It helps us connect the dots between how much money our top cities are making and what our customers in those cities are actually saying. We can quickly see our best-performing markets by revenue, and right alongside, get a clear picture of the most common things people are talking about in their reviews. This gives us a much richer, more human understanding of what's truly driving success – or perhaps what subtle issues might be brewing – even in our strongest areas. It's all about making smarter, more informed decisions, and we get these powerful insights just by asking a simple question.

Now let's explore strategies to address these key customer pain points and develop targeted action plans to improve performance in these cities.

Prompt:

Key insight: This analysis from Snowflake Intelligence gives us a clear picture of our lowest-earning cities and, crucially, shines a light on the exact customer pain points that are holding them back. By directly connecting raw revenue numbers with specific feedback from customer reviews, we can pinpoint where we need to focus our efforts to improve service, product, or support. This provides actionable intelligence to drive targeted growth and customer satisfaction in these challenged markets, all by simply asking a natural language question.

What we've just experienced with Tasty Bytes showcases a fundamental shift in how businesses can truly understand their data. By seamlessly integrating Snowflake Cortex Search for deep dives into unstructured customer feedback and Cortex Analyst for conversational insights from structured business metrics, we've brought a truly unified business intelligence to life.

You saw firsthand the power of this integration: users of all technical levels can now simply ask natural language questions and immediately receive visually rich, actionable answers. This direct and intuitive access to insights fundamentally transforms how organizations can swiftly identify operational risks, precisely quantify financial impact, and pinpoint new growth opportunities. It's clear that Snowflake Intelligence empowers rapid, data-driven decision-making, converting what was once fragmented data into clear, compelling business advantage for everyone.

Within this vignette, we will explore some of the powerful governance features within Snowflake Horizon. We will begin with a look at Role-Based Access Control (RBAC), before diving into features like automated data classification, tag-based masking policies for column-level security, row-access policies, data quality monitoring, and finally, account-wide security monitoring with the Trust Center.

Copy and paste the SQL from this file in a new SQL File to follow along in Snowflake.

Note that once you've reached the end of the SQL File you can skip to Step 29 - Apps & Collaboration.

Snowflake's security model is built on a framework of Role-based Access Control (RBAC) and Discretionary Access Control (DAC). Access privileges are assigned to roles, which are then assigned to users. This creates a powerful and flexible hierarchy for securing objects.

First, let's set our context for this exercise and view the roles that already exist in the account.

We will now create a custom tb_data_steward role. This role will be responsible for managing and protecting our customer data.

The typical hierarchy of system and custom roles might look something like this:

Snowflake System Defined Role Definitions:

We can't do much with our role without granting privileges to it. Let's switch to the securityadmin role to grant our new tb_data_steward role the necessary permissions to use a warehouse and access our database schemas and tables.

Finally, we grant the new role to our own user. Then we can switch to the tb_data_steward role and run a query to see what data we can access.

Looking at the query results, it's clear this table contains a lot of Personally Identifiable Information (PII). In the next sections, we'll learn how to protect it.

A key first step in data governance is identifying and classifying sensitive data. Snowflake Horizon's auto-tagging capability can automatically discover sensitive information by monitoring columns in your schemas. We can then use these tags to apply security policies.

Using the accountadmin role, we'll create a pii tag in our governance schema. We will also grant the necessary privileges to our tb_data_steward role to perform classification.

Now, as the tb_data_steward, we'll create a classification profile. This profile defines how auto-tagging will behave.

Next, we'll define a mapping that tells the classification profile to apply our governance.pii tag to any column whose SEMANTIC_CATEGORY matches common PII types like NAME, PHONE_NUMBER, EMAIL, etc.

Let's manually trigger the classification process on our customer_loyalty table. Then, we can query the INFORMATION_SCHEMA to see the tags that were automatically applied.

Notice that columns identified as PII now have our custom governance.pii tag applied.

Now that our sensitive columns are tagged, we can use Dynamic Data Masking to protect them. A masking policy is a schema-level object that determines whether a user sees the original data or a masked version at query time. We can apply these policies directly to our pii tag.

We'll create two policies: one to mask string data and one to mask date data. The logic is simple: if the user's role is not privileged (i.e., not ACCOUNTADMIN or TB_ADMIN), return a masked value. Otherwise, return the original value.

The power of tag-based governance comes from applying the policy once to the tag. This action automatically protects all columns that have that tag, now and in the future.

Let's test our work. First, switch to the unprivileged public role and query the table. The PII columns should be masked.

Now, switch to a privileged role, tb_admin. The data should now be fully visible.

In addition to masking columns, Snowflake allows you to filter which rows are visible to a user with Row Access Policies. The policy evaluates each row against rules you define, often based on the user's role or other session attributes.

A common pattern for row access policies is to use a mapping table that defines which roles can see which data. We'll create a table that maps roles to the country values they are permitted to see.

Now we create the policy itself. This policy returns TRUE (allowing the row to be seen) if the user's role is an admin role OR if the user's role exists in our mapping table and matches the country value of the current row.

Apply the policy to the country column of our customer_loyalty table. Then, switch to the tb_data_engineer role and query the table.

The result set should now only contain rows where the country is 'United States'.

Data governance isn't just about security; it's also about trust and reliability. Snowflake helps maintain data integrity with Data Metric Functions (DMFs). You can use system-defined DMFs or create your own to run automated quality checks on your tables.

Let's use a few of Snowflake's built-in DMFs to check the quality of our order_header table.

We can also create custom DMFs for our specific business logic. Let's create one that checks for orders where the order_total does not equal unit_price * quantity.

Let's insert a bad record to test our DMF. Then, we'll call the function to see if it catches the error. The record we will be inserting is ordering 2 items with a unit price of $5, and a total price of $5 instead of the correct total $10.

To automate this check, we can associate the DMF with the table and set a schedule to have it run automatically whenever the data changes, then add it to the order_detail table.

The Trust Center provides a centralized dashboard for monitoring security risks across your entire Snowflake account. It uses scheduled scanners to check for issues like missing Multi-Factor Authentication (MFA), over-privileged roles, or inactive users, and then provides recommended actions.

First, an ACCOUNTADMIN needs to grant the TRUST_CENTER_ADMIN application role to a user or role. We'll grant it to our tb_admin role.

Now, navigate to the Trust Center in the Snowsight UI:

1. Click the Monitoring tab in the left navigation bar.
2. Click on Trust Center.

By default, most scanner packages are disabled. Let's enable them to get a comprehensive view of our account's security posture.

1. In the Trust Center, click the Scanner Packages tab.
2. Click on CIS Benchmarks.

3. Click the Enable Package button.

4. In the modal, set the Frequency to Monthly and click Continue.

5. Repeat this process for the Threat Intelligence scanner package.

After the scanners have had a moment to run, navigate back to the Findings tab.

This powerful tool gives you a continuous, actionable overview of your Snowflake account's security health.

In this vignette, we will explore how Snowflake facilitates seamless data collaboration through the Snowflake Marketplace. We will see how easy it is to acquire live, ready-to-query third-party datasets and immediately join them with our own internal data to unlock new insights—all without the need for traditional ETL pipelines.

Copy and paste the SQL code from this file in a new SQL File to follow along in Snowflake.

One of our analysts wants to see how weather impacts food truck sales. To do this, they'll use the Snowflake Marketplace to get live weather data from Weather Source, which can then be joined directly with our own sales data. The Marketplace allows us to access live, ready-to-query data from third-party providers without any data duplication or ETL.

First, let's set our context to use the accountadmin role, which is required to acquire data from the Marketplace.

Follow these steps in the Snowsight UI to get the Weather Source data:

1. Make sure you are using the ACCOUNTADMIN role.

2. Navigate to Data Products » Marketplace from the left-hand navigation menu.

3. In the search bar, enter: Weather Source frostbyte.

   
4. Click on the Weather Source LLC: frostbyte listing.

   

5. Click the Get button.

6. Click to expand the Options, then change the Database name to ZTS_WEATHERSOURCE.

7. Grant access to the PUBLIC role.

8. Click Get.

This process makes the Weather Source data instantly available in our account as a new database, ready to be queried.

With the Weather Source data now in our account, our analyst can immediately begin joining it with our existing Tasty Bytes data. There's no need to wait for an ETL job to run.

Let's switch to the tb_analyst role and begin exploring the new weather data. We'll start by getting a list of all distinct US cities available in the share, along with some average weather metrics.

Now, let's create a view that joins our raw country data with the historical daily weather data from the Weather Source share. This gives us a unified view of weather metrics for the cities where Tasty Bytes operates.

Using our new view, the analyst can query for the average daily temperature in Hamburg, Germany for February 2022. Run the query below, then we'll visualize this as a line chart directly in Snowsight.

1. Run the query above.
2. In the Results pane, click Chart.
3. Set the Chart Type to Line.
4. Set the X-Axis to DATE_VALID_STD.
5. Set the Y-Axis to AVERAGE_TEMP_F.

Let's take it a step further and combine our orders_v view with our new daily_weather_v to see how sales correlate with weather conditions.

Our analyst can now answer complex business questions, such as: "How does significant precipitation impact our sales figures in the Seattle market?"

Let's also visualize the results again in Snowsight, but as a bar chart this time.

1. Run the query above.
2. In the Results pane, click Chart.
3. Set the Chart Type to Bar.
4. Set the X-Axis to MENU_ITEM_NAME.
5. Set the Y-Axis to DAILY_SALES.

Our analyst now wants more insight into the specific locations of our food trucks. We can get Point-of-Interest (POI) data from Safegraph, another provider on the Snowflake Marketplace, to enrich our analysis even further.

Follow the same procedure as before to acquire the Safegraph data from the Marketplace.

1. Ensure you are using the ACCOUNTADMIN role.
2. Navigate to Data Products » Marketplace.
3. In the search bar, enter: safegraph frostbyte.
4. Select the Safegraph: frostbyte listing and click Get.
5. Click to expand the Options, then set the Database name to ZTS_SAFEGRAPH.
6. Grant access to the PUBLIC role.
7. Click Get.

Let's create a view that joins our internal location data with the Safegraph POI data.

Now we can combine all three datasets: our internal data, the weather data, and the POI data. Let's find our top 3 windiest truck locations in the US in 2022.

Finally, let's conduct a more complex analysis to determine brand resilience. We'll use a Common Table Expression (CTE) to first find the windiest locations, and then compare sales on "calm" vs. "windy" days for each truck brand at those locations. This can help inform operational decisions, like offering "Windy Day" promotions for brands that are less resilient.

Streamlit is an open-source Python library designed for easily creating and sharing web applications for machine learning and data science. It allows for the rapid development and deployment of data-driven apps.

Streamlit in Snowflake empowers developers to securely build, deploy, and share applications directly within Snowflake. This integration allows you to build apps that process and utilize data stored in Snowflake without the need of moving the data or application code to an external system.

Let's create our first Streamlit app, an app that will display and chart sales data for each menu item in Japan for February 2022.

1. First, navigate to Projects » Streamlit, then click on the blue '+ Streamlit App' button in the top right to create a new app.

2. Enter these values in the 'Create Streamlit App' pop-up:

   • App title: Menu Item Sales
   • App location:
     • Database: tb_101
     • Schema: Analytics
   • App warehouse: tb_dev_wh

3. Now click 'Create'. When the app first loads, you'll see a sample app on the right pane and the app's code in the editor pane to the left.

4. Select all of the code and remove it.

5. Next copy + paste this code in the blank editor window, then click 'Run' in the top right.

Congratulations! You have successfully completed the entire Tasty Bytes - Zero to Snowflake journey.

You have now built and configured warehouses, cloned and transformed data, recovered a dropped table with Time Travel, and built an automated data pipeline for semi-structured data. You've also unlocked insights using AI by generating analysis with simple AISQL functions and accelerating your workflow with Snowflake Copilot. Furthermore, you have implemented a robust governance framework with roles and policies and seamlessly enriched your own data with live datasets from the Snowflake Marketplace.

If you would like to re-run this Quickstart, please run the complete RESET script located at the bottom of your SQL file.