5D Library › Cart-Abandonment Recovery Kinetics, Sunk-Data Retention Ratchets and High-Ticket B2B Qualification Mechanisms · 中文

Chapter 1. The Timing and Number of Follow-Ups after Abandonment

A return intensity that fades by itself

A buyer puts items in a cart and leaves without paying; some come back by themselves. Write the instantaneous probability of “coming back to buy now” as a return intensity h0(t)=ae−t/τh_0(t) = a\,e^{-t/\tau}: highest just after leaving, falling as interest fades. Each follow-up sent at time ss adds a decaying pulse b(s)e−(t−s)/κb(s)\,e^{-(t-s)/\kappa} to the intensity, whose size b(s)b(s) is smaller the longer the buyer has been gone; the kk-th message is discounted for habituation, and a message that follows the previous one too closely is discounted too. Returns are counted within 7 days (168 hours).

The model is often called a “Hawkes process”, but not accurately. A Hawkes process describes self-excitation, in which events trigger more events of the same kind (Hawkes 1971); coming back to buy is an absorbing event, and a buyer who has ordered does not “return” again. The intensity here is excited from outside by the follow-ups; only the form of the exponential kernel is borrowed.

Calculation

# Chapter 1. p01: When to send three follow-ups after an abandoned cart.
# Natural return of an abandoner has hazard h0(t) = a exp(-t/tau) (hours).
# A follow-up sent at time s adds an excitation b(s) exp(-(t-s)/kappa),
# where b(s) = b0 exp(-s/rho) falls as interest fades, and the k-th
# message is weaker by a factor f^k (habituation) and by 1-exp(-gap/G)
# when it follows the previous one too closely. Return is absorbing,
# so this is an externally excited intensity, not a self-exciting Hawkes
# process. We compare the schedule 0.25 h / 24 h / 72 h with the best
# three times on a grid, counting returns within 7 days (168 h).
from itertools import combinations
from math import exp

A, TAU = 0.02, 12.0          # natural return: about 21% eventually
B0, RHO, KAPPA, F, G = 0.08, 30.0, 2.0, 0.8, 12.0
HORIZON, DT = 168.0, 0.05
GRID = (0.25, 1, 2, 4, 8, 12, 24, 36, 48, 72, 96, 120)

def weights(times):
    w, prev = [], None
    for k, s in enumerate(times):
        g = 1.0 if prev is None else 1 - exp(-(s - prev) / G)
        w.append(F ** k * g * B0 * exp(-s / RHO))
        prev = s
    return w

def returned(times, horizon=HORIZON, dt=DT):
    times = sorted(times)
    ws = weights(times)
    cum, t = 0.0, 0.0
    while t < horizon:
        lam = A * exp(-t / TAU)
        for w, s in zip(ws, times):
            if t >= s:
                lam += w * exp(-(t - s) / KAPPA)
        cum += lam * dt
        t += dt
    return 1 - exp(-cum)

def curve(times, step=1.0):
    out, cum, t = [], 0.0, 0.0
    times = sorted(times)
    ws = weights(times)
    while t <= HORIZON:
        out.append((t, 1 - exp(-cum)))
        sub = 0.0
        for i in range(20):
            u = t + (i + 0.5) * step / 20
            lam = A * exp(-u / TAU)
            for w, s in zip(ws, times):
                if u >= s:
                    lam += w * exp(-(u - s) / KAPPA)
            sub += lam * step / 20
        cum += sub
        t += step
    return out

if __name__ == "__main__":
    base = returned(())
    rule = returned((0.25, 24, 72))
    print("   natural return within 7 days: {:.3f}".format(base))
    print("   schedule 0.25 h / 24 h / 72 h: {:.3f}  (+{:.1f} points)".format(
        rule, 100 * (rule - base)))
    scores = {c: returned(c) for c in combinations(GRID, 3)}
    best = max(scores, key=scores.get)
    rb = scores[best]
    print("   best grid schedule {} h: {:.3f}  (+{:.1f} points)".format(
        "/".join("{:g}".format(x) for x in best), rb, 100 * (rb - base)))
    print("   the rule reaches {:.0%} of the best gain".format(
        (rule - base) / (rb - base)))
    near = sum(1 for v in scores.values() if v - base >= 0.9 * (rb - base))
    print("   {} of {} grid schedules reach 90% of the best gain".format(
        near, len(scores)))
#    natural return within 7 days: 0.214
#    schedule 0.25 h / 24 h / 72 h: 0.369  (+15.5 points)
#    best grid schedule 0.25/12/24 h: 0.384  (+17.0 points)
#    the rule reaches 91% of the best gain
#    33 of 220 grid schedules reach 90% of the best gain

Under illustrative parameters, with no follow-up 0.214 of buyers return by themselves within 7 days. Sending three messages at 0.25 h, 24 h and 72 h raises the return rate to 0.369, 15.5 percentage points more; the best choice of three from 12 candidate times is 0.25 h, 12 h and 24 h, with a return rate of 0.384, 17.0 points more. The rule of thumb reaches 91% of the best gain, and 33 of 220 candidate schedules reach 90% of it.

Share returned over time: no follow-up, the rule-of-thumb schedule and the best schedule on the grid (p01).

Note

In practice. The optimum is flat: timing to the hour hardly matters; what matters is sending the first message early, because both the buyer’s interest and the effect of a follow-up decay with time. A third message at 72 hours contributes little in this model.

How many to send

Calculation

# Chapter 1. p02: How many follow-ups? Marginal recovery against the
# cost of unsubscribes. Messages go out at 0.25 h, 12 h, 24 h, 48 h,
# 72 h, 120 h (in that order, the first k used). Each message makes a
# share u of recipients unsubscribe; an unsubscribed address is worth
# V in future revenue. Per 1,000 abandoners, order value RM 98.
import importlib.util

def load(name):
    spec = importlib.util.spec_from_file_location(name, name + ".py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    return m

p01 = load("p01_return_hazard")
TIMES = (0.25, 12, 24, 48, 72, 120)
ORDER, U, V = 98.0, 0.004, 60.0

def ledger(k, n=1000):
    base = p01.returned(())
    rec = p01.returned(TIMES[:k]) - base
    gain = n * rec * ORDER
    lost = n * (1 - (1 - U) ** k) * V
    return rec, gain, lost

if __name__ == "__main__":
    prev = 0.0
    best, best_net = 0, 0.0
    print("   k  recovered  marginal RM  unsub cost RM  net RM")
    for k in range(1, len(TIMES) + 1):
        rec, gain, lost = ledger(k)
        net = gain - lost
        print("   {}  {:9.3f}  {:11,.0f}  {:13,.0f}  {:6,.0f}".format(
            k, rec, gain - prev, lost, net))
        prev = gain
        if net > best_net:
            best, best_net = k, net
    print("   best number of messages: {} (net RM {:,.0f})".format(
        best, best_net))
#    k  recovered  marginal RM  unsub cost RM  net RM
#    1      0.117       11,436            240  11,196
#    2      0.152        3,464            479  14,421
#    3      0.170        1,804            717  15,987
#    4      0.179          846            954  16,596
#    5      0.182          301          1,190  16,661
#    6      0.183           55          1,426  16,481
#    best number of messages: 5 (net RM 16,661)

Each extra message makes a small share of recipients unsubscribe, and an unsubscribed address loses its future value. Adding messages at 0.25, 12, 24, 48, 72 and 120 hours in turn: per 1,000 abandoners the first brings RM 11,436, the second RM 3,464, the third RM 1,804, the fourth RM 846, the fifth RM 301 and the sixth only RM 55, while the unsubscribe cost rises by about RM 240 per message. Net of unsubscribes, revenue peaks at five messages (RM 16,661), but the fourth and fifth together add very little.

Recovered revenue, and revenue net of unsubscribes, against the number of follow-up messages (p02).

Hypothesis · not established

The author’s hypothesis (not yet tested): for the author’s report products, three follow-ups with the first sent within 1 hour raise the 7-day return rate by at least 5 percentage points over follow-ups whose first message goes out at 24 hours. What would show it wrong: a randomised experiment in which the two schedules differ in return rate by less than 5 points.

Summary

The rule-of-thumb schedule of 15 minutes, 24 hours and 72 hours reaches 91% of the best gain in the illustrative model, and the optimum is flat. The marginal return of follow-ups falls fast; after the fourth, little but the cost of unsubscribes remains.

References

Hawkes, Alan G. 1971. “Spectra of Some Self-Exciting and Mutually Exciting Point Processes.” Biometrika 58 (1): 83–90.

Fan, Y. (2026). Cart-Abandonment Recovery Kinetics, Sunk-Data Retention Ratchets and High-Ticket B2B Qualification Mechanisms: Multi-Pulse Follow-Up Timing, Switching-Cost Accumulation and Screening Equilibria [弃单挽回动力学、沉没数据续费棘轮与高客单顾问筛选机制] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090209 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).