5D Library › Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds · 中文
Chapter 1. A Queueing Network of Four Teams and Its Bottleneck
Writing a company as a queueing network
In a company that wins customers with content, every piece of business passes through four teams in turn: content production, paid acquisition, conversion (sales) and fulfilment. Each team behaves like a queueing station: work arrives, waits, is served and flows on. After conversion, two in ten prospects go back to acquisition to be retargeted, five in ten buy and move to fulfilment, and three in ten leave; one in ten fulfilment jobs must be reworked.
Jackson showed that when service times at each station are exponential and outside arrivals form a Poisson stream, the stationary distribution of the whole network factors into a product of independent stations (Jackson 1957, 1963). One first solves the traffic equations for each station’s arrival rate; a station with staff who each handle jobs a day is then computed as an M/M/c queue. The mean lead time of the network follows from Little’s law (Little 1961).
Calculation
# Chapter 1. p01: An open Jackson network of four teams and its bottleneck.
# Each job is one customer journey: content -> acquisition -> conversion ->
# fulfilment. After conversion 20% go back to acquisition (retargeting),
# 50% go on to fulfilment and 30% leave unsold; 10% of fulfilment is
# reworked. Station i has c[i] servers of rate mu[i] jobs/day (M/M/c).
# Jackson's theorem: each station behaves as an independent M/M/c queue
# with the arrival rate solved from the traffic equations.
from math import factorial
NAMES = ("content", "acquisition", "conversion", "fulfilment")
ROUTE = ((0, 1.0, 0, 0), (0, 0, 1.0, 0), (0, 0.2, 0, 0.5), (0, 0, 0, 0.1))
BASE = {"c": (2, 1, 3, 2), "mu": (14.0, 40.0, 10.0, 12.0)}
def visits():
v = [0.0] * 4
for _ in range(500):
v = [(1.0 if j == 0 else 0.0) + sum(v[i] * ROUTE[i][j]
for i in range(4))
for j in range(4)]
return v
def mmc_L(lam, c, mu):
rho = lam / (c * mu)
if rho >= 1:
return float("inf")
a = lam / mu
s = sum(a ** k / factorial(k) for k in range(c))
top = a ** c / (factorial(c) * (1 - rho))
pw = top / (s + top) # Erlang C: P(wait)
return pw * rho / (1 - rho) + a # queue + in service
def network(lam0, c, mu):
v = visits()
rho = [lam0 * v[i] / (c[i] * mu[i]) for i in range(4)]
L = [mmc_L(lam0 * v[i], c[i], mu[i]) for i in range(4)]
cap = min(c[i] * mu[i] / v[i] for i in range(4))
return rho, L, sum(L) / lam0, cap
if __name__ == "__main__":
lam0 = 20.0
v = visits()
print(" visit ratios: " + ", ".join(
"{} {:.3f}".format(n[:4], x) for n, x in zip(NAMES, v)))
cases = (("base", BASE["c"], BASE["mu"]),
("content automated (mu x2)", BASE["c"], (28.0, 40, 10, 12)),
("one more closer", (2, 1, 4, 2), BASE["mu"]))
for name, c, mu in cases:
rho, L, W, cap = network(lam0, c, mu)
print(" {}:".format(name))
print(" utilisation " + " ".join("{:.3f}".format(r)
for r in rho))
print(" WIP {:.2f} jobs, lead time {:.3f} days".format(
sum(L), W))
print(" throughput {:.1f}/day; max sustainable {:.1f}/day".format(
lam0, cap))
# visit ratios: cont 1.000, acqu 1.250, conv 1.250, fulf 0.694
# base:
# utilisation 0.714 0.625 0.833 0.579
# WIP 12.33 jobs, lead time 0.617 days
# throughput 20.0/day; max sustainable 24.0/day
# content automated (mu x2):
# utilisation 0.357 0.625 0.833 0.579
# WIP 10.24 jobs, lead time 0.512 days
# throughput 20.0/day; max sustainable 24.0/day
# one more closer:
# utilisation 0.714 0.625 0.625 0.579
# WIP 9.36 jobs, lead time 0.468 days
# throughput 20.0/day; max sustainable 28.0/dayWith illustrative parameters, 20 jobs enter each day. The four teams carry loads of 0.714, 0.625, 0.833 and 0.579; conversion is the most heavily loaded and is the bottleneck. Work in progress across the network is 12.33 jobs and the mean lead time 0.617 days.
Throughput is set by the bottleneck
In an open network throughput equals the arrival rate, as long as every station is stable. The largest arrival rate the network can bear is , where , the visit ratio, is the mean number of times a job visits station . Here conversion and acquisition both have a visit ratio of 1.250 and fulfilment 0.694.
Doubling the capacity of the content team (automation) cuts its load from 0.714 to 0.357, work in progress to 10.24 jobs and the lead time to 0.512 days; but the maximum sustainable throughput stays at 24.0 jobs a day, not one more. Adding one closer to the conversion team raises the maximum to 28.0 a day, cuts work in progress to 9.36 jobs and the lead time to 0.468 days. The first claim of the theory of constraints follows: improving a non-bottleneck does not raise the ceiling on the system’s output (Goldratt and Cox 1984).
Note
Keep the two returns apart. Automating a non-bottleneck is not useless: it shortens the lead time (here from 0.617 to 0.512 days). But if the investment is justified as “doing more business”, its return in this network is zero.
Capping work in progress: a closed network
Many teams control flow with a cap on work in progress (CONWIP): at most jobs in hand, one released only when one is finished. That is a closed network. Pool each team into one server of rate , so station has service demand , and exact mean value analysis gives the throughput (Reiser and Lavenberg 1980).
Calculation
# Chapter 1. p02: A closed network (a cap of N jobs in progress, CONWIP).
# Each team is pooled into one server of rate c*mu; the service demand
# of station i is D_i = v_i / (c_i mu_i) days per job. Exact mean value
# analysis (Reiser-Lavenberg) gives throughput X(N); it can never exceed
# 1 / max D_i, whatever is done at the other stations.
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_jackson_open")
def demands(c, mu):
v = p01.visits()
return [v[i] / (c[i] * mu[i]) for i in range(4)]
def mva(D, nmax):
q = [0.0] * len(D)
out = []
for n in range(1, nmax + 1):
r = [D[i] * (1 + q[i]) for i in range(len(D))]
x = n / sum(r)
q = [x * ri for ri in r]
out.append((n, x, sum(r)))
return out
CASES = (("base", (2, 1, 3, 2), (14.0, 40.0, 10.0, 12.0)),
("content x2", (2, 1, 3, 2), (28.0, 40.0, 10.0, 12.0)),
("+1 closer", (2, 1, 4, 2), (14.0, 40.0, 10.0, 12.0)))
if __name__ == "__main__":
print(" jobs in throughput per day (lead time, days)")
print(" progress " + " ".join("{:>17}".format(n)
for n, _, _ in CASES))
rows = {name: mva(demands(c, mu), 40) for name, c, mu in CASES}
for n in (2, 5, 10, 20, 40):
cells = []
for name, _, _ in CASES:
_, x, r = rows[name][n - 1]
cells.append("{:>8.2f} ({:5.3f})".format(x, r))
print(" {:8d} ".format(n) + " ".join(cells))
for name, c, mu in CASES:
D = demands(c, mu)
print(" {:<10} bound 1/max D = {:.1f} per day".format(
name, 1 / max(D)))
# jobs in throughput per day (lead time, days)
# progress base content x2 +1 closer
# 2 11.58 (0.173) 13.16 (0.152) 12.57 (0.159)
# 5 17.88 (0.280) 19.69 (0.254) 19.57 (0.256)
# 10 21.57 (0.464) 22.87 (0.437) 23.93 (0.418)
# 20 23.51 (0.851) 23.92 (0.836) 26.69 (0.749)
# 40 23.98 (1.668) 24.00 (1.667) 27.84 (1.437)
# base bound 1/max D = 24.0 per day
# content x2 bound 1/max D = 24.0 per day
# +1 closer bound 1/max D = 28.0 per dayHowever large is, throughput cannot exceed : 24.0 jobs a day for both the original plan and the content-doubled plan, 28.0 for the plan with an extra closer. With a very low cap things differ: at the content-doubled plan delivers 13.16 jobs a day, more than the extra closer’s 12.57 and the original 11.58, because at that point every station’s speed sets the turnover directly. With the cap relaxed to 40 jobs the three deliver 23.98, 24.00 and 27.84.
Summary
In the illustrative four-team network the conversion team (load 0.833) is the bottleneck. Automating the content team shortens the lead time, but the maximum throughput stays at 24.0 jobs a day; only adding capacity at the bottleneck raises it, to 28.0. Only when work in progress is held very low does the speed of a non-bottleneck feed directly into output.
References
Fan, Y. (2026). Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds: Theory-of-Constraints Queueing Networks, Margin Dilution Matrices and Value-Based Advisory Pricing [企业瓶颈诊断、产品线自蚕食审计与自动化改造回报边界] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090217 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).