Snowflake

Learn how to create a sticky data reward reward program for you users and a new revenue channel for your business using TIKI + Snowflake's Marketplace.

Offer users benefits like cash back, loyalty points, or subscription discounts in exchange for data monetization rights, opening a low friction revenue stream for your business.

Let's dive in

Takes under an hr. to build

First, you'll need to decide on your user incentive program —popular choices are loyalty points, in-app cash, and product/subscription discounts. Ultimately it's up to you to decide what the offer is, and your users to decide if it's fair.

We do recommend selecting a reward program connected to one of your existing incentive programs. It's tends to be easier for users to understand, and much easier to implement.

Create the Offer

🌴

For the following examples, we will be using the configurable TIKI Pre-built UI (fast af). But, feel free to build a killer custom offer flow the SDK (likely more than an hr. lol)

You'll need to decide of a couple of marketing assets for the Offer.

1. The Reward Image —named that because it should describe the user's reward in exchange for participating in the program. Resolution of 300x86.

For example:

2. A text Description of the program —up to 3 lines, adding additional details about your program.

For example:
Did you know you can partially pay for a premium subscription with your data?

3. Bullets (3x) explaining to the user how their data will or will NOT be used

For example:

• Yes: Aggregated and anonymized
• Yes: Sold to AI co's to pay your bill
• No: Used to target and follow you

The last part of the Offer is the official legal terms of the deal, aka the User Data License Agreement (UDLA). The agreement becomes the official legal document under the covers that makes these types of programs possible.

If you intend to draft your own UDLA, please review our guidelines for drafting an effective agreement. Or, we have a boilerplate agreement as a template you can quickly modify for your use case.

🌴

UDLAs are digitally signed by both your business and your users. However like everything TIKI, it's programmatic and automated. This is not like docusign, where your team will be tied up for months processing millions of signatures 😅.

Add the TIKI SDK

Alright! With your new data reward program designed, use the TIKI SDK to add the offer to your app or website.

Supported Libraries:

iOS →

Android →

Flutter →

Web →

Configure the SDK with your new Offer details and optionally set a Theme to match your app.

window.TikiSdk.config()
  .offer
    .ptr('PTR RECORD')
    .description("Did you know you can partially pay for a premium subscription with your data?")
    .use({ usecases:[TikiSdk.LicenseUsecase.distribution()], destinations:["app.snowflake.com"] })
    .bullet({ text: 'Aggregated and anonymized', isUsed: true })
    .bullet({ text: 'Sold to AI co\'s to pay your bill', isUsed: true })
    .bullet({ text: 'Used to target and follow you', isUsed: false })
    .tag(TikiSdk.TitleTag.productInteraction())
    .reward('reward.png')
    .terms('terms.md')
    .add()
  .initialize('PUBLISHING ID', 'USER ID')

init() {
  try? TikiSdk.config()
        .offer
            .ptr("PTR RECORD")
            .description("Did you know you can partially pay for a premium subscription with your data?")
            .use(usecases: [.distribution], destinations: ["app.snowflake.com"])
            .bullet(text: "Aggregated and anonymized", isUsed: true)
            .bullet(text: "Sold to AI co's to pay your bill", isUsed: true)
            .bullet(text: "Used to target and follow you", isUsed: false)
            .tag(.productInteraction)
            .reward("reward")
            .terms("terms.md")
            .add()
        .initialize(publishingId: "PUBLISHING ID", id: "USER ID")
}

override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  TikiSdk
    .offer
      .ptr("PTR RECORD")
      .description("Did you know you can partially pay for a premium subscription with your data?")
      .use(listOf(LicenseUsecase.DISTRIBUTION), listOf("app.snowflake.com"))
      .bullet("Aggregated and anonymized", true)
      .bullet("Sold to AI co's to pay your bill", true)
      .bullet("Used to target and follow you", false)
      .tag(TitleTag.PRODUCT_INTERACTION)
      .reward(ResourcesCompat.getDrawable(resources, R.drawable.reward, null)!!)
      .terms(this,"terms.md")
      .and()
    .initialize(this, "PUBLISHING ID", "USER ID")
}

void main() async {
  await TikiSdk.config()
    .offer
        .ptr("PTR RECORD")
        .description("Did you know you can partially pay for a premium subscription with your data?")
        .use([LicenseUsecase.distribution()], ["app.snowflake.com"])
        .bullet("Aggregated and anonymized", true)
        .bullet("Sold to AI co's to pay your bill", true)
        .bullet("Used to target and follow you", false)
        .tag(TitleTag.productInteraction())
        .reward(Image.asset("assets/images/reward.png"))
        .terms("assets/terms.md")
        .add()
    .initialize("PUBLISHING ID", "USER ID");
} 

In addition to your Offer marketing assets, you'll need to define some key metadata.

• PTR record —the unique identifier for the data you're licensing. This identifier will be used by the Snowflake integration to lookup licenses, so make sure to pick a good one! The easiest is your system's internal user id (FYI, we hash all PTRs), but other common ones are things like MAIDS (GAID/IDFA) and billing ids.
• Usecases —the metadata describing the use case for the license. In this case, it's "distribution" since you're going to be listing the data on Snowflake's Marketplace. If you intend to do other things with the same dataset, like create analytics, you can include them in the array.
• Destinations —an optional field narrowing where the data license may be applied (e.g. "app.snowflake.com"). Narrow is usually better when it comes to security/privacy, but if you're unsure just remove it entirely (null) to skip it.
• Tag —an optional field(s) to add metadata tags describing the data set. They will not be used in this example, but they always seem to come in handy, so we suggest setting at least one.

Next, let's call initialize. It requires just 2 parameters:

• Publishing ID — Get one for free at console.mytiki.com by creating a Project.
• User ID — Your internal User ID.

Done! Call TikiSdk.present() to see your hard work.

Connect Reward Program

Connecting your reward program is a piece of cake. Just use the onAccept event handler to call your function.

TikiSdk.config()
  .onAccept((offer, license) => {
// Notify the backend of the opt-in
})

TikiSdk.config()
    .onAccept { offer, license in
// Notify the backend of the opt-in
    }
})

TikiSdk.config()
  .onAccept{ offer, license -> {
// Notify the backend of the opt-in
  }}
)

TikiSdk.config()
  .onAccept((offer, license) => {
// Notify the backend of the opt-in
})

Collect Zero-party Data

If you're already collecting zero-party data as part of your app's normal use, you can skip this part.

If not, add API calls to publish the new datasets to your backend. Then just wrap your PPI calls in TIKI's guard function to only publish in accordance with the license terms.

TikiSdk.guard("PTR RECORD", [TikiSdk.LicenseUsecase.distribution()], ["app.snowflake.com"], () => {
// Your API Call
})

TikiSdk.guard(ptr: "PTR RECORD", usecases: [.distribution], destinations: ["app.snowflake.com"]) {
// Your API Call
}

TikiSdk.guard("PTR RECORD", listOf(LicenseUsecase.DISTRIBUTION), listOf("app.snowflake.com"), onPass = {
// Your API Call
})

TikiSdk.guard("PTR RECORD", [LicenseUsecase.distribution()], destinations: ["app.snowflake.com"], onPass: () => {
// Your API Call
});

Set up Snowflake Integration

First, clone the Integrations Repository and open the snowflake project (cd snowflake).

Configure

Add your TIKI API Key to tiki.js

const keyId = "API KEY ID";
const keySecret = "API KEY SECRET";

Add any additional static filters to include WITH your PTR filer in index.js. DO NOT comment out the empty ptr array initialization ptrs: [].

const filters = {
    ptrs: [],
    // tags: [],
    usecases: ["distribution"],
    // destinations: [],
  };

Deployment

Note: This part is easy, but requires focus. It's easy to screw up.

Using CloudFormation, you first deploy the API Gateway/Lambda and then link the function to Snowflake.

They have an excellent step-by-step guide for you to follow, which we STRONGLY recommend following —we structured this integration to pair with the instructions.

Creating an External Function for AWS Using an AWS CloudFormation Template →

There are only 2 minor differences:

1. Instead of using their example CloudFormation template, use our template.
2. Instead of inline-code in the CloudFormation template, ours requires the code to be hosted in an S3 Bucket.
   1. Run npm install; npm pack to generate the deployment asset (/deploy/package.zip).
   2. Upload deploy/package.zip to your S3 Bucket. When you run the CloudFormation template in AWS, it will prompt you for the Bucket Name and Key.

The result, given a Table like:

SELECT * FROM demo;

Where PTR abcde has a valid data license and 12345 does not. Adding the external function to a WHERE clause to returns:

SELECT *
FROM demo
WHERE integrationFnName(ptr) = true;

Publish to Marketplace

Exciting! Last step. Use a normal SQL query to define the dataset(s) you'd like to publish adding the WHERE integrationFnName(ptr) = true; clause to filter the set by users who've agreed to the license terms.

After that it's as simple as filling out Snowflake's Marketplace listing form to submit your data to the marketplace for buyers.

Happy users & happy bottom line 🍹.

Love the integration but found the instructions hard to follow? We're here to help!

👾 Pop into our Discord

📅 Chat with Mike

🍻

Special thanks to Andrew & Kyle from Snowflake for their help