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 plan | 15.91 h |
| P(done by padded plan) | 0.645, P(on time 16 h) = 0.721 |
| mean with no early hand-on | 16.01 h |
| regime B, median plan | 12.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 commitment | 1.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
- Chapter 1 · The Break-Even Line of Demo-First Selling: Win-Rate Jumps, the Endowment Dispute and Name Personalisation
- Chapter 2 · How Complete Should a Preview Be? The Saturating Win-Rate Curve, the Optimal Completeness and Preview Compliance
- Chapter 3 · Forty-Eight Hours Is a Distribution: Sums of Module Hours, the Probability of Being on Time and the Planning Fallacy
- Chapter 5 · Free Revisions and Scope Creep: Poisson Request Rates, the Change-Pricing Lock and the Choice of Contract
- Chapter 6 · Upfront Payments, Milestones and the Hosting Retainer: Expected Cash and Retention Without Hostages
- Chapter 7 · Classical Sources East and West: Mozi on Gongshu Ban, the Kaogong ji, the Gospel of Luke and Vitruvius
- Chapter 8 · The Empirical Loop: Actuarial Tools and Execution Checklist for Demo and Delivery