Abandoned Cart Recovery

Abandoned Cart Recovery

Call your high-value cart abandoners within 5 minutes, beat the objection live, and close the order — before email ever lands in an ignored inbox.

Built on the Telenow App Platform as a pure declarative app: the data model, the agent tools, the store webhook, the value-branch queueing rule, the recovery workflow, the recovery agent, and the objection playbook all run on-platform. No external server.

The problem (and the number)

70–77% of online carts are abandoned. That's the single biggest leak in D2C. The industry's default response — win-back email and SMS — recovers only 5–8% of those carts, because a template that arrives hours later can't answer the one specific doubt (shipping cost, "is COD available?", "will this size fit?", "my payment failed") that actually stopped the buyer.

A phone call within minutes recovers 25–35% — 4–5× the email baseline — because a person can hear the real objection and remove it while the shopper still wants the item.

Abandoned Cart Recovery does exactly that, automatically. And it does it profitably by dialing only high-value carts — the wedge that keeps the unit economics positive.

How it works

Shopify checkout  ──(cart / checkout abandoned webhook)──►  cart object (status: abandoned)
        │                                                        │
        │                                              fires object.cart.created
        │                                                        │
        │                                    ┌──── value-branch event RULE ────┐
        │                                    │  when data.value  gte 1500       │  ← the WEDGE:
        │                                    │  upsert → callable_cart (queued) │    only high-value
        │                                    └──────────────────┬──────────────┘    carts get queued
        ▼                                                       │
   dedupe on cart token                        fires object.callable_cart.created
                                                                │
                                          ┌─────────────────────┴─────────────────────┐
                                          ▼                                             ▼
                                recover_cart workflow                        whatsapp_nudge workflow
                                  ├─ delay ~5 min                              ├─ delay ~2 min
                                  └─ outbound-call  {{settings.recover_agent_id}}   └─ send-message {{settings.wa_channel}}
                                        → dials {{trigger.data.phone}}                    → "finish your order" nudge
                                        → passes cart_id, value
                                              │
                                              ▼
                                Cart Recovery Agent (friendly, vernacular)
                                find_cart → hear the objection → answer it from the playbook (KB)
                                → resume checkout / apply discount
                                → mark_recovered | mark_lost | record_objection

Everything the agent does on the call updates the same cart rows you see on the dashboard — and the dashboard's Call now button dials through the same agent and tools.

The value-branch when.gte pattern (the wedge)

The queue is driven by a single declarative event rule, not code:

"events": [
  { "on": "object.cart.created",
    "handler": {
      "kind": "rule", "do": "upsert", "object": "callable_cart", "key": "cart_id",
      "when": { "path": "data.value", "gte": 1500 },          // ← numeric value-branch
      "map": { "cart_id": "data.cart_id", "phone": "data.phone", "value": "data.value" }
    } }
]

when.gte is a numeric guard: every new cart fires object.cart.created, but only carts worth ≥ ₹1,500 are upserted into callable_cart (deduped on cart_id). Only those queued carts fire object.callable_cart.created, which is what the workflow dials. Change the cutoff by editing that gte (keep it aligned with the High-value threshold setting, which the dashboard filter and KPIs use).

Agent tools (used mid-call — all declarative)

The bundled Cart Recovery Agent is a multi-context flow: a deterministic find_cart tool node (looks the caller up in this app's data) → a conversation node that hears the objection, answers it from the playbook, and closes. STT/TTS default to Sarvam (anushka) so Tier-2/3 vernacular shoppers get a call in their own language.

Dashboard pages

• Abandoned Cart Recovery (dashboard) — KPI tiles (recovered revenue, recovery rate, vs email/SMS lift multiplier, high-value queued, carts today), a voice vs email/SMS recovered-revenue comparison bar, a cart-outcome mix, recent carts, and daily recovered revenue. Also powers the platform dashboard_widget slot in a compact form.
• Carts — high-value filter (≥ threshold) plus status filters and search, with a per-row Call now that triggers a recovery call and passes the cart's context variables to the agent.
• Setup — a configuration checklist, a one-click Create recovery agent button, and the post-install wiring steps.

Knowledge base

cart-playbook ships five real scripts the agent answers from: shipping-cost objection, COD availability, size/fit doubt, payment failure / trust worry, and the recovery discount offer.

Install & post-install wiring

1. Install Abandoned Cart Recovery into your org.
2. Open Setup → Create recovery agent (builds the bundled agent, auto-wired to the tools + playbook KB).
3. Copy the new agent's ID into the app's Recovery agent ID setting (recover_agent_id) so recover_cart can dial.
4. (Optional) Set the High-value threshold (high_value_threshold, default ₹1,500) to tune what counts as high-value in the UI, and WhatsApp channel ID (wa_channel) to auto-send the finish-your-order nudge.
5. Point your store's checkout / cart abandoned webhook at the inbound hook — shopify_cart (verified with x-shopify-hmac-sha256). New abandoned carts now flow in; high-value ones auto-queue and auto-dial.

Settings

Bulk dialing your backlog

The real-time path (webhook → rule → workflow → call) covers new high-value carts. To sweep an existing backlog, use the app-key campaign API:

POST /api/app-campaigns
{ "agentId": "<recovery agent id>",
  "targetQuery": { "status": "abandoned", "value": { "$gte": 1500 } },   // over the `cart` object
  "result": { ... write-back ... } }

Monetization

Abandoned Cart Recovery is billed on outcomes, not seats: a percentage of recovered cart revenue. You only pay a share of the carts the agent actually closes (recovered) — revenue that email and SMS almost never bring back — so the app is always net-positive for the merchant. The dashboard's recovered revenue and vs email/SMS lift make that ROI obvious at a glance.

Changelog

1.1.0 — 2026-07-12

• Renamed to Abandoned Cart Recovery (business-friendly) with a marketplace icon.
• Added real UI screenshots (dashboard + key pages).
• The recovery workflow now marks the queued cart as called, so the high-value queue actually drains.
• Verified end-to-end loop closure: trigger → workflow → call → agent tools → write-back → dashboard.

1.0.0

• Initial release.
• Data model: cart object (cart id, phone, customer, value, items, objection, language, status, created_at) with high_value / recovered / lost saved views; callable_cart queue object (cart id, phone, value, status) with a queue view; and a metric object for the daily recovered-revenue rollup.
• Agent tools (declarative): find_cart, mark_recovered, mark_lost, record_objection.
• Bundled agent: Cart Recovery Agent — a Sarvam vernacular multi-context flow (deterministic find_cart lookup → hear objection → answer from playbook → close) auto-wired to the tools and the cart-recovery playbook knowledge base.
• Knowledge base: cart-playbook — shipping-cost objection, COD availability, size/fit doubt, payment failure / trust worry, and the recovery discount offer.
• Automation: shopify_cart inbound webhook (HMAC-verified, dedupe on cart token); value-branch event rule (when.gte 1500) that upserts a callable_cart only for HIGH-VALUE carts — the wedge; recover_cart workflow (delay ~5 min → outbound recovery call); whatsapp_nudge workflow (delay ~2 min → finish-your-order WhatsApp).
• Dashboard UI: KPI tiles (recovered revenue, recovery rate, vs email/SMS lift, high-value queued, carts today), a voice-vs-email/SMS recovered-revenue comparison, cart-outcome mix, recent carts, and daily recovered revenue; also renders into the dashboard_widget slot in compact form.
• Carts page: high-value + status filters, search, and per-cart Call now (passes cart context variables to the agent).
• Setup page: configuration checklist + one-click Create recovery agent and post-install wiring steps.
• Self-seed: a fresh install auto-loads six realistic demo carts across statuses (with the high-value ones queued) and a metric row (removable) so the dashboard is populated on first open.