Hightouch Rewind: How we did it

Who doesn't love getting their Spotify Wrapped every year? We decided to build our own version for Hightouch customers so they could see a fun summary of their product activity each year.

The purpose of this playbook is to showcase the actual steps we took to create our very own “Hightouch Rewind” campaign! There are ten steps, but you’ll see that most are pretty quick and easy to implement.

Here’s an example of what our customers get in their inboxes, celebrating all they were able to accomplish through their use of Hightouch throughout the year:

1. Collect, store, and model product usage data in a data warehouse (we use Snowflake)
2. Connect Hightouch to your data warehouse to activate that data
3. Sync that data to an email platform where you can build dynamic emails (we use HubSpot)

First, we had to ensure we had all the requisite raw product data in Snowflake. In this case, we did, but we would have had to identify and include new data in our Fivetran syncs to our warehouse if we didn't. Here is a simplified ERD representing some of the entities involved from our product database.

Once we were sure we had all the raw data we wanted to use in Snowflake, we proceeded to the modeling stage of the project. Modeling is actually the most complicated step in this process.

In this case, much of the data we needed was already robustly modeled in our dbt project. Beyond some light modifications, all we had to do was create a new model highlighting the exact product usage stats we wanted to share with each user, with exactly one record for each recipient (email address) in the cohort we wanted to target.

It doesn’t make sense to show the entire file, so below is an example of the final select statement and a few notable bits of configuration from the beginning of the file.

The final select statement:

select
   {{ rewind_campaign_year }} as rewind_campaign_year
   , email
   , organization_id
   , total_users as current_workspace_collaborators
   , total_active_destinations as current_active_destinations
   , total_enabled_syncs as current_enabled_syncs
   , new_audiences_created_ytd as ytd_audiences_created
   , new_sync_runs_completed_ytd as ytd_sync_runs
   , new_operations_completed_ytd as ytd_records_synced
   , new_rows_queried_ytd as ytd_rows_queried
from
   paid_active_with_emails

Note that we created a variable for the “campaign year” to make it easier to adjust this value model-wide should we change our campaign's timing (we plan to run near year-end). We also materialize this model as a view because it would waste time and resources to materialize it as a table since we only use it about once a year.

{{ config (materialized='view') }}

{% set rewind_campaign_year = 'date_part(''year'', current_date)' %}

We already had our data warehouse set up as a source in our Hightouch workspace, but if we were starting from scratch, it wouldn’t take long to configure Snowflake as a source. All you have to do is provide your credentials in Hightouch and configure what warehouse and database your want Hightouch to query. Instructions for setting up Snowflake as a source can be found in our docs.

"Models" in Hightouch are the subsets of data that you'll sync to end destinations. There are many ways you can create models, including our no-code audience builder, raw SQL, or taking advantage of our native integrations with tools like Looker and dbt. In order to sync product usage data to our email tool, we needed to create a model that contained this data for each customer.

In this scenario, we chose to leverage Hightouch’s dbt integrations and use a dbt-based model. There were a few advantages to this model type. Firstly, Hightouch can add a dbt exposure to your project to identify the syncs powered by dbt models. Hightouch also integrates with Github to provide PR checks and warn developers before making a breaking change to that Hightouch sync from the dbt project.

Since we had already set up our integration between Hightouch and our dbt project, we simply had to select the dbt model we built for this campaign from the Hightouch UI when we set up the Hightouch model.

We use Hubspot to send some of our marketing emails, so we already had it set up as a destination in our Hightouch workspace. Connecting HubSpot as a source is simple and faster than most source setups. All you have to do is provide a few credentials.

When creating this sync, we defined the fields we wanted to pull in from the model and how we wanted to map them in HubSpot. We chose to map directly to Contact objects. Here is an example of the mapping:

Step 7: Test the sync

Hightouch has convenient and flexible testing features that gave us a chance to test our sync without running it fully. We could select the exact record we wanted to sync and even modify values on the fly if needed. Once we ran the test sync from Hightouch, the desired data was properly synced to Hubspot.

Any email creative will do, but each time your email references a piece of content specific to a user (e.g., dynamic content), it will need to leverage templating language to pull in the various variables. In the case of HubSpot, it’s easy to create dynamic fields in a bespoke email template. Once we configured our template, we sent tests to ourselves to ensure it looked good!

For this use case, we only ran the sync once manually. However, if we wanted to update it on a recurring schedule (e.g., for a weekly or monthly campaign), Hightouch allows us to do that as well.

Once we had built our Hubspot email template and we were ready to send our Hightouch Rewind email, we ran our sync manually with a single click. We could have set up a HubSpot workflow to trigger our customers once their data arrived, but we decided to manually trigger our HubSpot campaign.

Modern marketing teams are constantly looking for new opportunities to connect on a deeper level with their customers. Many companies like Spotify, Uber, Grammarly, and now Hightouch, turn to product utilization campaigns to deliver hyper-personalized experiences that inform and excite their users by leveraging their product interaction data.

Thanks to Composable CDPs like Hightouch, now any company can activate data directly from their cloud data warehouse and sync it to frontline marketing tools so teams can deliver personalized omnichannel experiences.

Building product utilization emails has never been easier. If you want to get started with your own, you can create a free Hightouch account or request a demo.