DEV Community: PackForge Industries

Find the Bottleneck in a Packing Line with 20 Lines of Python

PackForge Industries — Tue, 27 Oct 2026 08:36:48 +0000

A packing line is just a pipeline: fill, seal, label, carton, tape, strap, wrap. Like any pipeline, it runs at the speed of its slowest stage. If you have ever profiled code, you already know how to think about this.

Normalise every stage to the same unit

Machine specs come in mixed units: cartons per minute, cartons per hour, metres per minute of belt speed. Convert everything to units per hour first.

def per_hour(value, unit, carton_length_mm=None, gap_mm=0):
    if unit == "per_min":
        return value * 60
    if unit == "per_hour":
        return value
    if unit == "m_per_min":  # belt speed -> cartons, needs carton length
        pitch_m = (carton_length_mm + gap_mm) / 1000
        return value / pitch_m * 60
    raise ValueError(unit)

The belt-speed case matters: a carton sealer rated at 24 m/min does not seal 24 cartons a minute. With 400 mm cartons and a 400 mm gap between them, that is 30 cartons a minute, and the real limit is usually how fast people can feed it.

Model the line

line = {
    "filling":        per_hour(18, "per_min"),
    "carton sealing": per_hour(24, "m_per_min", carton_length_mm=400, gap_mm=400),
    "flap fold + seal": per_hour(25, "per_min"),
    "random sealer":  per_hour(600, "per_hour"),
}

bottleneck = min(line, key=line.get)
for stage, rate in sorted(line.items(), key=lambda kv: kv[1]):
    util = line[bottleneck] / rate
    print(f"{stage:18} {rate:7.0f}/h  utilisation {util:5.0%}")
print("Bottleneck:", bottleneck, "->", round(line[bottleneck]), "units/hour")

Output:

random sealer          600/h  utilisation  100%
filling               1080/h  utilisation   56%
flap fold + seal      1500/h  utilisation   40%
carton sealing        1800/h  utilisation   33%
Bottleneck: random sealer -> 600 units/hour

(The filling rate is illustrative; the sealer figures are real spec values.)

What to do with the result

Upgrading a non-bottleneck stage is wasted money. In the example, a faster carton sealer changes nothing.
Low utilisation is a signal, not a failure: those stages can absorb short stoppages elsewhere.
Add buffers (accumulation tables) in front of the bottleneck so it never starves.

The sealer numbers above (24 m/min belt speed, up to 25 cartons/min with flap folding, about 500 to 700 mixed cartons per hour on a random size sealer) come from this overview of automatic carton sealing machines, if you want to plug in other real figures.

Induction Cap Sealing Explained for Engineers: Eddy Currents in a Bottle Cap

PackForge Industries — Tue, 27 Oct 2026 08:35:51 +0000

Peel the foil off a new bottle of medicine or cooking oil and you are looking at a neat bit of applied physics. That foil was sealed to the bottle rim without anything touching it, through a closed plastic cap. Here is how it works, and what it means if you ever have to integrate one of these machines into a line.

The stack inside the cap

An induction-ready cap contains a liner (the "wad") that is typically a layered stack: a backing layer, an aluminium foil layer and a heat-seal coating that faces the bottle rim.

The physics

The sealing head drives an alternating current through a coil, creating an alternating magnetic field.
The field passes straight through the plastic cap, because plastic is not a conductor and does not heat up.
In the aluminium foil, the changing field induces eddy currents.
Those currents meet the foil's electrical resistance and turn into heat (Joule heating, P = I²R).
The heat-seal coating melts onto the bottle rim and bonds as it cools, leaving a tamper-evident, leak-proof inner seal.

The cap and the product are not heated directly; only the conductive foil is.

Why seals fail (the debugging checklist)

Loose cap: the foil is not pressed against the rim, so it heats but does not bond.
Contaminated rim: oil or syrup on the rim blocks bonding.
No foil wad: no conductor, no heating. The machine cannot seal a cap without the wad.
Wrong dwell or power: too little energy gives a weak bond, too much can scorch the liner.

Modeling energy per bottle

On a conveyor sealer, energy delivered per cap depends on head power and how long the cap spends under the coil:

def dwell_s(coil_length_mm: float, conveyor_m_per_min: float) -> float:
    return (coil_length_mm / 1000) / (conveyor_m_per_min / 60)

for speed in (2, 6, 12):  # m/min
    print(speed, "m/min ->", round(dwell_s(300, speed), 2), "s under the coil")
# 2 m/min -> 9.0 s, 6 m/min -> 3.0 s, 12 m/min -> 1.5 s

The coil length here is an illustrative value, but the relationship is the point: double the conveyor speed and you halve the dwell, so power must rise or seal quality drops.

Hand-held vs conveyor

Hand-held units (around 500 W) are held over each capped bottle, while continuous conveyor units (around 2000 W) seal bottles as they pass under the head. If you want real-world specs for both types, this overview of induction sealing machines lists cap ranges and power ratings.

Thermal Label Printing Math: DPI, Dots per mm and Barcodes That Actually Scan

PackForge Industries — Tue, 27 Oct 2026 08:29:34 +0000

If you generate shipping or product labels from a web or mobile app, sooner or later a barcode prints fine on screen but refuses to scan. Nine times out of ten the cause is simple arithmetic: your design was not snapped to the printer's dot grid.

Step 1: convert DPI to dots per mm

Thermal printers burn whole dots. A 304 DPI head gives:

dots_per_mm = 304 / 25.4 ≈ 11.97 ≈ 12 dots/mm

A common 203 DPI head gives about 8 dots/mm. Everything you draw should be a whole number of dots.

Step 2: know your printable width

The paper roll width is not your canvas. A 58 mm roll has margins, and the print head is narrower than the roll, so check the printable width in the spec sheet. Then:

const dpi = 304;
const dotsPerMm = dpi / 25.4;
const printableMm = 48;               // example value: confirm for your printer
const canvasWidthDots = Math.floor(printableMm * dotsPerMm); // 574

Render your label to a canvas exactly that many pixels wide and send it 1:1. Any scaling step will smear thin bars.

Step 3: snap barcode modules to whole dots

A 1D barcode is built from "modules" (the narrowest bar). If the module is 2.5 dots wide, the printer rounds some bars up and some down and the ratios break.

function moduleDots(targetMm, dotsPerMm) {
  return Math.max(2, Math.round(targetMm * dotsPerMm)); // never below 2 dots
}
const m = moduleDots(0.25, 304 / 25.4); // 3 dots = 0.25 mm per module

Then check the whole barcode still fits: for Code 128, width in modules depends on the data, so compute it before choosing the module size, and drop to a smaller module only if it still stays at 2+ dots.

Step 4: practical checks

Use direct thermal rolls of the right width; ordinary paper prints blank on a direct thermal printer.
Print in pure black and white. Grey anti-aliasing turns into random dots.
Test-scan a barcode every time you change roll type.

The example numbers here (304 DPI, 58 mm rolls) come from a real compact Bluetooth label printer; the thermal label printer spec page is a handy reference if you are working with similar hardware.

Modeling a Stretch Wrapper Recipe in Code: Turntable RPM, Wrap Counts and Cycle Time

PackForge Industries — Tue, 27 Oct 2026 08:28:54 +0000

Industrial machines often store "recipes": named sets of parameters that a PLC loads so the same machine can handle different loads consistently. A stretch wrapping machine is a nice, concrete example to model in code.

What a stretch wrapper actually does

A turntable rotates the load.
A film carriage travels up and down a tower, laying stretch film around the load.
Pre-stretch stretches the film before it reaches the load, so each load uses less film.
A PLC stores named programmes, so one machine can wrap several load types the same way every time.

A recipe as data

from dataclasses import dataclass

@dataclass
class WrapRecipe:
    name: str
    turntable_rpm: float      # e.g. 3 to 12 rpm on a pallet wrapper
    bottom_wraps: int
    top_wraps: int
    up_down_passes: int       # carriage travels
    load_height_mm: int
    carriage_speed_mm_s: float

    def cycle_time_s(self) -> float:
        sec_per_rev = 60 / self.turntable_rpm
        wraps_time = (self.bottom_wraps + self.top_wraps) * sec_per_rev
        travel_time = self.up_down_passes * self.load_height_mm / self.carriage_speed_mm_s
        return round(wraps_time + travel_time, 1)

    def loads_per_hour(self) -> int:
        return int(3600 // self.cycle_time_s())

heavy = WrapRecipe("heavy pallet", turntable_rpm=10, bottom_wraps=3, top_wraps=2,
                   up_down_passes=2, load_height_mm=1500, carriage_speed_mm_s=60)
print(heavy.cycle_time_s(), "s per load")      # 80.0 s per load
print(heavy.loads_per_hour(), "loads per hour") # 45 loads per hour

The numbers above are illustrative, but the structure is exactly why PLC recipes exist: change one field (more bottom wraps for a heavy base, slower rpm for a tall unstable load) and every operator gets the same result.

Validating recipes against machine limits

A recipe should never ask for more than the machine can do. Encode the limits next to the data:

LIMITS = {"turntable_rpm": (3, 12), "max_load_kg": 2000}

def validate(r: WrapRecipe, load_kg: float):
    lo, hi = LIMITS["turntable_rpm"]
    if not lo <= r.turntable_rpm <= hi:
        raise ValueError(f"rpm {r.turntable_rpm} outside {lo}-{hi}")
    if load_kg > LIMITS["max_load_kg"]:
        raise ValueError("load exceeds turntable rating")

Those limits are taken from a real spec: a pallet wrapper with a 2000 kg turntable and 3 to 12 rpm speed range. Real machines quote roughly 20 to 40 loads per hour, which is a good sanity check for your model.

If you want to see how the physical machines compare (pallet vs box wrappers, top press, PLC models), this stretch wrapping machine buying guide lays out the real specs behind the numbers used here.

Build a Machine Payback Calculator in Plain JavaScript (With Real Price Data)

PackForge Industries — Tue, 27 Oct 2026 08:04:13 +0000

Small factories often ask one question before buying equipment: how many months until this machine pays for itself? It is a nice little problem to code, because the maths is simple but the inputs need care.

In this post we build a tiny, dependency-free payback calculator, using carton sealing machines as the example.

The formula

monthly_value = labour_saved + tape_saved - running_cost
payback_months = machine_price / monthly_value

Labour saved comes from the time difference per carton:

hours_saved_per_month = cartons_per_day * (manual_sec - machine_sec) / 3600 * working_days
labour_saved = hours_saved_per_month * cost_per_hour

The code

function payback({ price, cartonsPerDay, manualSec, machineSec,
                   workingDays, costPerHour, tapeSavedPerMonth = 0,
                   runningCostPerMonth = 0 }) {
  if (machineSec >= manualSec) throw new Error("Machine must be faster than manual taping");
  const hoursSaved = cartonsPerDay * (manualSec - machineSec) / 3600 * workingDays;
  const monthlyValue = hoursSaved * costPerHour + tapeSavedPerMonth - runningCostPerMonth;
  if (monthlyValue <= 0) return { monthlyValue, months: Infinity };
  return { monthlyValue: Math.round(monthlyValue), months: +(price / monthlyValue).toFixed(1) };
}

console.log(payback({
  price: 69730,        // semi automatic sealer, before GST (INR)
  cartonsPerDay: 400,
  manualSec: 30,
  machineSec: 12,
  workingDays: 26,
  costPerHour: 100,
  runningCostPerMonth: 600
}));
// -> { monthlyValue: 4600, months: 15.2 }

Feeding it real prices

Hard-coding one price is fine for a demo, but a real tool should let the user pick a model. Here is a small price table (INR, before 18% GST) you can drop into a <select>:

const models = [
  { name: "Compact sealer",               price: 57500 },
  { name: "Semi automatic top & bottom",  price: 69730 },
  { name: "102TUS (small cartons)",       price: 98560 },
  { name: "102TU (standard cartons)",     price: 107520 },
  { name: "102TR pneumatic, auto size",   price: 250880 },
];
const withGst = p => Math.round(p * 1.18);

Things worth handling

Guard against zero or negative value. If running costs beat the savings, payback is "never", so return Infinity instead of a negative number.
Keep GST separate. Businesses that claim input tax credit usually compare ex-GST prices.
Be honest in the UI. Savings are only real if the freed staff time is used elsewhere or overtime falls, so label the result as an estimate.

The price figures above come from PackForge's published carton sealing machine price list. Swap in your own numbers and you have a useful little tool for any equipment purchase.