How to Set Up Coalesce for Data Transformation

Coalesce is a GUI-first data transformation platform that generates and runs SQL pipelines directly inside Snowflake, Databricks, or Microsoft Fabric. Unlike writing dbt models in a text editor, Coalesce gives you a visual node graph where each step — source, stage, dimension, fact — is a draggable object that Coalesce compiles into warehouse-native SQL.

This guide walks you through connecting your warehouse, setting up your first transformation pipeline, deploying to production, and understanding when Coalesce fits your stack better than alternatives.

What Coalesce Does Differently

Most transformation tools fall into one of two camps: pure code (dbt, SQLMesh) or no-code BI layers (Looker, Tableau). Coalesce sits between them. You work in a visual canvas, but every node is backed by real SQL that you can inspect, override, and version-control via Git.

The practical difference shows up in team size and skill distribution. A dbt project requires every contributor to be comfortable writing Jinja-templated SQL models in a code editor. Coalesce lets an analyst with working SQL knowledge build pipelines visually while an engineer reviews the generated SQL in Git before promotion to production. According to Coalesce's own benchmark data, teams building their first pipeline in Coalesce hit production in an average of 3 days versus 2 to 3 weeks for comparable dbt projects built from scratch.

Coalesce currently supports three warehouse targets: Snowflake (its primary platform), Databricks, and Microsoft Fabric. This matters for teams running mixed workloads or planning a migration — the same pipeline graph can be retargeted without rewriting transformation logic.

Prerequisites

Before starting, you need three things: a Coalesce account (free trial available at coalesce.io), a Snowflake or Databricks or Microsoft Fabric account, and Google Chrome. Coalesce's build interface officially supports only Chrome. Using Safari or Firefox will cause rendering issues in the node graph.

If you are testing without real company data, Snowflake provides sample data (SNOWFLAKE_SAMPLE_DATA) in every account by default. The quickstart in this guide uses that dataset.

Step 1: Connect Your Warehouse

After signing in to Coalesce, you land on the Projects Dashboard. You will see a default project and a Development Workspace. Click Launch to open the workspace.

To connect your data warehouse:

1. Click the cogwheel icon labeled Build Settings in the top navigation.
2. Go to Development Workspaces and click the pencil icon next to your workspace.
3. Under Settings, enter your Snowflake account identifier. You find this in Snowflake's account selector in the lower-left corner — it looks like xy12345.us-east-1.
4. Under User Credentials, enter your Snowflake username and password.
5. Click Test Connection. A green checkmark confirms a working connection. Click Save.

For Databricks, the process is the same but you supply a Databricks host URL, HTTP path (from your SQL warehouse settings), and a personal access token instead of a password.

Step 2: Configure Storage Locations

Storage locations are the logical names Coalesce uses to reference databases and schemas in your warehouse. They keep pipeline logic portable — changing the underlying database name means updating the storage mapping once, not hunting through dozens of SQL files.

For a new Snowflake setup:

1. Go to Build Settings > Storage Mappings.
2. You will see two default locations: SAMPLE and WORK.
3. Map SAMPLE to the SNOWFLAKE_SAMPLE_DATA database and schema TPCH_SF1.
4. Map WORK to a target database and schema you control (for example, ANALYTICS.DEV).

The SAMPLE location is read-only source data. The WORK location is where Coalesce will write your transformed tables during development.

Step 3: Add Source Nodes

The Node Graph is Coalesce's canvas. Each box is a node: a source, a stage, a dimension, or a fact. Arrows show dependencies and data flow.

To add source tables:

1. In the left sidebar, expand Nodes.
2. Click the + button and choose Add Sources.
3. Browse your mapped storage locations, select the tables you want (for example, CUSTOMER, ORDERS, and NATION from TPCH_SF1), and click Add Sources.

You will see three source nodes appear on the canvas. Source nodes are read-only references — Coalesce does not write to them.

Step 4: Create a Stage Node

Stage nodes are intermediate transformation steps. This is where most SQL logic lives: cleaning, renaming, casting, filtering, and joining.

To create a stage node from NATION:

1. Right-click the NATION source node and choose Add Node > Stage Node.
2. Double-click the new node to open the Node Editor.
3. In the Mapping grid, find the column N_NAME.
4. Double-click the Transform cell for that column and enter LOWER("NATION"."N_NAME").
5. Set Storage Location to WORK.
6. Click Create, then Run.

Coalesce will generate and execute a CREATE TABLE statement with your transformation applied. You can preview the result directly in the Node Editor output panel — no need to open a separate SQL client.

Any Snowflake-native function works here: date truncation, JSON extraction with PARSE_JSON, conditional logic with CASE WHEN, and window functions like ROW_NUMBER() OVER (PARTITION BY...). The transform field accepts standard SQL expressions, not a proprietary syntax.

Step 5: Build a Dimension Table

Dimension tables track entity data — customers, products, regions. Coalesce has a built-in Dimension node type that handles Type 1 (overwrite) and Type 2 (slowly changing, historical) patterns automatically.

To create a Type 2 dimension for customers:

1. Right-click CUSTOMER and create a Stage Node named STG_CUSTOMER. Click Create and Run.
2. From the canvas, right-click STG_CUSTOMER and choose Add Node > Dimension Node.
3. Open the DIM_CUSTOMER node editor.
4. Under Options > Business Key, add C_CUSTKEY. This is the unique identifier for each customer.
5. Under Change Tracking, add C_ADDRESS and C_PHONE. These are the columns Coalesce will track for changes over time.
6. Click Create and Run.

With those two settings, Coalesce automatically generates a Type 2 SCD table — new rows for changed addresses or phone numbers, with effective date columns and a surrogate key. Writing this logic manually in SQL takes roughly 40 to 60 lines. In Coalesce it is a checkbox.

Step 6: Create a Fact Table

Fact tables store transactional data linked to dimensions via foreign keys. The Coalesce Fact node handles merge logic (insert-or-update based on a business key) without custom SQL.

To build a fact table for orders:

1. Create a Stage Node from ORDERS named STG_ORDERS.
2. In the STG_ORDERS editor, delete all columns except O_ORDERKEY, O_CUSTKEY, and O_TOTALPRICE.
3. From the left panel, drag DIM_CUSTOMER_KEY from your DIM_CUSTOMER node into the STG_ORDERS mapping grid.
4. Go to the Join tab, clear any existing SQL, and click Generate Join. Replace the /_COLUMN_/ placeholder with O_CUSTKEY.
5. Click Create and Run on STG_ORDERS.
6. Right-click STG_ORDERS and add a Fact Node named FCT_ORDERS.
7. Under Options > Business Key, add O_ORDERKEY.
8. Click Create and Run.

Coalesce generates a MERGE statement that upserts rows based on O_ORDERKEY. You can verify the output by running this query directly in Snowflake:

SELECT DIM.C_NAME AS CUSTOMER_NAME,
       SUM(FCT.O_TOTALPRICE) AS TOTAL_PRICE
FROM ANALYTICS.DEV.FCT_ORDERS FCT
INNER JOIN ANALYTICS.DEV.DIM_CUSTOMER DIM
  ON FCT.DIM_CUSTOMER_KEY = DIM.DIM_CUSTOMER_KEY
GROUP BY DIM.C_NAME;

Step 7: Deploy to Production

Everything above runs in your Development Workspace. To promote to production:

1. Click the Deploy tab in the top navigation.
2. Create a Production Environment, mapping storage locations to your production database and schema (for example, ANALYTICS.PROD).
3. Select the nodes you want to deploy and click Deploy.

Coalesce runs the same SQL it generated in development against your production storage locations. No manual copy-paste, no environment-specific SQL edits. If you have connected Git (GitHub, GitLab, or Azure DevOps), the deployment can be triggered via CI/CD pipeline instead of the UI.

For teams with separate QA environments, you create an additional environment with its own storage mapping between Dev and Prod. The same node graph targets all three without changes.

When Coalesce Fits Your Stack

Coalesce makes the most sense for three situations. First, mixed-skill data teams where analysts own transformation logic but need engineers to review and promote it. The visual canvas gives analysts confidence without writing raw Jinja, while the Git-backed SQL gives engineers the review surface they need.

Second, Snowflake-heavy organizations already buying into the Snowflake ecosystem — Coalesce has a Partner Connect integration that provisions a trial account in under five minutes.

Third, teams migrating from legacy ETL tools like Informatica or Talend to a warehouse-native pattern. The visual metaphor maps closely enough to what they already know that onboarding time is short.

Coalesce is less suited to teams who live in the terminal and want pure-code workflows, or teams running open-source stacks where paying for managed tooling is not an option.

If you want to explore the transformed data without setting up a separate BI tool, VSLZ lets you upload or connect the output tables and run plain-English queries directly against them — useful for validating pipeline output before promotion to production.

Summary

Coalesce gives you a visual DAG interface over warehouse-native SQL, with built-in node types for dimensions, facts, and slowly changing dimensions. The setup takes under 30 minutes for a Snowflake connection, and a working fact table with SCD Type 2 tracking can be running in under two hours. The deployment model — environment-based storage mappings plus Git integration — handles the dev-to-prod promotion that makes most visual tools impractical for production use.