SGA on Shopify — Solution Blueprint

Recreating VShred's SGA funnel natively on Shopify: how it works, how it maps from the current system, and what to build. The whole funnel — quiz → VSL → checkout → upsells — on Shopify.

The approach — three systems on native Shopify primitives

Routing

Which page comes next

A resolver evaluates each step's conditions and returns the next page — spanning the whole funnel, quiz → upsells.

macro cart ownership geo
Charging

Vault once, charge per step

A $0 selling plan vaults the card at checkout; each upsell is a billing attempt against the contract. No re-collecting payment.

the piece a page-by-page build doesn't reach · proven in the POC
Measurement

Emit per step — you keep your warehouse

Customer Events emit at each step to an endpoint you own → Snowflake. Funnel Progression, Survey GA, Klaviyo don't move.

Shopify feeds your existing stack
The commitment underneath all three: the funnel is editable config read by the resolver at runtime, not hard-coded flow — so routing and A/B change without a deploy, and the whole Survey GA funnel runs on one model instead of disconnected pages.

How it maps from the current system

A port of the existing model onto Shopify primitives — the concepts survive one-to-one, not a foreign rebuild.

Today (LE / Laravel)
On Shopify
Sales Funnel sequence of routes
funnel config Shopify metaobjects — a funnel + ordered step definitions, edited in admin
Route one URL / step
a step record a funnel_node metaobject — slug + before / after / variants / track as JSON fields
Page versions weight + control
A/B variants on a step variant pool on the step; the assigned group rides as a cart attribute the resolver reads
Before/After-visit conditions engine
the resolver a small app-proxy service that reads the cached config JSON and decides the next page at each hop
Card charging on the funnel
selling-plan abstraction + billing attempts $0 selling plan → SubscriptionContract (card vaulted) → subscriptionBillingAttemptCreate per step
Interaction ledger → Snowflake
Customer Events → your endpoint → Snowflake Web Pixels / Customer Events → your Track API v2 or lambda → SQS → Snowflake
Survey GA / Funnel Progression · Klaviyo
unchanged — you keep them fed by the Customer Events above; receipts/marketing still Klaviyo

The condition vocabulary is theirs, extracted from the live decision tree — geo, cart-SKU/product, ownership, the quiz macro (gender + goal). We're re-expressing rules they already run, not inventing them.

How it works, end to end

1
Quiz sets the macro
gender + goal (e.g. female / get-toned); the resolver routes to the right VSL — routing fires in the upper funnel, not only upsells.
2
Checkout vaults the card
the $0 selling plan opens a subscription contract and vaults the card; the macro carries across.
3
Session starts
first upsell action mints a token → a fast session store holds the macro, position, and which vaulted card.
4
Resolver decides each step
entry (skip/redirect) → A/B variant (weighted, sticky) → exit (which page next, on the cart).
5
Quick buy
accepting an offer is a real billing attempt against the vaulted card; the purchase is recorded.
6
Events emit
impression / decision / purchase / drop-off, tagged funnel · step · variant · macro · SKUs · revenue → your endpoint → Snowflake.
7
Consolidated receipt
purchases consolidated into one receipt, auto-totaled, confirmation via Klaviyo.

The components to build

1

Subscription & card vault

$0 selling plans + card vaulting so later steps can charge — selling-plan groups → subscription contract.

net-new · POC exists
2

Checkout extension + session start

First upsell action kicks off the funnel and mints the session token.

net-new · POC exists
3

Session state store

Fast server-side store (e.g. Redis) holding the macro, sticky A/B groups, position — off Shopify's hosting.

net-new · the new foundation
4

Resolver (+ authorization)

The decision engine — entry gating and exit routing; the A/B group picks which rule-set.

net-new · mapped in most detail
5

Quick buy / charge

Each accept is a billing attempt against the vaulted card; records the purchase.

net-new · POC exists
6

A/B assignment

Weighted, sticky, step-level tests; the group is a cart attribute the resolver reads.

config + integration
7

Event emission & tracking

Customer Events emit per step, tagged, to your ingest endpoint → your warehouse.

net-new emission · warehouse unchanged
8

Receipt, consolidation & email

Consolidate in-funnel purchases into one receipt, auto-total, send via Klaviyo.

net-new · mirrors current behavior

The data shape — one step, as data

A step is four config blocks. Real example: the burn step, from the live rules.

us/burn · upsell
before
gate on arrival
segment / geo → skip or redirect
variants
A/B — which version
weighted pool, sticky
after
route on action
cart → next page, else fallback
track
emit events
impression · decision · conversion
{
  "slug": "us/burn", "type": "upsell",
  "before": [
    { "when": {"is":"macro","gender":"female","goal":"get-toned"}, "goto":"us/burn-gt" },
    { "when": {"is":"geo_not","countries":["US"]},                 "goto":"us/ht-call" }
  ],
  "variants": { "sticky":"session", "pool":[ {"page":"…/12712","weight":50,"control":true}, {"page":"…/12721","weight":50} ] },
  "after": [
    { "when": {"is":"cart_has_offer","skus":["…_sub_115","…_monthly"]}, "goto":"us/burn-pm" },
    { "when": {"is":"cart_has_offer","skus":["…evolved2_1","…_3","…_6"]}, "goto":"us/burn-3bo-us" }
  ],
  "fallback": "us/burn-1bo-ds",
  "track": { "on":["impression","decision","conversion"], "tags":["funnel","step","variant","macro"] }
}

Authored as metaobjects (variant references + safe rollback), generated to JSON, cached at the request layer for fast reads. Everything else is a list of nodes built from three primitives: a rule (when → goto), a condition (a typed when), a variant (page + weight + control).

SLTWTR solution blueprint · the full spec (components, data shapes, event model, open items) lives in the ClickUp deliverable. Scope: SLTWTR implements the selling-plan / card-vaulting piece and blueprints the rest for VShred's team to build.