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

Chapter 2. Discount Hooks and Overstated Recovery

Buyers learn to wait

Many abandonment flows attach a 10%-off coupon to the second or third message. In the short run it recovers more orders; in the long run it teaches buyers something: put items in the cart, leave, wait, and a discount will come. This is the same structure as the classic problem of the durable-goods monopolist: if the seller will cut prices later, rational buyers wait (Coase 1972).

Calculation

# Chapter 2. p03: Discount hooks teach buyers to abandon on purpose.
# A cohort of 1,000 repeat buyers makes 12 purchase decisions a year at
# RM 98. Each decision: a "learner" abandons on purpose and waits for the
# coupon; a non-learner buys at once with probability p, otherwise
# abandons and is recovered by the coupon email with probability r.
# Each coupon received turns a non-learner into a learner with
# probability L. Learners recovered by coupon pay (1 - d) x price.
# Compare revenue per year with coupon emails (d = 10%) and with plain
# reminders (d = 0, no learning, lower recovery r0).
import random

N, ROUNDS, PRICE = 1000, 12, 98.0
P_BUY, R_COUPON, R_PLAIN, D = 0.70, 0.25, 0.17, 0.10

def run(coupon, learn, seed=79):
    rng = random.Random(seed)
    learner = [False] * N
    by_round = []
    for _ in range(ROUNDS):
        rev = 0.0
        for i in range(N):
            if rng.random() < P_BUY:
                if not learner[i]:
                    rev += PRICE
                elif rng.random() < 0.95:
                    rev += PRICE * (1 - D)
                continue
            r = R_COUPON if coupon else R_PLAIN
            if rng.random() < r:
                rev += PRICE * ((1 - D) if coupon else 1.0)
                if coupon and rng.random() < learn:
                    learner[i] = True
        by_round.append(rev)
    return by_round, sum(learner)

if __name__ == "__main__":
    plain, _ = run(False, 0.0)
    print("   plain reminders: RM {:,.0f} per year".format(sum(plain)))
    for learn in (0.0, 0.3, 0.6):
        rows, n = run(True, learn)
        print("   coupon, learning {:.1f}: RM {:,.0f} per year;"
              " {} learners".format(learn, sum(rows), n))
        print("     month 1 RM {:,.0f}, month 12 RM {:,.0f}".format(
            rows[0], rows[-1]))
#    plain reminders: RM 882,196 per year
#    coupon, learning 0.0: RM 903,795 per year; 0 learners
#      month 1 RM 75,440, month 12 RM 75,921
#    coupon, learning 0.3: RM 892,270 per year; 250 learners
#      month 1 RM 75,440, month 12 RM 73,402
#    coupon, learning 0.6: RM 880,971 per year; 427 learners
#      month 1 RM 75,440, month 12 RM 73,235

In the illustrative model, 1,000 repeat buyers make 12 purchase decisions a year at RM 98 each. With plain reminders a year’s revenue is RM 882,196. With 10%-off coupons and buyers who never learn, revenue is RM 903,795, indeed more; but if each coupon received teaches a buyer to abandon on purpose with probability 0.3, revenue falls to RM 892,270, with 250 “learners” by the end of the year; at a learning probability of 0.6 revenue is RM 880,971, already below plain reminders, with 427 learners. In the first month all three cases bring RM 75,440; the difference shows only by the end of the year (RM 73,235 in month 12, against RM 75,921 without learning).

Note

Why short tests miss it. A two-week A/B test compares the first month, where the coupon looks a sure winner. The learning effect appears only after the same buyers buy again, so discount hooks must be evaluated by following buyers for months, or used for first-time buyers only.

How much recovery would have happened anyway

Calculation

# Chapter 2. p04: How many "recovered" carts were really recovered?
# Attribution usually credits every order placed after a follow-up was
# sent. With the model of p01, returns that would have happened anyway
# (the natural hazard) are mixed in. Per 1,000 abandoners, RM 98 each.
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")

def after_first(times, n=1000):
    # returns after the first message are what attribution credits
    before = p01.returned((), horizon=times[0])
    total = p01.returned(times)
    return n * (total - before)

if __name__ == "__main__":
    base = p01.returned(())
    for times in ((0.25, 24, 72), (2, 24, 72), (12, 24, 72)):
        att = after_first(times)
        inc = 1000 * (p01.returned(times) - base)
        print("   first message at {:>5g} h: attributed {:4.0f} orders,"
              " incremental {:4.0f}".format(times[0], att, inc))
        print("     incremental share {:.2f}; attributed RM {:,.0f},"
              " incremental RM {:,.0f}".format(inc / att, att * 98,
                                               inc * 98))
#    first message at  0.25 h: attributed  364 orders, incremental  155
#      incremental share 0.43; attributed RM 35,672, incremental RM 15,207
#    first message at     2 h: attributed  326 orders, incremental  149
#      incremental share 0.46; attributed RM 31,960, incremental RM 14,563
#    first message at    12 h: attributed  185 orders, incremental  112
#      incremental share 0.61; attributed RM 18,153, incremental RM 11,025

The usual attribution counts every order placed after a follow-up was sent as “recovered”. With the model of Chapter 1: with the first message at 0.25 h, attribution credits 364 orders per 1,000 abandoners, but the follow-ups actually add only 155, a share of 0.43; at RM 98 each, RM 35,672 attributed against RM 15,207 incremental. The later the first message, the smaller the attributed figure and the larger the incremental share (0.61 when sent at 12 hours), because the buyers most eager to return have already come back on their own.

Hypothesis · not established

The author’s hypothesis (not yet tested): a flow that attaches coupons for first-time buyers and sends plain reminders to repeat buyers earns no less over 12 months than a flow that attaches coupons for everyone. What would show it wrong: with buyers randomised and followed for 12 months, the all-coupon group earns significantly more.

Summary

Discount hooks work in the short run but teach repeat buyers to abandon on purpose; at a learning probability of 0.6 a year’s revenue is already below that of plain reminders. Attributed recovery includes buyers who would have come back anyway; the earlier the follow-up, the larger the overstatement.

References

Coase, Ronald H. 1972. “Durability and Monopoly.” The Journal of Law and Economics 15 (1): 143–49.

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).