Little's Law

Performance Engineering

Meaning

Little's Law states that the average number of items in a stable system (WIP) equals the average arrival rate (throughput) multiplied by the average time an item spends in the system (cycle time). It helps engineers predict how long work will stay in a process based on observed flow. You reach for it when you need to relate capacity, demand, and latency in a production or service environment.

Primary Function

Performance analysis

Communicative Purpose

Enables estimation of cycle time from observed throughput and work‑in‑process.

Pattern

measure WIP and throughput → apply Little's Law → derive cycle time

Core Structure

WIP = throughput * cycle_time

Função primária

Performance analysis

Propósito comunicativo

Enables estimation of cycle time from observed throughput and work‑in‑process.

Situações de gatilho

Manufacturing: estimating lead time when daily output and work‑in‑process are known Web services: sizing server pool based on request rate and average handling time Kanban systems: forecasting delivery dates from current WIP and throughput

Contextos

Operations research, software performance engineering, DevOps capacity planning, lean manufacturing, agile workflow tools

Padrão

measure WIP and throughput → apply Little's Law → derive cycle time

Estrutura central

WIP = throughput * cycle_time

Colocados típicos

throughput
cycle time
work‑in‑process
lead time
utilization

Substituições comuns

using average lead time instead of cycle time (same meaning in many contexts) expressing throughput as items per hour versus items per minute (unit conversion) replacing WIP with queue length when the system is a simple FIFO queue

Erros comuns

Assuming Little's Law holds during transient spikes – leads to under‑estimating cycle time Mixing units (e.g., items per minute with hours) – produces nonsensical results Treating WIP as a snapshot count without averaging over time – violates the law's assumptions

Similar / contraste

Kendall's notation – describes queueing model structure, not a simple relationship Kingman's formula – estimates average waiting time for G/G/1 queues, more complex than Little's Law

Interferências

Coming from SQL: using SELECT COUNT(*) as WIP without accounting for time‑averaging → yields a point‑in‑time count, not the average WIP required by Little's Law

Família do chunk

Queueing theory
Throughput analysis
Cycle time estimation

Nuance

Do not use Little's Law for systems with bursty arrivals or non‑steady state behavior The formula is dimensionally consistent; mismatched time units directly affect the computed cycle time It assumes infinite buffer capacity; finite buffers can cause blocking that violates the law

Efeito pragmático

Applying Little's Law lets teams size resources accurately, avoid bottlenecks, and set realistic delivery expectations, reducing over‑provisioning and missed deadlines.

Dica de memória

Think of a highway: the number of cars on the road equals the flow of cars per hour times the average travel time.

Nota

The law requires the system to be in statistical equilibrium; transient periods must be excluded from measurements.

Upgrade path

After mastering Little's Law, move to queueing network models (e.g., M/M/1, M/G/1) for deeper performance analysis.

Frequência: HighFormulaicidade: FixedTipo de construção: conceptPrioridade de aquisição: Recognition firstPrioridade de output: InputTag de espaçamento: Medium-term

Examples

python # Compute cycle time from observed WIP and throughput wip = 120 # items currently in the system throughput = 30 # items per hour cycle_time = wip / throughput # hours per item print(f"Average cycle time: {cycle_time:.2f} hours")

python # Simulate a simple production line and verify Little's Law import random, statistics def simulate(hours, arrival_rate, service_time): wip_samples = [] items_completed = 0 wip = 0 for _ in range(hours * 60): # minute granularity # arrivals if random.random() < arrival_rate / 60: wip += 1 # service completions if wip > 0 and random.random() < 1 / service_time: wip -= 1 items_completed += 1 wip_samples.append(wip) avg_wip = statistics.mean(wip_samples) throughput = items_completed / hours return avg_wip, throughput avg_wip, thr = simulate(1000, arrival_rate=20, service_time=2) print(f"Avg WIP: {avg_wip:.2f}, Throughput: {thr:.2f} items/hr") print(f"Cycle time from Little's Law: {avg_wip / thr:.2f} hr/item")

python # Use pandas to compute average WIP and throughput from a log import pandas as pd # Sample log: timestamp, items_in_system log = pd.DataFrame({ 'timestamp': pd.date_range(start='2023-01-01', periods=100, freq='T'), 'wip': [max(0, int(50 + 10 * pd.np.sin(i/10))) for i in range(100)] }) # Approximate throughput as change in cumulative completions per hour log['completed'] = log['wip'].diff().fillna(0).apply(lambda x: -x if x < 0 else 0) throughput = log['completed'].sum() / (log['timestamp'].iloc[-1] - log['timestamp'].iloc[0]).total_seconds() * 3600 avg_wip = log['wip'].mean() cycle_time = avg_wip / throughput if throughput else float('inf') print(f"Avg WIP: {avg_wip:.1f}, Throughput: {throughput:.2f} items/hr, Cycle time: {cycle_time:.2f} hr/item")