Offer targeting for retailers

Give the code to the shopper who keeps coming back to the price

A shopper has opened the same jacket three times this visit, scrolled to the price each time and left the page without adding it. The site-wide code went out in this morning's email to everyone, before anyone could tell this shopper from the one who bought on the first look. The third return to the price is the moment to make the offer. The rules can only make it then if they see it while the shopper is still on the product page.

What Signals knows

product_views_session: How many times they opened each product this visit
adds_session: Items added to the cart this visit

What your offer rules do

Shows a code on the product page once a shopper has opened the same product three times this visit with nothing in the cart, and keeps the site-wide banner closed for everyone who has not.

product.tsx · 13 lines

from snowplow_signals import (
    Attribute, EntityProperty, Event, StreamAttributeGroup, domain_sessionid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
add_to_cart = Event(name="add_to_cart", vendor="com.example", version="1-0-0")
product_id = EntityProperty(vendor="com.example", name="product", major_version=1, path="id")

product_views_session = Attribute(
    name="product_views_session",
    type="dict",
    events=[page_view],
    aggregation="category_count",
    property=product_id,
)

adds_session = Attribute(
    name="adds_session",
    type="int32",
    events=[add_to_cart],
    aggregation="counter",
    default_value=0,
)

# Keyed on the visit, so the count resets when the shopper comes back another day.
shop_offers_hesitating = StreamAttributeGroup(
    name="shop_offers_hesitating",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[product_views_session, adds_session],
)

// In the code that renders the product page
const shopper = await signals.getServiceAttributes({
  name: "shop_offers_hesitating",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { product_views_session: { "sku-4471": 3, "sku-2210": 1 }, adds_session: 0 }

const looks = shopper.product_views_session[productId] ?? 0;

if (looks >= 3 && shopper.adds_session === 0) {
  offers.show({ kind: "code", product: productId, placement: "price" });
}

Hold the code from the shopper who has decided

A shopper landed on a product from search, read the page once and added it to the cart at full price. The site-wide code reaches them anyway, in the banner, in the cart and again at checkout, because it went out before anyone could tell them from the shopper who is still deciding. The discount lands on a sale that was going through without it, and the margin goes with it.

What Signals knows

adds_session: Items added to the cart this visit
products_viewed_session: How many different products they opened this visit

What your offer rules do

Keeps the code banner and the promo field closed for a shopper who added on the first look, and lets the order go through at full price.

product.tsx · 11 lines

from snowplow_signals import (
    Attribute, EntityProperty, Event, StreamAttributeGroup, domain_sessionid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
add_to_cart = Event(name="add_to_cart", vendor="com.example", version="1-0-0")

adds_session = Attribute(
    name="adds_session",
    type="int32",
    events=[add_to_cart],
    aggregation="counter",
    default_value=0,
)

products_viewed_session = Attribute(
    name="products_viewed_session",
    type="int32",
    events=[page_view],
    aggregation="approx_count_distinct",
    property=EntityProperty(vendor="com.example", name="product", major_version=1, path="id"),
)

shop_offers_decided = StreamAttributeGroup(
    name="shop_offers_decided",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[adds_session, products_viewed_session],
)

// In the code that renders the product page and the cart
const shopper = await signals.getServiceAttributes({
  name: "shop_offers_decided",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { adds_session: 1, products_viewed_session: 1 }

if (shopper.adds_session >= 1 && shopper.products_viewed_session <= 1) {
  offers.suppress({ scope: "session", reason: "added_at_full_price" });
}

Start with a smaller nudge for a shopper who keeps coming back

A shopper has opened the same pair of boots on three visits over two weeks and has not added them once. The retargeting ad and the browse-abandon email both carry the full code, so the first touch spends the whole discount without knowing whether this shopper would have moved for less. Free delivery or a low-stock note is the smaller ask. The code waits until they come back once more and stall again.

What Signals knows

product_views_30d: How many times they opened each product in the last 30 days
visits_30d: Separate visits in the last 30 days
adds_30d: Items added to the cart in the last 30 days

What your offer rules do

Shows free delivery on the product page when a shopper has opened the same product across three visits without adding it, and moves to a code only when they come back a fourth time and still have not added it.

product.tsx · 14 lines

from datetime import timedelta
from snowplow_signals import (
    Attribute, AtomicProperty, EntityProperty, Event, StreamAttributeGroup, domain_userid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
add_to_cart = Event(name="add_to_cart", vendor="com.example", version="1-0-0")

product_views_30d = Attribute(
    name="product_views_30d",
    type="dict",
    events=[page_view],
    aggregation="category_count",
    property=EntityProperty(vendor="com.example", name="product", major_version=1, path="id"),
    period=timedelta(days=30),
)

visits_30d = Attribute(
    name="visits_30d",
    type="int32",
    events=[page_view],
    aggregation="approx_count_distinct",
    property=AtomicProperty(name="domain_sessionid"),
    period=timedelta(days=30),
)

adds_30d = Attribute(
    name="adds_30d",
    type="int32",
    events=[add_to_cart],
    aggregation="counter",
    period=timedelta(days=30),
    default_value=0,
)

# Keyed on the browser, so the same shopper is recognized across visits without logging in.
shop_offers_returning = StreamAttributeGroup(
    name="shop_offers_returning",
    version=1,
    attribute_key=domain_userid,
    owner="you@example.com",
    attributes=[product_views_30d, visits_30d, adds_30d],
)

// In the code that renders the product page
const shopper = await signals.getServiceAttributes({
  name: "shop_offers_returning",
  attribute_key: "domain_userid",
  identifier: domainUserId,
});
// { product_views_30d: { "sku-8812": 3 }, visits_30d: 3, adds_30d: 0 }

const looks = shopper.product_views_30d[productId] ?? 0;

if (looks >= 3 && shopper.visits_30d >= 3 && shopper.adds_30d === 0) {
  const kind = shopper.visits_30d >= 4 ? "code" : "free_delivery";
  offers.show({ kind, product: productId, placement: "price" });
}

Keep a second code off an order that has one

A shopper arrived from a coupon site, applied the code they found there and has filled a cart. The exit offer and the checkout banner were set up for a shopper about to leave empty-handed, and they fire on the way to checkout without knowing a code is on the order. Two discounts land on an order that was going through with one.

What Signals knows

coupons_applied_session: Coupon codes applied this visit
entered_from: The campaign medium on their first page view
adds_session: Items added to the cart this visit

What your offer rules do

Closes the exit offer and the checkout code banner for a shopper who has a coupon on the order, and leaves the code they brought with them to stand alone.

checkout.tsx · 11 lines

from snowplow_signals import (
    Attribute, AtomicProperty, Event, StreamAttributeGroup, domain_sessionid,
)

page_view = Event(name="page_view", vendor="com.snowplowanalytics.snowplow", version="1-0-0")
add_to_cart = Event(name="add_to_cart", vendor="com.example", version="1-0-0")
coupon_applied = Event(name="coupon_applied", vendor="com.example", version="1-0-0")

coupons_applied_session = Attribute(
    name="coupons_applied_session",
    type="int32",
    events=[coupon_applied],
    aggregation="counter",
    default_value=0,
)

entered_from = Attribute(
    name="entered_from",
    type="string",
    events=[page_view],
    aggregation="first",
    property=AtomicProperty(name="mkt_medium"),
)

adds_session = Attribute(
    name="adds_session",
    type="int32",
    events=[add_to_cart],
    aggregation="counter",
    default_value=0,
)

shop_offers_stacked = StreamAttributeGroup(
    name="shop_offers_stacked",
    version=1,
    attribute_key=domain_sessionid,
    owner="you@example.com",
    attributes=[coupons_applied_session, entered_from, adds_session],
)

// In the code that renders checkout and the exit offer
const shopper = await signals.getServiceAttributes({
  name: "shop_offers_stacked",
  attribute_key: "domain_sessionid",
  identifier: sessionId,
});
// { coupons_applied_session: 1, entered_from: "affiliate", adds_session: 4 }

if (shopper.coupons_applied_session > 0) {
  offers.suppress({ scope: "checkout", reason: "coupon_on_order", via: shopper.entered_from });
}

A discount that goes to the shopper who needs it.

Spend less on discounts by giving the code to the shopper who is hesitating.

Give the code to the shopper who keeps coming back to the price

Hold the code from the shopper who has decided

Start with a smaller nudge for a shopper who keeps coming back

Keep a second code off an order that has one

Try it on your own site.