How to cut the required parts from fabric, sheet, or panel stock with the least waste — minimizing trim loss while meeting the order in full (known in the literature as cutting stock).
In plain words
Sound familiar?
- Each order batch, the cutter spends 1–3 hours on 'which pattern, which roll, how many'
- Trim loss doesn't drop below 8%; on some batches and materials it climbs to 15–25%
- When a repeat order comes in, the cutter rebuilds the pattern from scratch every time
- Offcuts ('we might need this someday') pile up in the warehouse and never get used
- When a rush order arrives, 'can we cut this from existing offcuts' takes half a day to answer
- When the customer changes a pattern or a dimension, the entire cutting plan must be redrawn
- Material cost is 40–65% of cost of goods sold; even a 3–5 percentage-point improvement in trim loss goes straight to the bottom line
Why it matters
How it's solved
Technical depth
How it's solved
Technical depthOne-liner: Pack different-size pieces onto the same roll/sheet so they complement each other — the gap left by a large piece swallows a smaller piece in the same cut. Versus cutting only one size per sheet, this typically drops trim loss by 3–8 percentage points.
What the software is really doing is this: the cutting pattern your cutter draws on paper in 1–2 hours, it builds in seconds for complex 200-piece orders, and tracks the trim loss continuously. Three stages:
1. It describes the order and the stock. Which pieces — dimensions, quantity, grain or pattern constraints, kerf (cutting width) — and the standard material rolls or sheets — length, width, grade, price. The data flows from the order system automatically, or is entered once into a clean table.
2. It finds the most efficient pattern. The software does not try every possible layout one by one — for 50 different pieces that is mathematically impossible (the combinatorial count is huge). Instead, it uses optimization — a body of work from operations research (a discipline that uses math and computing to solve business-decision problems) that includes column generation and integer programming — to take intelligent shortcuts: for each standard piece of stock, which pieces and in what arrangement. A result comes back within minutes — for each standard piece of stock a layout, with overall trim-loss percentage and total material required.
3. It hands the pattern to the cutting machine or cutter. If there is a CNC cutter, the pattern goes directly to the machine. For manual cutting it appears on the cutter’s tablet or as a printout: which roll to open, how to lay out the pieces, and the cutting order. For a rush order, the software evaluates existing offcuts and suggests ‘we can cut this piece from that remnant’.
It does not replace the cutter’s expertise; think of it as a calculator that scales the layout your cutter does for 20 pieces up to 200, never makes a layout error, and tracks trim loss for every job. The decision is still yours, but every order has a current, comparable cutting plan.
Alternatives
Paper, pencil + the cutter's experience
FreeFree
Who it fits: 10–20 different pieces, single material type, small batches
- + Zero cost
- + Flexible — easy on-the-fly adjustment
- + No capex decision
- − Trim loss climbs fast above 50 pieces (15–25%)
- − Pattern knowledge sits in one person — risk when the cutter is out
- − Offcut stock cannot be evaluated systematically
- − Drawing complex 2D pieces by hand is impractical
Local cutting / CAD-CAM software
Enterprise$500–2,000 setup + $100–400/month (regional SMB pricing)
Who it fits: 20–100 pieces, single sector (textile only or sheet metal only)
- + Local-language interface and support
- + Local CNC machine integration built in
- + Strong visualization of the cutting layout
- − Optimization engine is usually a simple heuristic — no global-optimum guarantee
- − Offcut inventory management is limited
- − Weak on multi-batch orders
International specialized cutting / nesting software
Enterprise$100–500/seat/month subscription, or $30,000–150,000/year licence
Who it fits: 100+ pieces, multiple machines, complex 2D parts, or multi-sector
- + Mature: 1D and 2D nesting, offcut evaluation, real-time recompute
- + Multi-machine integration ready
- + Algorithms hardened over many years — measurable trim-loss difference
- − High licence and consulting cost
- − Rollout takes 2–4 months
- − Local-language support can be limited
Custom build on an open-source solver
Open SourceLicence free; 8–16 weeks of internal development, or $50,000–200,000 of consulting
Who it fits: Large manufacturer with an in-house software team or unusual part geometry
- + No licence cost
- + Fully customizable to your part geometry and material constraints
- + Runs in the cloud or on your own server
- − Requires real technical capacity in-house
- − Ongoing maintenance is real work
- − Optimization and geometry are two separate disciplines; building both teams is expensive
Recommendation
Ask in the meeting
- What algorithm underpins the cutting pattern optimization — heuristic, column generation, full integer programming? At which scale does each kick in?
- Do you support both 1D (rolls, bars) and 2D (sheets) in the same system? How are irregular shapes (e.g. leather pieces) handled?
- How are grain direction, pattern repeat, or material-defect constraints entered?
- Are existing offcuts automatically considered for new orders?
- Is there direct integration with a CNC cutter or cutting table? Which vector formats do you support (DXF, DWG, and similar)?
- When a rush order comes in, how fast does the plan update? How is a half-finished cutting batch handled?
- How do you structure the pilot — how many order batches, how many weeks, what is the success bar?
- If we stop working with you, how do we get our part geometry, cutting pattern, and offcut data back? Is there a standard export format?
Technical details
Editor’s note
On the shop floor this problem is known as “trim-loss reduction”, “the cutting plan”, or “fabric economy”. The academic name is the Cutting Stock Problem (CSP), solved by Gilmore and Gomory in 1961 using column generation — one of the classic problems of combinatorial optimization. Without that context, you cannot tell whether the “cutting planning module” being pitched to you is genuinely searching for a near-optimal solution or just running a simple heuristic.
The point most often overlooked in this segment: many products advertise “cutting planning” but underneath they only run first-fit-decreasing or a similar simple heuristic — place big pieces first and try to squeeze small pieces into the gaps. That works for small problems; once piece variety or material constraints (grain direction, pattern repeat, material defects) increase, trim loss rises sharply. In any demo, ask the vendor to walk through a 30-piece example with 3 stock types and a grain-direction constraint, and explain which algorithm the engine uses and what trim-loss figure it produces.
A step-by-step path for an SMB
Stage 1 — Measure first, plan later. For at least four weeks, log four things in a spreadsheet:
- Material consumed and trim loss per order batch (by weight or square meters)
- Trim loss as a percentage per batch (which order types generate waste?)
- Cutting-plan prep time (how many hours of the cutter’s day)
- Offcut inventory (remnants kept) — quantity and value
Without this baseline you cannot tell which software will deliver which result.
Stage 2 — Build the parts catalog. List the repeating piece dimensions in production: how many distinct shapes, each with its size, angular constraints, and kerf (cutting width). In textile this is the “pattern set”; in sheet metal the “cut list”; in furniture the “panel list”. 30–50 distinct pieces is a good starting point — this catalog is your knowledge capital, and any serious vendor will ask for it first.
Stage 3 — Pilot. Start with 1–2 product lines from your busiest category for 6–10 weeks. Define the success criterion in writing, before the pilot: e.g. “trim loss down 4 percentage points and cutting plan prep time cut in half within 90 days.” If the bar is missed, the pilot ends — keep that exit right in the contract.
Stage 4 — Rollout. If the pilot lands, scale to the whole product range over 2–4 months. Cutter training runs 1–2 weeks; CNC integration adds another 4–8 weeks.
Risks — what can go wrong
- Bad geometry data. If piece sizes are entered wrong, the output rots. Before the pilot, validate each piece against a CAD file or a millimetric measurement.
- Cutter resistance. “The computer draws it wrong, I can do better by hand” is a common reaction. In the pilot, walk through results with the cutter; the software must show transparently which rule was applied and what trim-loss number it produced.
- CNC integration time. Vendors say “1–2 weeks”; in practice it’s 4–8 weeks. Older machine models may need a custom adapter.
- Vendor lock-in. Software that stores part geometry and cutting history in a proprietary format makes migration hard. Put a clause in the contract: “We can export our data in standard open formats (DXF, CSV, or similar) at any time, on request.”
Related cautionary lesson (will be linked once published): “A mid-sized textile shop that dropped its cutting software at month 8 — what they missed.”
A technical view of the solution method
This section holds what you’ll need when talking to a software team or a consultant. It is not what the cutter sees on the daily screen — it is the engine behind the curtain.
The main approaches used for the Cutting Stock Problem:
| Approach | Typical use | Solve time | Guarantees optimum? |
|---|---|---|---|
| Heuristics (FFD, BFD) | Small part variety, fast solve | Seconds | No — trim loss 2–5 points above optimum |
| Column generation | Classic 1D cutting | 1–15 minutes | Practically near-optimal |
| MIP (pattern assignment) | Complex constraints | 5–60 minutes | Yes, given enough time |
| Metaheuristic (GA, simulated annealing) | Irregular 2D shapes | 1–30 minutes | No (near-optimal) |
| Hybrid (MIP + heuristic) | Production setting, real time | 30 seconds – 5 minutes | Practically near-optimal |
In practice: under 50 piece types with a clean 1D problem, column generation is enough. With 100+ pieces, complex 2D geometry, or grain/pattern constraints, a hybrid approach is typically preferred. For irregular 2D parts (e.g. leather cutting), metaheuristic approaches are common.
Objective function choice changes the shape of the solution:
- Total trim loss percentage: “Minimize material cost” — fits high-volume, thin-margin production
- Number of stock units used: “Draw least from inventory” — fits material-scarce situations
- Total cutting time: “Maximize machine utilization” — fits a capacity-constrained shop
- Offcut reusability: “Produce reusable offcuts for the next job” — fits small-batch custom work
Most real deployments use a weighted blend of all four.
Academic references
Listed in the sources block of this page’s frontmatter. The cutting stock problem is one of operations research’s oldest active fields (since 1961); modern work focuses on 2D irregular nesting and real-time recomputation. INFORMS Interfaces and the European Journal of Operational Research archive carry deployment case studies tied to real cutting operations.
Sources
- Gilmore, P. C. and Gomory, R. E. (1961). A linear programming approach to the cutting-stock problem. Operations Research, Vol. 9 — the paper that introduced column generation as the workhorse method for cutting stock.
- Wäscher, G., Haußner, H. and Schumann, H. (2007). An improved typology of cutting and packing problems. European Journal of Operational Research, Vol. 183 — the standard taxonomy of cutting and packing problems.
- Delorme, M., Iori, M. and Martello, S. (2016). Bin packing and cutting stock problems: Mathematical models and exact algorithms. European Journal of Operational Research, Vol. 255 — a comprehensive review of modern methods.
- INFORMS Interfaces — case studies of operations research deployments in cutting and packing operations. informs.org/Publications/Interfaces
Glossary
- Cutting Stock Problem
- The problem of extracting required pieces from standard rolls or sheets with the least waste.
- Column Generation
- A large-scale optimization method that generates candidate decisions (columns) on demand instead of enumerating all of them upfront.
- MIP
- An optimization model where some decision variables are forced to be whole numbers (e.g. number of trucks, number of shifts).