What does Demo-First Closing and 48-Hour Delivery conclude, in numbers, about “Put the Buffer at the End of the Chain: Critical Chain, Fat-Tailed Modules and the Limits of Intake”?

Answer: Padding every task bloats the plan and, because early finishes never hand over, digests only bad news: the padded plan of the illustrative six-module order is 15.91 hours, with a probability of being on time of only 0.721. An end-of-chain buffer, with tasks at their medians and immediate handover, commits to 14.73 hours with a probability of 0.997. The root-sum-square rule underestimates the buffer when two lanes run in parallel and serves only as a lower bound. Off-catalogue modules have fat tails: a single custom integration planned at 3 hours can drag the probability of being on time down to 0.632, so every such module leaves the forty-eight-hour order.

Scope of the numbers: Its win rates, hours, margins, upfront shares, fees and prices are illustrative, counted in units that match no currency, client or real deal, and all calculations are generated by its programs. It is not legal advice and not individual business or financial advice; contract terms need review by a locally admitted lawyer.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.721, 0.997, 14.73, 15.91

regime A, padded plan15.91 h
P(done by padded plan)0.645, P(on time 16 h) = 0.721
mean with no early hand-on16.01 h
regime B, median plan12.09 h + buffer
simulated 95 % buffer 2.65 h -> commit 14.73 h
root-sum-square buffer 1.99 h -> commit 14.08 h
P(on time 16 h)0.997, mean 12.80 h
padding minus pooled commitment1.18 h
Show the full program
# Chapter 4. p41: pad every module, or pool one buffer at the chain end?
# Six-module order and lanes of p32/p33. Regime A pads each module to
# its own P90 and, as Parkinson's law and late starts suggest, gains
# from early finishes are not passed on: a module ends at
# max(actual, padded). Regime B (critical chain, Goldratt 1997) plans
# each module at its median, passes early finishes on, and keeps one
# project buffer at the end of the chain. Root-sum-square sizing is
# compared with the simulated 95 % buffer. Illustrative; N = 20,000.
import math
import random

N = 20000
WINDOW = 16.0
LANE_A = [(0.5, 1.0, 2.0), (3.0, 4.0, 7.0), (1.5, 2.5, 5.0)]
LANE_B = [(2.0, 3.0, 5.0), (2.0, 3.0, 6.0), (1.0, 2.0, 4.0)]
QA = (2.0, 3.0, 4.0)


def tri_q(m, u):
    lo, mode, hi = m
    cut = (mode - lo) / (hi - lo)
    if u <= cut:
        return lo + math.sqrt(u * (hi - lo) * (mode - lo))
    return hi - math.sqrt((1 - u) * (hi - lo) * (hi - mode))


def lane_time(mods, draws, floor_q):
    parts = []
    for m, d in zip(mods, draws):
        parts.append(max(d, tri_q(m, floor_q)) if floor_q else d)
    return math.fsum(parts)


rng = random.Random(20261120)
pad_t, pool_t = [], []
for _ in range(N):
    da = [rng.triangular(m[0], m[2], m[1]) for m in LANE_A]
    db = [rng.triangular(m[0], m[2], m[1]) for m in LANE_B]
    dq = rng.triangular(QA[0], QA[2], QA[1])
    pad_t.append(max(lane_time(LANE_A, da, 0.9),
                     lane_time(LANE_B, db, 0.9)) + max(dq, tri_q(QA, 0.9)))
    pool_t.append(max(math.fsum(da), math.fsum(db)) + dq)
pool_t.sort()


def plan_at(u):
    a = math.fsum(tri_q(m, u) for m in LANE_A)
    b = math.fsum(tri_q(m, u) for m in LANE_B)
    return max(a, b) + tri_q(QA, u)


padded, median = plan_at(0.9), plan_at(0.5)
sim_buf = pool_t[int(0.95 * N)] - median
heavy = LANE_A if math.fsum(tri_q(m, 0.5) for m in LANE_A) >= \
    math.fsum(tri_q(m, 0.5) for m in LANE_B) else LANE_B
rss = math.sqrt(math.fsum((tri_q(m, 0.9) - tri_q(m, 0.5)) ** 2
                          for m in heavy + [QA]))
print("regime A, padded plan: {:.2f} h".format(padded))
print("  P(done by padded plan) = {:.3f}, P(on time 16 h) = {:.3f}".format(
    len([t for t in pad_t if t <= padded]) / N,
    len([t for t in pad_t if t <= WINDOW]) / N))
print("  mean with no early hand-on: {:.2f} h".format(
    math.fsum(pad_t) / N))
print("regime B, median plan: {:.2f} h + buffer".format(median))
print("  simulated 95 % buffer {:.2f} h -> commit {:.2f} h".format(
    sim_buf, median + sim_buf))
print("  root-sum-square buffer {:.2f} h -> commit {:.2f} h".format(
    rss, median + rss))
print("  P(on time 16 h) = {:.3f}, mean {:.2f} h".format(
    len([t for t in pool_t if t <= WINDOW]) / N, math.fsum(pool_t) / N))
print("padding minus pooled commitment: {:.2f} h".format(
    padded - (median + sim_buf)))

Single source and citation

Fan, Y. (2026). Demo-First B2B Closing, Forty-Eight-Hour Turnkey System Delivery and Scope-Creep Containment (Version 1.0.0), Chapter 4: Put the Buffer at the End of the Chain: Critical Chain, Fat-Tailed Modules and the Limits of Intake. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-368 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026368,
  author    = {Fan, Yafu},
  title     = {Demo-First B2B Closing, Forty-Eight-Hour Turnkey System Delivery and Scope-Creep Containment},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book