From design to cut list: spreadsheet, CAD or optimizer

Every cut list starts as a design, and every design has to cross a translation gap before it becomes something a saw can execute. That gap is where most waste and most mistakes are actually introduced — not at the saw, but in the spreadsheet or CAD export that fed it. There are three common paths across that gap, and each has a failure mode worth knowing before you pick one for your shop.

The spreadsheet path

A plain spreadsheet — one row per part, columns for length, width, thickness, quantity, material, grain — is the lowest-friction starting point and the one every shop can use without buying anything. It's also the easiest to get wrong silently: nothing stops you from entering a part backwards (width where length should be), duplicating a row, or leaving the material column blank. Spreadsheets have no concept of a sheet, a kerf, or a guillotine constraint, so once your list is built you still need to run it through something else to actually get a layout.

The CAD export path

Cabinet design software (whether general CAD or dedicated cabinet/furniture design tools) can export a parts list directly from the 3D model, which eliminates transcription errors — the dimensions come from the model, not from someone re-measuring a drawing. The trade-off is that CAD exports are often verbose and inconsistently formatted: hardware, dowels, and non-sheet items may be mixed in with panel parts, part names may be auto-generated and unreadable, and thickness is sometimes expressed as a material name rather than a number. You'll almost always need a cleanup pass before this data is cut-list-ready.

The dedicated optimizer path

A dedicated cut list optimizer takes parts (from a spreadsheet, a CAD export, or manual entry) and turns them into an actual sheet layout: sheet count, waste percentage, cut sequence, and a guillotine-constrained, numbered, printable result. This is the only one of the three that answers the questions you actually need answered before buying material — how many sheets, how much waste, which parts don't fit. Neither a spreadsheet nor a raw CAD export does that on its own.

Data hygiene rules that apply to all three

Regardless of which path produced your part list, the same hygiene rules decide whether the final cut list is trustworthy. Sloppy input data produces a layout that's technically valid and practically wrong — the optimizer will happily nest a part entered backwards, it just won't fit in your cabinet.

• Keep length and width in a fixed, documented orientation (e.g. length = the grain-direction dimension) across every row and every part source.
• Never leave thickness or material blank; group by both together, since 18 mm melamine and 18 mm birch ply are not interchangeable on a layout.
• Use one unit throughout the list — mixing mm and inches in adjacent rows is the single most common source of a part that's ten times too big.
• Round to a sane precision (0.1 mm or 1/16 in) and strip trailing formulas or references that don't survive a copy-paste into another tool.
• Flag parts that need special grain orientation or that must not be rotated, before the list reaches the optimizer.

Part naming

Give every part a short, human-readable name tied to the build drawing — "L-side-560", "shelf-800-B" — rather than relying on row order or a generic "Part 1, Part 2" sequence. CAD exports are the worst offenders here, often naming parts after internal model IDs that mean nothing on the shop floor. A cut list where you can't identify which physical piece came from which row is a cut list you'll mis-assemble at glue-up, regardless of how good the sheet layout was.

Thickness grouping

Sort and batch your part list by thickness before it goes anywhere near a layout, because mixing thicknesses in one nesting run either produces nonsense (parts sharing a sheet that isn't the right thickness) or forces the optimizer to silently split into sub-runs you didn't ask for. If your job uses 18 mm carcass material and 6 mm back panels, treat them as two completely separate cut lists with two separate sheet counts from the start.

Handling multiple materials

A single project frequently spans melamine-faced board for carcasses, plywood for backs, and solid edging for visible edges. Keep a material column that's an exact match to what you'll actually order — not just "18mm" but "18mm white MFC" versus "18mm birch ply" — and run each material through the optimizer separately. Combining them in one pass to save a step is how shops end up ordering the wrong sheet count of the wrong material, because the tool averaged waste across materials that were never on the same sheet.

Checklist before cutting

1. Every part has length, width, thickness, quantity, and material filled in — no blanks.
2. Length/width orientation is consistent across the whole list.
3. Parts are grouped and run separately by thickness and material.
4. Grain-critical parts are flagged and locked against rotation.
5. Part names match the build drawing, not internal model IDs.
6. The optimizer output is guillotine-constrained if it's going to a panel saw.
7. Kerf and sheet size in the optimizer match your actual saw and stock.

Version control when the design changes mid-job

Designs change after cutting has started more often than anyone plans for — a client asks for one more shelf, or a measurement on-site turns out to be wrong. The moment that happens, treat the cut list as a new revision rather than editing the original in place: rename the file with a revision number, note exactly which parts changed, and re-run the whole thing through the optimizer rather than hand-patching the sheet layout. Hand-patching a layout after a design change is how a shop ends up cutting a superseded part from an old sheet plan sitting on the same bench as the new one.

Getting labels and part IDs onto the shop floor

A cut list is only useful on the floor if the physical part can be matched back to its row without a lookup table in someone's head. Printed labels — even simple painter's-tape-and-marker labels applied right after cutting — carrying the part name from your list prevent the classic mix-up where two similarly sized parts from different cabinets get swapped during assembly. For higher-volume shops, a barcode or QR code on each label that links back to the row in your part list turns a five-minute manual lookup into a phone-scan, but even without that infrastructure, consistent manual labelling at the saw closes most of the gap between a clean digital cut list and a clean physical build.

Auditing the optimizer's output before you commit material

Before ordering sheets off any optimizer result, spot-check three things: that the total part count in the output matches your input list exactly (a filtered or partially-imported list is a common silent error), that the sheet dimensions used match what you'll actually buy, and that at least one part on each sheet diagram has its labeled size checked by hand against a tape measure on the printed layout. This two-minute audit catches unit mismatches, accidental duplicate imports, and stale cached results far more reliably than trusting a total sheet count on faith, and it costs nothing compared to discovering the error after the first sheet is already cut.

Bottom line

The workflow you choose matters less than the discipline you apply before the data reaches a layout tool. A clean spreadsheet beats a messy CAD export every time, and either one only becomes a usable cut list once it's been through an optimizer that enforces sheet size, kerf, and guillotine constraints.

Next steps. Load a sample project at /examples to see a clean part list format, then run your own list through the cut list optimizer and check it against the checklist above before you cut.