Industrial Engineering Calculator

Little's Law Calculator

Relate average Work-In-Process (WIP), Throughput and Lead Time in a stable system. The fundamental relationship of lean manufacturing and queuing theory: WIP = Throughput × Lead Time.

Little's Law

Long-run averages for a stable system

WIP (L)

120.00

items in system

=

Throughput (λ)

30.00

items / time

×

Lead Time (W)

4.00

time in system

Input Parameters

Choose which variable to solve for, then enter the other two.

units

Average number of items currently in the system.

units / time

Average rate at which items leave the system.

Material Note

Material properties can vary significantly based on heat treatment and manufacturer. Always consult specific supplier datasheets for critical components.

Lead Time (W)

4.000time

WIP

120.00

Throughput

30.00

Lead Time

4.00

Interpretation

In a stable system, an average of 120.0 items are in process. Items leave at a rate of 30.00 per time unit, so each item spends on average 4.00 time units in the system.

Governing Formula

L = λ × W

WIP = Throughput × Lead Time

L (WIP)units

Average items in the system

λ (Throughput)units / time

Average completion rate

W (Lead Time)time

Average time in the system

Calculation Assumptions

  • System is stable (long-run averages)
  • Consistent units for all variables
  • Arrival rate ≈ departure rate
  • Applies to average values only
  • No major capacity changes during period
  • Holds for any stable process / queue

Engineering Code

Reuse the calculation in your own planning or simulation tools.

Python
def littles_law(wip=None, throughput=None, lead_time=None):
    """
    Little's Law: WIP = Throughput × Lead Time

    Provide any two values; the third is calculated.
    """
    provided = sum(x is not None for x in (wip, throughput, lead_time))
    if provided != 2:
        raise ValueError("Provide exactly two of the three values.")

    if wip is not None and throughput is not None:
        if wip <= 0 or throughput <= 0:
            raise ValueError("Values must be > 0")
        lead_time = wip / throughput
    elif wip is not None and lead_time is not None:
        if wip <= 0 or lead_time <= 0:
            raise ValueError("Values must be > 0")
        throughput = wip / lead_time
    else:
        if throughput <= 0 or lead_time <= 0:
            raise ValueError("Values must be > 0")
        wip = throughput * lead_time

    return {"wip": wip, "throughput": throughput, "lead_time": lead_time}


# Example – solve for Lead Time
result = littles_law(wip=120, throughput=30)
print(f"WIP         : {result['wip']:.3f} units")
print(f"Throughput  : {result['throughput']:.3f} units/time")
print(f"Lead Time   : {result['lead_time']:.3f} time units")
MATLAB
function result = littles_law(wip, throughput, lead_time)
    % Little's Law: WIP = Throughput × Lead Time
    % Pass NaN for the unknown variable.

    known = ~isnan([wip, throughput, lead_time]);
    if sum(known) ~= 2
        error('Provide exactly two of the three values.');
    end

    if ~isnan(wip) && ~isnan(throughput)
        lead_time = wip / throughput;
    elseif ~isnan(wip) && ~isnan(lead_time)
        throughput = wip / lead_time;
    else
        wip = throughput * lead_time;
    end

    result.wip = wip;
    result.throughput = throughput;
    result.lead_time = lead_time;
end

% Example
r = littles_law(120, 30, NaN);
fprintf('WIP         : %.3f units\n', r.wip);
fprintf('Throughput  : %.3f units/time\n', r.throughput);
fprintf('Lead Time   : %.3f time units\n', r.lead_time);
Excel Formulas
Lead Time  = WIP / Throughput
Throughput = WIP / Lead Time
WIP        = Throughput * Lead Time

Example Calculation

A production cell has an average of 120 units of WIP and completes 30 units per hour. What is the average lead time?

Lead Time = WIP / Throughput = 120 / 30
Lead Time = 4.000 hours

Technical Explanation: Little's Law in Operations and Queuing Theory

Little's Law is a foundational theorem in operations research, queuing theory, and industrial engineering. It establishes a deterministic relationship between three critical performance metrics of any stable system: the average number of items in the system (Work-In-Process or WIP), the average rate at which items exit the system (Throughput), and the average time an item spends in the system (Lead Time). Engineers and operations managers use this law to diagnose production bottlenecks, design pull-based manufacturing systems (such as Kanban), and optimize service operations without needing to model complex underlying probability distributions of arrivals or service times.

Governing Formula

The fundamental equation is elegantly simple and dimensionally consistent:

L = λ × W

In manufacturing and operational terms, this is expressed as:

WIP = Throughput × Lead Time
  • WIP (L): The average number of items (parts, customers, tasks) currently inside the defined system boundary.
  • Throughput (λ): The average rate at which items are completed and exit the system (e.g., units per hour, tasks per day).
  • Lead Time (W): The average time an individual item spends within the system from entry to exit.

Conceptual Foundation and Derivation

While Little's Law is often treated as an operational axiom, it can be conceptually derived from the conservation of flow. Imagine plotting the number of items in a system over time. The area under this curve represents the total "item-time" accumulated in the system. If we observe the system over a long period T, the total number of arrivals equals the total number of departures (due to system stability).

The average number of items in the system (WIP) is the total area under the curve divided by T. The average time an item spends in the system (Lead Time) is the total area under the curve divided by the total number of items processed (N). Throughput is simply N / T. Therefore, WIP = (Total Item-Time / T) = (Total Item-Time / N) × (N / T) = Lead Time × Throughput. This derivation proves that the relationship is purely geometric and relies only on long-term averages, not on specific arrival or service distributions.

Input Parameters and Physical Meaning

  • Work-In-Process (WIP): Represents the physical or logical inventory tied up in the process. A common mistake is including raw materials in a warehouse or finished goods in shipping; WIP strictly includes items that have entered the process but have not yet completed it.
  • Throughput: The actual output rate, not the theoretical maximum capacity. If a machine can produce 100 units/hour but is starved for materials and only produces 60 units/hour, the throughput for Little's Law is 60.
  • Lead Time: Also known as cycle time or flow time. It encompasses both active processing time and waiting time. In many manufacturing systems, waiting time constitutes over 90% of the total lead time.

Engineering Interpretation

Little's Law reveals a profound operational truth: if throughput is constrained by a bottleneck and cannot be easily increased, the only way to reduce lead time is to reduce WIP. This is the mathematical justification for Lean manufacturing principles. By intentionally limiting WIP (e.g., via Kanban cards), engineers force the system to expose hidden inefficiencies, reduce queueing delays, and improve flow. Conversely, artificially inflating WIP without increasing throughput does not increase output; it only inflates lead times, ties up working capital, and obscures quality defects.

Units and Unit Consistency

The dimensional consistency of Little's Law is straightforward but strictly enforced. The time unit in Throughput must be the inverse of the time unit in Lead Time.

  • If Throughput is measured in units / day, Lead Time must be in days.
  • If Throughput is 15 parts / hour, and WIP is 45 parts, then Lead Time = 45 / 15 = 3 hours.

Mixing units (e.g., throughput in parts per week and lead time in days) will yield mathematically incorrect results. Always normalize time bases before calculation.

General Case and Subsystems

A powerful feature of Little's Law is its universality. It applies not only to the entire factory but to any defined subsystem. You can apply it to a single workstation, a specific queue before a machine, or an entire global supply chain. Furthermore, it applies to service industries (e.g., average number of customers in a bank = arrival rate × average time in bank) and software engineering (e.g., average number of active bugs = discovery rate × average time to resolve).

Assumptions and Limitations

For Little's Law to hold strictly true, the following assumptions must be met:

  • System Stability: The system must be in a steady state over the long run. The average arrival rate must equal the average departure rate. If WIP is continuously growing (e.g., a system collapsing under demand), the law does not apply to transient states.
  • Conservation of Flow: Items are neither created nor destroyed within the system boundary.
  • Long-Run Averages: The law describes asymptotic behavior. Short-term fluctuations or transient startup phases may temporarily violate the equation.

Practical Engineering Use

  • Kanban System Design: Calculating the required number of Kanban cards to achieve a target lead time given a known throughput.
  • Bottleneck Analysis: Estimating the hidden lead time in a congested production cell by simply counting the physical WIP and measuring the exit rate.
  • Software Development: Managing Agile/Scrum workflows by limiting Work-In-Progress to accelerate feature delivery (Lead Time).
  • Healthcare Operations: Estimating patient wait times in an emergency department based on the average number of patients present and the discharge rate.

Real-World Engineering Cases

The Factory Floor Traffic Jam

A factory manager wanted to increase output, so they dumped 50% more raw materials (WIP) onto the production floor. However, the machines' processing speed (Throughput) remained unchanged. According to Little's Law, the only result was a massive increase in Lead Time. Parts sat in piles waiting for machines, clogging the aisles and slowing down workers.

Engineering Lesson

You cannot force a system to produce more simply by stuffing it with more work. If Throughput is fixed, increasing WIP only increases Lead Time (delays). To improve output, you must fix the bottleneck, not flood the floor.

Continue Calculating

calculators

Calculators

Quickly calculate and analyze parameters for your calculators requirements.

Open
calculators

Civil

Quickly calculate and analyze parameters for your civil requirements.

Open
calculators

Beam Bending Moment

Quickly calculate and analyze parameters for your beam bending moment requirements.

Open

Frequently Asked Questions

What is Little's Law?

Little's Law states that the average number of items in a stable system (WIP) equals the average throughput rate multiplied by the average time an item spends in the system (Lead Time): L = λ × W.

Does it require any distribution assumptions?

No. Little's Law is distribution-free. It holds for any stable system as long as long-run averages are used. Arrival process, service times and number of servers can be arbitrary.

How do I reduce lead time using Little's Law?

Either increase throughput (capacity) or reduce WIP. In many factories the fastest and cheapest lever is to lower WIP through pull systems, smaller batch sizes or tighter Kanban limits while keeping throughput constant.

What units should I use?

Any consistent set. Common choices are units + units/hour + hours, or units + units/day + days. The time unit of throughput and lead time must match.

Calculations provided by this tool are for educational and preliminary analysis purposes. Little's Law applies to long-run averages in stable systems. Always validate assumptions and data quality before using results for operational or capacity decisions.