Build a complete route optimization platform in minutes using just natural language commands.

This solution builds an Open Route Service Native App directly in your Snowflake account using Cortex Code - Snowflake's AI-powered CLI. No complex setup, no external APIs, no data leaving Snowflake.

🔧 OpenRouteService Native App - A self-contained routing engine running in Snowpark Container Services with SQL-callable functions.

📍 Four Powerful Routing Functions:

📐 GeoFunctions — Each routing function also has a _GEO variant (e.g. DIRECTIONS_GEO, ISOCHRONES_GEO, OPTIMIZATION_GEO) that wraps the base function and returns the route/polygon geometry as a native Snowflake GEOGRAPHY column — ready for geospatial analysis with ST_LENGTH, ST_AREA, ST_WITHIN, and more.

🗺️ Any Location - Customize to Paris, London, New York, or anywhere in the world with downloadable OpenStreetMap data.

🧪 Function Tester - An interactive Streamlit app to test the routing functions with sample addresses.

This is what you will need:

The architecture below shows the solution which uses a native app and container services to power sophisticated routing and optimisation functions.

This is a self-contained service which is managed by you. There are no API calls outside of Snowflake and no API limitations. This solution uses a small high-memory pool (HIGHMEM_X64_S) which is capable of running unlimited service calls within San Francisco (the default map). If you wish to use a larger map such as Europe or the World, you can increase the size of the compute.

Use Cortex Code, Snowflake's AI-powered CLI, to deploy the Native App using natural language commands and automated skills.

1. Clone the repository:

   git clone https://github.com/Snowflake-Labs/sfguide-create-a-route-optimisation-and-vehicle-route-plan-simulator
   cd sfguide-create-a-route-optimisation-and-vehicle-route-plan-simulator
   

   Without Git: Download the ZIP from the repository and extract it, then navigate to the folder in VS Code

   After cloning, open the folder in VS Code. You should see the following structure in your Explorer:

   

2. Launch Cortex Code CLI in the VS Code terminal:

   cortex
   

3. Connect to Snowflake - Cortex Code will prompt you to select or create a connection. once a connection has ben created using one of the authentication methods, you will now be able to start cortex code in the terminal by using the cortex command which will give you a similar screen as below.

Before running any commands, it's helpful to understand what skills are and how they power this solution.

What are Skills?

Skills are structured specifications that instruct Cortex Code how to perform a procedure. Think of them as detailed recipes - they define the exact steps, parameters, and verification checks needed to accomplish a task. Each skill is a markdown file that describes:

Benefits of Using Skills

How This Solution Uses Skills

This repository demonstrates how skills can manage the complete lifecycle of an end-to-end Snowflake analytical solution - from installation through customization to uninstallation. There are multiple pre-built skills in the .cortex/skills/skill_name/SKILL.md:

To run any skill, simply tell Cortex Code:

For example:

Cortex Code reads the skill's markdown file and executes each step, asking for input when needed and verifying success before moving on.

Run the prerequisites check skill to ensure all dependencies are installed:

Simply type the following command in Cortex Code:

Cortex Code will automatically:

The skill will guide you through any required steps, including:

The skill uses interactive prompting to gather required information:

What gets installed:

Simply confirm each prompt as the skill progresses. The skill handles all the complex setup automatically - creating databases, uploading files, building containers, and deploying the Native App.

Once complete, you'll see a success message with a direct link to your app:

Once deployment completes, Cortex Code will provide a link to your app. You need to:

1. Navigate to Data Products > Apps > OPENROUTESERVICE_NATIVE_APP in Snowsight

2. Click on the OPENROUTESERVICE_NATIVE_APP to open it

3. Grant the required privileges and review external access

The app requires these permissions to function:

Click Grant for Step 1. For Step 2, click Review to see the external endpoints, then click Connect to allow the connection.

4. Once all privileges are granted, click Activate and wait a few minutes for the routing functions to install and the graphs to build

Once activated, you'll see a Launch app button appear. Click it to open the Service Manager.

The Launch app button takes you to the Service Manager dashboard, which displays the status of each of the four services running:

The Service Manager shows:

Use the Start All / Stop All buttons for bulk operations, or manage services individually. Click Refresh Status to update the dashboard.

The Native App is configured via the ors-config.yml file which controls:

Map Source File

The default deployment uses San Francisco. When you customize the map region, this path is updated automatically.

Routing Profiles

The configuration defines which routing profiles are available for routing:

Optimization Limits

The config also controls route optimization capacity:

These settings support complex route optimizations with many vehicles and delivery points.

The Native App includes a built-in Function Tester Streamlit application for testing the routing functions interactively.

To access the Function Tester:

1. Open Data Products > Apps > OPENROUTESERVICE_NATIVE_APP in Snowsight
2. Navigate to the Function Tester page in the app

The Function Tester allows you to test all four routing functions:

🗺️ DIRECTIONS

🚚 OPTIMIZATION

⏰ ISOCHRONES

🗺️ TIME-DISTANCE MATRIX

All routing functions are deployed as SQL functions inside the Native App and can be called directly from any Snowflake worksheet, notebook, or application. The functions live under OPENROUTESERVICE_NATIVE_APP.CORE.

Directions: Point-to-Point

Calculate a driving route between two coordinates (longitude, latitude):

Directions: Multi-Waypoint

Route through multiple stops by passing a locations object:

Isochrones

Generate a polygon showing the area reachable within 10 minutes of driving:

Optimization: Tabular

Match delivery jobs to vehicles using arrays of jobs and vehicles:

Optimization: Raw Variant

Pass a full VROOM-compatible JSON challenge:

Matrix: Tabular

Calculate the time and distance matrix between multiple locations:

Matrix: Raw Variant

Pass full matrix options for advanced control (sources, destinations, metrics):

The _GEO functions are SQL wrappers around the base functions above. All they do is:

1. Call the base function (e.g. DIRECTIONS)
2. Use TO_GEOGRAPHY() to parse the GeoJSON geometry from the VARIANT response into a native Snowflake GEOGRAPHY column
3. Extract key summary fields (distance, duration, vehicle ID, etc.) into their own columns

Why this matters: The base functions return a single VARIANT column where the route geometry is buried inside response:features[0]:geometry. The GeoFunctions extract that geometry into a dedicated GEOJSON GEOGRAPHY column for user convenience.

DIRECTIONS_GEO: Point-to-Point

DIRECTIONS_GEO: Multi-Waypoint

ISOCHRONES_GEO

OPTIMIZATION_GEO: Tabular

Returns one row per vehicle route with the route geometry as a GEOGRAPHY LineString:

OPTIMIZATION_GEO: Raw Variant

Once you have GEOGRAPHY columns from the Geofunctions, you can chain them with Snowflake's built-in geospatial functions:

Route length in kilometers:

Isochrone area in square kilometers:

Check if a point falls within an isochrone:

The default deployment uses San Francisco with standard routing profiles. You can customize two key areas for the ORS Native App:

To customize, run:

The main $customize-main skill orchestrates the process by asking two questions, then runs only the relevant sub-skills:

1. "Do you want to customize the LOCATION (map region)?"

   • If YES → Runs $customize-main/location `
   • If NO → Skips map download entirely

2. "Do you want to customize ROUTING PROFILES (vehicle types)?"

   • If YES → Runs $customize-main/routing-profiles
   • If NO → Keeps default profiles (car, HGV, electric bicycle)

Let's try changing the location to Paris. In Cortex Code, simply type:

then select location: Paris as part of the workflow.

Cortex Code will find the appropriate skill and guide you through the process:

Step 1: Location Change

Step 2: Routing Profiles

Step 3: Function Tester Update

Step 4: Build Graphs

Once the customization completes, Cortex Code shows a summary of everything that was updated:

The summary confirms:

1. ✅ Map downloaded - The Île-de-France map for the Paris region
2. ✅ Config updated - ors-config.yml now points to the new map file
3. ✅ Service spec updated - Volume paths configured for Paris
4. ✅ Services resumed - ORS_SERVICE is rebuilding routing graphs (this takes 15-30 minutes depending on map size)
5. ✅ Streamlit updated - Default location changed to "Eiffel Tower, Paris"

⏳ Wait for Services to Restart

After the map is uploaded (if location was changed) or profiles were modified (if vehicles were changed), the services need to update the routing graphs. You can monitor progress in the Service Manager:

1. Navigate to Data Products > Apps > OPENROUTESERVICE_NATIVE_APP
2. Check the Service Manager - all 4 services should show ✅ RUNNING
3. The Open Route Service will take the longest as it builds the graph files

Once services are running, the Function Tester will show Paris addresses instead of San Francisco!

You can now test the routing functions with Paris addresses. Here's an example of testing the ISOCHRONES function to calculate a 15-minute driving catchment area from the Eiffel Tower:

If you selected YES to location customization, the skill downloads OpenStreetMap data from Geofabrik or BBBike. The bigger the map file, the longer it takes to:

Automatic Compute Scaling

Cortex Code will detect the map size after download and offer to resize the compute pool to speed up graph generation:

When prompted, you can accept the scaling recommendation to ensure graphs are computed as quickly as possible. The extended auto-suspend time prevents the service from shutting down mid-build.

Routing Profile Configuration

The skill presents available routing profiles and lets you enable/disable them:

Function Tester Customization

The skill automatically updates the Function Tester Streamlit with:

Region-specific sample addresses:

Vehicle profiles dropdown:

This ensures test addresses are valid for your map region and vehicle options match your configuration.

Once your services are running with the new map (or if you skipped customization), you're ready to deploy the demo!

🎉 Congratulations! Your Routing Solution is now installed and configured.

To deploy the Route Optimization demo with real-world POI data and interactive notebooks, continue to the next quickstart: 👉 Deploy Route Optimization Demo

The demo quickstart will:

All demo content will use your configured map region (San Francisco by default, or your customized region like Paris).

Cortex Code makes uninstallation simple with natural language commands.

To remove the Snowflake objects installed as part of the demo you can type in Cortex Code CLI:

This will:

You've just deployed a self-contained routing solution in Snowflake using natural language commands - no complex configuration files, no external API dependencies, and no data leaving your Snowflake environment.

This solution demonstrates the power of combining:

The key advantage of this approach is flexibility without complexity. Want to switch from San Francisco to Paris? Just run the location customization skill. Need to add walking or cycling routes? Enable additional routing profiles. The skill-based approach means you only run the steps you need.

Deploy the demo to see the routing functions in action with real-world POI data:

👉 Deploy Route Optimization Demo