CPG Scheduler
All posts

Run Order Matters: Sequencing SKUs to Slash Total Changeover Time

changeoversschedulingsmedcpg operationssequencing

Run Order Matters: Sequencing SKUs to Slash Total Changeover Time

Picture two lines running the exact same weekly mix — same SKUs, same volumes, same crew skill. One finishes the week with hours to spare. The other is always behind, always cleaning, always apologizing to the shipping dock. The products were identical. The order they ran in was not.

That gap is the difference between a schedule that treats changeovers as fixed overhead and one that treats them as a variable you control. Many plants spend more than 20% of planned production time on changeovers (reliableplant.com). If a fifth of your capacity is going into transitions, the sequence you choose is a throughput lever hiding in plain sight.

Two levers people constantly confuse

There are two very different ways to attack changeover loss, and mixing them up wastes effort.

Lever 1 — Make each changeover faster. This is SMED (Single-Minute Exchange of Die), the method Shigeo Shingo developed while cutting a 1,000-ton press setup from about four hours toward single-digit minutes. SMED separates internal setup (done while the line is stopped) from external setup (prepped while it's still running) and aims to push individual changeovers under ten minutes (leanproduction.com; en.wikipedia.org). We covered the cost framing of that work in the hidden cost of changeovers.

Lever 2 — Trigger fewer expensive changeovers. This is sequencing: choosing the run order so you rarely hit the costly transitions in the first place. SMED shortens each event; sequencing minimizes the sum across a whole cycle. You want both. A ten-minute changeover you never had to do beats a five-minute one you do forty times a week.

This article is about lever two.

What "sequence-dependent" actually means on a line

Here's the core idea: the time and cost of a changeover depend on the pair — what you're coming from and what you're going to — not just on the next SKU by itself.

Switching between product families can require cleaning, temperature changes, or component swaps, so the same two SKUs cost different amounts depending on which one runs first (sciencedirect.com). Going from a clear beverage to a dark cola is a quick rinse. Going the other direction — dark to clear — is a full flush to chase out color carryover. Same two products, wildly different transition.

The drivers you'll see repeatedly on food and beverage lines:

  • Allergen carryover — moving into an allergen-containing SKU is easy; moving out of one demands a validated sanitation.
  • Color and flavor carryover — light shades and mild flavors tolerate a downstream neighbor; strong ones contaminate it.
  • Sugar, fat, and viscosity — thicker, richer, sweeter products leave residue that lighter ones can't run behind.
  • Temperature and sanitation regime — a wet clean-in-place (CIP) between two SKUs costs far more than a dry wipe-down.

Because the cost lives in the transition, not the product, your job is to arrange the products so the cheap transitions happen often and the expensive ones almost never.

The changeover matrix: your single most useful artifact

You cannot sequence what you haven't measured. The foundational tool is a changeover matrix — an N×N grid where the cell in row A, column B holds the time (and/or cost) to go from SKU A to SKU B.

Build it like this:

  1. List your SKUs (or SKU families) down the rows and across the columns. Start with families if the full SKU list is overwhelming — you can refine later.
  2. Fill each cell with the from→to changeover time. Pull the numbers from line logs, sanitation SOPs (a validated allergen wet-clean has a known duration), and, where data is thin, a stopwatch on the floor.
  3. Expect asymmetry. The cell A→B will often differ from B→A. That asymmetry is exactly the information you're going to exploit. If your matrix is perfectly symmetric, you probably haven't looked closely enough.

Reading the matrix, you're hunting for two things: cheap neighbors (pairs with near-zero transition time you want to run back-to-back) and cliff transitions (the wet-clean, full-sanitation monsters you want to hit at most once per cycle). Setup time as a scheduling variable has been recognized since the late 1960s and remains an active research field — a 2025 review synthesized more than 2,100 articles published between 1986 and 2024, so the matrix approach rests on decades of grounding (sciencedirect.com).

Heuristics operators can actually run

You don't need a solver to get 80% of the benefit. These rules of thumb encode the physics of carryover and get you a strong sequence fast:

  • Light to dark. Run clear, pale, and white products first; work toward dark colors. You avoid flushing color backward.
  • Plain → mild → strong. Unflavored or lightly seasoned first, bold and spiced last.
  • Low to high sugar / fat / viscosity. Thin and lean before thick and rich, so residue always moves in the tolerable direction.
  • Allergen-free first, allergen-containing last. Run the clean SKUs early, then step into allergens, and put the full validated sanitation at the end of the campaign — once, not repeatedly.
  • Group into families, then sequence within and across. Order the SKUs inside each family, then order the families using the same light-to-heavy logic.
  • Nearest-neighbor on the matrix. For a quick "good enough" pass: start somewhere, and each time pick the next SKU with the smallest from→to cell that you haven't run yet.

The math, kept light

What you're solving is a classic single-machine (or flow-shop) sequencing problem: find the permutation of jobs that minimizes total setup — mathematically a cousin of the traveling-salesman problem, where "distance" is changeover time. In the permutation flow-shop variant, the job order stays the same across stages, which is the backbone of "optimize the order" (en.wikipedia.org).

The practical truth: finding the provably optimal sequence is hard at real SKU counts, which is why heuristics plus a solver (or an automated scheduler) are the working answer, not hand math. Dedicated models exist for exactly these industries — capacitated lot-sizing with sequence-dependent setups (sciencedirect.com), MIP formulations for the beverage industry (sciencedirect.com), and MILP scheduling of make-and-pack processes in consumer goods (sciencedirect.com). Campaign sequencing on a single processor with sequence-dependent setups is its own studied problem (sciencedirect.com).

And the pure rule always bends to real constraints: due dates, shelf-life / FEFO, allergen validation windows, and tank or CIP availability.

A worked mini-example

Say you run six SKUs. A naïve schedule dumps them in the order the orders arrived:

Dark Cola → Lemon-Lime (clear) → Chocolate Milk → Vanilla Milk → Peanut Bar → Plain Bar

Count the transitions: dark-to-clear (full flush), then a milk crossover, then chocolate-to-vanilla (backward — flush again), then into an allergen (peanut), then peanut-to-plain (full allergen sanitation). You've triggered three cliff transitions.

Now reorder using the heuristics — light to dark, plain to flavored, allergen last:

Lemon-Lime (clear) → Dark Cola → Vanilla Milk → Chocolate Milk → Plain Bar → Peanut Bar

Clear runs before dark (quick rinse forward). Vanilla before chocolate (forward). Plain bar before the peanut bar. The single expensive allergen sanitation now lands at the end of the campaign, where it was going to happen anyway. You've gone from three cliff transitions to essentially zero mid-run — often tens of minutes to hours recovered per cycle, which converts directly into extra run hours and cases without touching a single machine setting.

Where sequencing fits with EPEI, Heijunka, and the wheel

Sequencing is one piece of a stack, and it's worth being precise about the boundaries:

  • EPEI (Every Product Every Interval) decides how often each SKU runs.
  • Heijunka levels the mix and volume so you're not slamming the line with lumpy batches (see also iSixSigma).
  • Sequencing — this article — sets the order within the cycle once frequency and mix are fixed.

They compose. EPEI tells you a SKU appears twice a week; Heijunka spreads those appearances evenly; sequencing decides which neighbors each appearance sits between. If your line is bottleneck-constrained, pair this with drum-buffer-rope scheduling so the recovered changeover time protects the constraint.

Guardrails: don't optimize yourself into trouble

A faster sequence is worthless if it creates a recall risk or a late shipment.

  • Food safety is not negotiable. Never shortcut a validated allergen sanitation to save minutes. Sequencing reduces how often you need it; it never lets you skip it.
  • Respect freshness and date codes. FEFO and customer date-code commitments can override the "ideal" order.
  • Account for crew skill and fatigue. Some transitions are harder to execute cleanly; sequence them when your strongest crew is on.

How to operationalize it

A matrix in a spreadsheet decays fast. Treat it as living data: update cells as recipes, equipment, and sanitation SOPs change. Because orders shift, the ideal sequence shifts too — which is exactly the kind of re-planning a headless, agentic scheduler is built to do, re-sequencing the wheel within the frozen zone as demand moves while still honoring allergen and date-code constraints. It also keeps you out of the reactive firefighting loop that eats planners alive.

Track these KPIs to prove it's working:

  • Total changeover minutes per shift — the headline number.
  • Changeover % of planned production time — is it drifting below that 20% benchmark?
  • OEE availability — recovered changeover time should show up here.
  • Schedule adherence — sequencing shouldn't blow up due-date performance.

Quick-start checklist

  1. Build the matrix. Start at family level, from→to, in minutes.
  2. Pick a heuristic. Light-to-dark, plain-to-flavored, allergen-last, or nearest-neighbor.
  3. Pilot on one line. Run the reordered sequence for a week.
  4. Measure recovered hours. Compare total changeover minutes before and after.
  5. Automate. Hand the matrix and constraints to a scheduler that re-sequences as orders change.

You can't always make each changeover shorter — but you can almost always run fewer of the expensive ones. Order is a lever. Pull it.

Sources

More from the journal

Run Order Matters: Sequencing SKUs to Slash Total Changeover Time · CPG Scheduler