What does Fan-Out Tail Latency conclude, in numbers, about “The Multiplicative Law: How One Slow Call in a Hundred Becomes Sixty-Three Slow Pages in a Hundred”?

Answer: Chapter 1 recomputes the multiplicative law: one slow request in ten thousand across two thousand calls still gives slow pages with probability 0.181, and a page 99th percentile allows each call a slow share of only 0.000100.

Scope of the numbers: Service times, slow shares and costs are illustrative; all calculations are generated by the book's programs; the book is general business analysis, not individualised business advice. Marked boxes separate published evidence, runnable Python calculations (22 programs), classical sources and the author's hypotheses.

中文版

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.000100, 99

Per-call percentile needed for a page percentile
Npage p95: call qninespage p99: call qnines
10.9500001.300.9900002.00
100.9948842.290.9989953.00
300.9982922.770.9996653.48
1000.9994873.290.9999004.00
3000.9998293.770.9999664.47
10000.9999494.290.9999905.00
Page p99 at N=100 needs each call at pct 99.990
Allowed slow share per call: 0.000100
Rule of thumb (1 - P)/N:0.000100
Show the full program
# Chapter 1. p12: which per-call percentile a page percentile demands.
# Model: for N independent parallel calls, the page meets its deadline
# with probability q^N when each call does so with probability q. To
# give the page a target probability P, each call needs q = P^(1/N).
# The "nines" column is -log10(1 - q). Targets are illustrative.
import math


def per_call_q(page_target, n):
    return math.exp(math.log(page_target) / n)


if __name__ == "__main__":
    print("Per-call percentile needed for a page percentile")
    print("      N   page p95: call q   nines   page p99: call q   nines")
    for n in (1, 10, 30, 100, 300, 1000):
        cells = []
        for tgt in (0.95, 0.99):
            q = per_call_q(tgt, n)
            nines = -math.log10(1.0 - q)
            cells.append("{:12.6f}   {:5.2f}".format(q, nines))
        print("  {:5d}   {}   {}".format(n, cells[0], cells[1]))
    q = per_call_q(0.99, 100)
    print("Page p99 at N=100 needs each call at pct {:.3f}".format(
        100 * q))
    print("Allowed slow share per call: {:.6f}".format(1.0 - q))
    print("Rule of thumb (1 - P)/N:     {:.6f}".format(0.01 / 100))

Single source and citation

Fan, Y. (2026). The Multiplicative Law of Fan-Out Tail Latency and Hedged Requests: How Percentile Latency Amplifies When One Page Makes Many Calls (Version 1.0.0), Chapter 1: The Multiplicative Law: How One Slow Call in a Hundred Becomes Sixty-Three Slow Pages in a Hundred. 5D Library. DOI pending

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

BibTeX
@book{fan2026326,
  author    = {Fan, Yafu},
  title     = {The Multiplicative Law of Fan-Out Tail Latency and Hedged Requests: How Percentile Latency Amplifies When One Page Makes Many Calls},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book