Production Scheduling for Cooked Meat Processing

Cooked meat processing is a classic hybrid-flowshop environment where raw meat moves through sequential batch and flow stages — curing, cooking, chilling, slicing, and packaging — with divergent product routings and allergen-driven changeover constraints. This guide shows production planners and operations managers how to model their cooked meat facility in Schantt so the scheduling algorithm can sequence batches, assign machines, and respect sanitation windows automatically.

This guide follows a fictional composite company built from industry research on cooked meat processing; all names, parameters, and figures are illustrative.

Industry context

Cooked meat processing transforms raw meat into ready-to-eat products through a series of batch and continuous-flow stages. Whole-muscle products such as ham and roast beef receive brine injection followed by extended tumbling before cooking, while emulsified products such as frankfurters are ground and stuffed before entering the smokehouse. Bacon follows a separate path with a long smoking stage, pressing, and then slicing. Despite these divergent front-end routes, all three product classes converge at the cooking stage and pass through the same downstream chilling, slicing, and packaging stages — making this a textbook hybrid-flowshop environment.

A typical SMB facility processes 3,000–7,000 tonnes of meat per year across multiple product classes and dozens of SKUs. Cooking happens in batch smokehouses or steam ovens with capacities of 500–2,000 kg per load and cycle times of 2–8 hours depending on the product type and thickness. Once cooked, every product must be cooled to ≤4°C before it can be sliced — a passive hold that takes 2–6 hours depending on product mass and chiller capacity. High-speed slicers run at 200–400 kg per hour, and packaging lines wrap or vacuum-seal at 150–300 kg per hour. Changeovers between product classes at the cooking and slicing stages can take 20–90 minutes, driven by allergen cleanout requirements — soy-based brines in whole-muscle products versus milk protein in emulsified sausages.

Sterling Valley Meats runs 85 people at a 4,500 m² facility, making three product classes — whole-muscle cooked meats, emulsified sausages, and smoked bacon — across five production stages, scheduled by a three-person planning team.

Process overview

flowchart LR
    Curing["Curing and Marination"] --> Cooking["Cooking and Smoking"] --> Chilling["Chilling"] --> Slicing["Slicing"] --> Packaging["Packaging"]

Five-stage cooked meat production flow from curing through packaging.

Note on skip routing: Emulsified sausage and bacon products skip the curing stage and enter directly at cooking. The transfer time bridging that skip is configured on the Stage detail page.

Scheduling challenges and how Schantt handles them

Cooked meat production at Sterling Valley Meats is driven by finished-product orders — the planning team receives a weekly order book and builds a production sequence around it. The optimizer minimizes total production time — the overall completion time across all products — by sequencing jobs and assigning machines intelligently. Schantt schedules forward from a chosen start date; this guide assumes a one-week planning horizon. Two scheduling modes are available: Auto mode, where the algorithm determines both job sequence and machine assignments, and Semi-Auto mode, where the planner fixes the production order and the algorithm optimises machine assignments within it.

What Schantt handles well

• Sequential multi-stage production with batch and flow stages in the same route
• Parallel machines at each stage — multiple smokehouses, slicers, and packaging lines
• Mixed batch-and-flow pipelines, where batch cooking feeds continuous-flow slicing and packaging
• Multi-product routing with stage skipping — each product class follows its own path
• Sequence-dependent changeovers — directional durations for allergen-driven cleanouts
• Shift-aware availability with scheduled sanitation downtimes and calendar exceptions

How Schantt handles each challenge

1. Mixed batch-and-flow timing across product classes.

• Sterling Valley runs three product classes with very different cooking times — whole-muscle takes 6 hours, emulsified sausages 3 hours, and bacon 10 hours — all sharing the same four smokehouses. The timing mismatch means a planner must decide which smokehouses run which product and in what order, or risk the downstream packaging lines sitting idle while the right product finishes cooking.
• Schantt models each smokehouse as a batch stage with its per-class cycle duration and batch capacity. Slicing and packaging are flow stages with per-class throughput rates. The simulation walks each job sequentially through its stages — curing, cooking, chilling, slicing, packaging — timing each step according to its type: batch stages use the quantity divided by the batch capacity, rounded up, multiplied by the cycle duration, and flow stages use the quantity multiplied by the time per unit derived from the throughput rate. The algorithm explores job sequences and machine assignments to keep the downstream lines fed while minimising total production time.

2. Allergen-driven changeover sequencing.

• Whole-muscle products use a soy-based brine, while emulsified sausages contain milk protein. Switching between these on the same smokehouse requires a full sanitation cleanout taking 90 minutes — three times longer than a same-class changeover. A naive sequence that alternates product classes can lose hours per day to excessive cleanouts, and the planning team's spreadsheet has no way to model this trade-off when deciding the weekly production order.
• Changeover times are configured as directional, per-machine entries — for example, changing Smokehouse-1 from whole-muscle to emulsified sausage carries a 90-minute duration, while same-class changes on the same smokehouse take 30 minutes, and a bacon-to-sausage change takes only 20 minutes. When Auto mode evaluates candidate sequences, it folds each changeover duration into the affected job's start time, naturally favouring sequences that cluster same-class runs to reduce total changeover time. In Semi-Auto mode, the planner's fixed sequence is preserved but the algorithm still assigns jobs to machines to minimise the changeover impact within that order. On the Gantt, each changeover appears as a labelled segment before its operation's processing bar, making it easy to see where time is spent on transitions.

3. Sanitation window scheduling with shared-resource constraints.

• Each smokehouse requires a 4-hour CIP sanitation window once per week. Because all four smokehouses share a single CIP cleaning circuit, only one can be cleaned at a time. The planner must stagger these windows so that no two overlap, while still maintaining production throughput.
• Scheduled sanitation is modeled as a machine downtime window on each smokehouse — a 4-hour block during which that machine is unavailable. The four downtime windows are staggered across the week so that the shared CIP circuit is never double-booked. During scheduling, the algorithm routes work around each machine's downtime, and the Gantt displays the blocked periods as shaded overlays with the reason (CIP sanitation) in the hover detail. The planner reviews the Gantt to confirm the staggered windows have no overlap — Schantt schedules each machine's availability independently, and the shared-CIP overlap check is a manual review step.

4. Cooling hold between cooking and slicing.

• Once cooked, products must cool to ≤4°C before they can be sliced. This cooling hold takes 2–6 hours depending on the product — whole-muscle cools in 4 hours, emulsified sausages in 2 hours, and bacon in 6 hours. The hold has no active processing, but the schedule must account for it so that slicing knows when each batch will be ready.
• The cooling hold is configured as a transfer time on the Stage detail page — from the cooking stage to the chilling stage — with per-product-class durations. Transfer time is applied as wall-clock elapsed minutes, so a multi-hour cooling hold advances continuously regardless of working hours. Once the hold expires, the next active stage (chilling) resumes in working hours. This keeps the product flow realistic without requiring a dedicated cooling stage with capacity tracking.

5. Stage-skipping for divergent product routings.

• Emulsified sausages and bacon skip the curing stage entirely — they enter the production line at the cooking stage. Whole-muscle products go through curing (brine injection and tumbling) before cooking. The planner must set up each product class's route differently without creating phantom operations for stages the product never visits.
• Per-class routing handles this naturally. Whole-muscle products are routed through all five stages: curing → cooking → chilling → slicing → packaging. Emulsified sausages and bacon are routed through the four stages starting at cooking: cooking → chilling → slicing → packaging. When the schedule runs, skipped stages produce no operation, no machine assignment, and no Gantt row — the product simply starts on the Gantt at its first required stage. A bridging transfer time is configured from the curing stage (position 1) to the cooking stage (position 2) so the handoff for classes that enter at cooking still carries the correct forward delay.

What to model in Schantt

Before setting up the schedule, create the production entities that mirror Sterling Valley's physical layout.

Step-by-step setup

1. Create the stages. Add the five stages in production order: Curing and Marination (batch type), Cooking and Smoking (batch), Chilling (flow), Slicing (flow), and Packaging (flow). Set the positions 1 through 5. On each stage, configure the transfer times between consecutive stages:
- Curing → Cooking: 30 minutes
- Cooking → Chilling: 240 minutes for whole-muscle, 120 minutes for emulsified sausages, 360 minutes for bacon (this is the cooling hold)
- Chilling → Slicing: 15 minutes
- Slicing → Packaging: 10 minutes
- Also add a bridging transfer time from Curing to Cooking with a short duration — this carries the handoff for classes that enter at cooking rather than curing.

2. Add the machines. Add machines to each stage: 3 vacuum tumblers and 1 brine injector at curing, 4 smokehouses at cooking, 2 blast chill cells at chilling, 3 slicers at slicing, and 3 packaging lines (flow-wrap, vacuum pack, tray seal).

3. Create the product classes. Define three product classes: Whole-Muscle Cooked Meats (unit: kg), Emulsified Sausages (kg), and Smoked Bacon (kg). Set each class's routing:
- Whole-muscle visits all five stages in order
- Emulsified sausages and smoked bacon skip curing and begin at cooking
- For emulsified sausages, enable partial transfer at the cooking→chilling handoff with a partial quantity of 200 kg — this lets small portions move to chilling while the rest of the smokehouse load finishes cooking

4. Add the products. Add one representative product per class: Smoked Ham (whole-muscle), Frankfurters (emulsified sausage), and Streaky Bacon (smoked bacon). Assign each its colour for Gantt rendering.

5. Set machine capacity parameters. On each machine detail page, configure the processing parameters:

Cooking stage (batch):
- Smokehouses 1–4: 1,200 kg batch capacity with a 360-minute cycle (whole-muscle); 600 kg with a 180-minute cycle (emulsified sausage); 1,000 kg with a 600-minute cycle (bacon)

Curing stage (batch):
- Tumblers 1–3: 800 kg batch capacity with a 720-minute cycle (whole-muscle, tumbling)
- Brine Injector 1: 500 kg batch capacity with a 60-minute cycle (whole-muscle, injection)

Chilling stage (flow):
- BlastChill-1 and BlastChill-2: 600 kg/hr (whole-muscle), 500 kg/hr (emulsified sausage), 400 kg/hr (bacon)

Slicing stage (flow):
- Slicers 1–3: 300 kg/hr (whole-muscle), 250 kg/hr (emulsified sausage), 200 kg/hr (bacon)

Packaging stage (flow):
- PackLine-1 (flow-wrap): 250 kg/hr (whole-muscle), 300 kg/hr (sausage), 200 kg/hr (bacon)
- PackLine-2 (vacuum): 200 kg/hr (whole-muscle), 250 kg/hr (sausage), 180 kg/hr (bacon)
- PackLine-3 (tray seal): 180 kg/hr (whole-muscle), 200 kg/hr (sausage), 150 kg/hr (bacon)

Then add the directional changeover times on each smokehouse and each slicer — a full matrix of 6 directional pairs per machine with longer durations (90 minutes) for class changes involving allergen cleanout between whole-muscle and emulsified sausage, and shorter durations (20–30 minutes) for same-class or bacon-related changes.

6. Configure calendars and downtimes. Set the standard calendar with two shifts per day on weekdays and a reduced Saturday shift: Monday–Friday 06:00–14:30 (first shift) and 14:30–23:00 (second shift), Saturday 06:00–14:30 (overtime), Sunday non-working. Add the calendar exceptions: New Year's Day (non-working), International Workers' Day (non-working), Christmas Eve (working 06:00–12:00 only), Christmas Day (non-working). Then add the scheduled machine downtimes for weekly CIP sanitation on each smokehouse — 4-hour windows staggered across Monday and Tuesday so that the shared cleaning circuit is never in use by two smokehouses at once. Finally, add a year-end plant-wide maintenance shutdown for the last week of December. With these calendars and downtimes in place, every machine's available working hours reflect the actual plant schedule, and the algorithm plans production only during staffed, non-cleaning windows.

For step-by-step instructions on configuring each of these in Schantt, see the Schantt documentation.

Common mistakes

1. Modeling cooling as a separate stage instead of a transfer time. Adding a dedicated cooling stage with machines, capacity, and processing times introduces unnecessary complexity and implies cooler capacity is tracked. In reality, cooling is a passive hold — no machine is doing work. Model it as a per-class transfer time from cooking to chilling to keep the setup simple and the schedule accurate.
Fix: Delete the cooling stage and its machines. Set the cooling duration as the transfer time on the cooking stage's detail page, with a different value for each product class if their cooling times differ.

2. Using a single blanket changeover time for all transitions. When all product class pairs share the same changeover duration, the algorithm cannot favour sequences that cluster similar products to reduce cleanout time. Allergen-driven cleanouts (90 minutes) are three times longer than same-class transitions (30 minutes), and the schedule should exploit that difference.
Fix: Enter directional changeover times for every (from_class, to_class) pair on each shared machine. Use longer durations for allergen-crossing transitions and shorter ones for same-class or low-risk changes.

3. Defining one product class that covers both whole-muscle and sausage routes. A single product class with a routing that visits every stage forces all products through curing, creating phantom operations for classes that should skip it. Products that skip stages need their own routing.
Fix: Create separate product classes for each divergent route. Whole-muscle visits all five stages; emulsified sausage and bacon skip curing and start at cooking. The Gantt then shows each product only on the stages it actually uses.

4. Setting up all four smokehouses with identical availability when they share a single CIP cleaning circuit. If every smokehouse has the same downtime schedule, the schedule may try to clean two at once — but the shared cleaning circuit can handle only one at a time.
Fix: Stagger the downtime windows. Schedule Smokehouse-1 and Smokehouse-2 on Monday (morning and afternoon) and Smokehouse-3 and Smokehouse-4 on Tuesday. Verify on the Gantt that no two smoking machine downtimes overlap.

5. Entering machine throughputs that do not respect the upstream feed rate. If slicing throughput exceeds the chilling stage's effective output, the schedule will show the slicer running faster than meat can be supplied — producing an unrealistic plan where downstream stages appear to run independently of their material supply.
Fix: Enter throughput values that are equal to or lower than the upstream stage's rate. At Sterling Valley, set all three slicers to 200–300 kg/hr per machine and the two upstream blast chillers to 400–600 kg/hr per machine. Because each chiller feeds multiple slicers, the combined chiller throughput (800–1,200 kg/hr total) comfortably covers the combined slicing demand (600–900 kg/hr total), so the chillers always feed at or above the slicing rate.

What a good schedule looks like

When the optimizer runs on a correctly configured model, the Gantt shows each product flowing stepwise through its stages with realistic gaps for changeovers, cooling holds, and shift boundaries.

Before (manual spreadsheet): The planning team spends 6–8 hours per week manually sequencing smokehouse loads and calculating transfer times by hand. Allergen changeovers are tracked in a separate column and frequently missed, leading to a skipped cleanout mid-week that forces a full rework of the remaining days. Cooling holds are approximated as a flat "next day" buffer, which either over-constrains the slicing schedule or overshoots the actual hold window. Sanitation windows are pencilled onto a shared whiteboard and sometimes end up overlapping when two smokehouses are scheduled for cleaning on the same CIP circuit — a conflict nobody notices until the cleaning crew arrives. The result is a schedule that works on paper but breaks under real-world conditions, costing the plant hours of lost throughput each week.

After (Schantt Auto mode): The schedule is built in minutes instead of hours. The algorithm sequences the smokehouse loads to minimise cross-class changeovers — clustering whole-muscle runs together through Monday morning, then executing a single 90-minute cleanout before switching to emulsified sausage, then finishing the week with bacon. Cooling holds appear as scheduled transfer gaps between cooking and chilling on each product's timeline, with different durations per product class (2 hours for sausages, 4 for whole-muscle, 6 for bacon). Sanitation windows display as shaded downtime bands on each smokehouse row, staggered so no two overlap — visible at a glance on the Gantt. The total production time across the week's orders is measurably shorter than the manual plan because the algorithm finds a sequence and machine assignment that the spreadsheet-based approach simply could not evaluate.