You receive 15 DWG files from a subcontractor. You open the first one. There are 34 layers, none of which match your standard. Half the entities have ByBlock properties. The drawing units are set to millimeters but the geometry is clearly in inches. There are 200 unused blocks cluttering the file. And that is just the first drawing. You have 14 more to go.
If you work in a shop that receives drawings from outside vendors, subcontractors, or customers, this is your reality. Nobody sends you clean files. Every vendor has their own layer convention, their own block library, their own habits. Some are meticulous. Most are not. And every messy file that lands on your desk is time you spend on cleanup instead of actual production work.
I have been cleaning up vendor drawings for years, and over that time I have developed a checklist that handles the most common problems. I will walk you through it here—both the manual approach (for when you want to understand what you are fixing) and the automated approach (for when you just need it done).
The Vendor Drawing Problem
Before we get into the fixes, let me catalog the common issues. If you have worked with vendor files, you will recognize all of these.
Non-Standard Layers
Every vendor uses different layer names. One sends files with "Layer1", "Layer2", "Layer3." Another uses "CONTOUR", "NOTES", "DIMS_ALL." A third uses layers in German. A fourth puts everything on Layer 0 and calls it done.
The problem is not that these are bad layer names (well, "Layer1" is pretty bad). The problem is that they do not match your layer standard. Your CAM software expects entities on "CUT". The vendor put them on "OUTLINE_RED_2024". Someone needs to map one to the other before the file is usable.
ByBlock and ByLayer Property Chaos
AutoCAD entities have three ways to get their color, linetype, and lineweight: from the layer (ByLayer), from the block they are inside (ByBlock), or from a direct assignment (explicit color/linetype/lineweight).
In a well-organized drawing, everything is ByLayer. The layer controls the appearance, and changing the layer changes the appearance. Simple and predictable.
In vendor drawings, you get a mix of all three. Some entities are ByLayer. Some have explicit colors that override the layer color. Some are ByBlock from blocks that were exploded, so they now display as white regardless of what layer they are on. The result is a drawing where the colors you see on screen do not correspond to the layers entities are on, which defeats the entire purpose of visual layer checking.
Wrong Units
This one is subtle and dangerous. A drawing set to millimeters but drawn in inches (or vice versa) will import into your CAM software at the wrong scale. A 4-inch bracket becomes a 4-millimeter bracket. A 100mm plate becomes a 100-inch plate. Either way, the parts are wrong.
You catch this pretty quickly if the scale is off by a factor of 25.4 (the mm-to-inch conversion). But sometimes the units are ambiguous—set to "Unitless" or "Architectural" when the geometry is clearly decimal inches for a machined part. These require manual judgment to resolve.
Garbage Blocks and Unused Data
Vendor drawings accumulate junk. Blocks that were inserted and deleted but still exist in the block table. Layers that were created but never used. Linetypes loaded but never assigned. Text styles defined but never referenced. Dimension styles from every project the vendor has ever worked on.
This junk does not usually cause manufacturing errors, but it bloats the file size, clutters the interface, and can cause confusion. When you open the layer manager and see 47 layers, but only 8 have entities on them, you are wasting time figuring out which 8 matter.
Nested Blocks and XRefs
Some vendor drawings are built as assemblies of nested blocks or external references. When you open the file without the referenced files, you get missing XRef warnings and blank spaces where geometry should be. Or worse, you get the geometry but it is locked inside an XRef that you cannot edit without binding it first.
Nested blocks can also cause layer issues. A block created on one layer, containing entities on five other layers, inserted on a sixth layer—when you try to figure out what layer controls what, it becomes a puzzle.
The Manual Cleanup Checklist
Here is the step-by-step process I follow for manual cleanup. This is the "hard way," and it works, but it takes 30 to 60 minutes per file depending on complexity.
Step 1: AUDIT
Before touching anything, run AUDIT. Type AUDIT at the command line, say yes to fixing errors. This catches database corruption, invalid object IDs, and other internal issues that can cause crashes or weird behavior later. It takes a few seconds and can prevent headaches down the road.
Step 2: Check and Fix Units
Type UNITS and check the insertion units and drawing units. Measure a known dimension in the drawing to verify the scale is correct. If the units are wrong, you may need to scale the entire drawing by 25.4 (to convert inches to mm) or 1/25.4 (to convert mm to inches).
Step 3: Bind XRefs
If the drawing has external references, open the XREF manager and bind any that contain geometry you need. Use "Bind" (not "Insert") to preserve layer names with the XRef prefix, which helps you track where things came from. If there are missing XRefs that you do not need, detach them.
Step 4: Explode Problem Blocks
Identify blocks that need to be exploded for layer reassignment. Be selective—you do not want to explode everything, because some blocks (like title blocks) should stay intact. Focus on blocks that contain mixed-layer entities that need to be separated.
Step 5: OVERKILL
Run OVERKILL on the entire drawing. This removes duplicate and overlapping geometry—duplicate lines sitting exactly on top of each other, overlapping arcs, coincident points. Vendor files frequently have duplicate entities from copy-paste operations, block explosions, or sloppy editing. OVERKILL cleans this up and prevents double-cutting at the laser.
Step 6: Reassign Entity Properties
Select all entities and set color, linetype, and lineweight to ByLayer. This ensures that the layer controls the appearance, not random explicit overrides. You can do this by selecting everything (Ctrl+A), then changing the properties in the Properties panel.
This is also where you need to deal with ByBlock entities. Anything that was ByBlock from an exploded block needs to be changed to ByLayer so it inherits the correct appearance from whatever layer you assign it to.
Step 7: Reclassify Entities to Standard Layers
This is the big one. Using QSELECT, filter by entity type and move entities to your standard layers:
- Select all DIMENSION entities → move to DIMS layer
- Select all TEXT and MTEXT entities → move to TEXT layer
- Select all LEADER and MULTILEADER entities → move to DIMS layer
- Select all HATCH entities → move to HATCH layer
- Manually identify and move remaining geometry: cut lines to CUT, centerlines to CENTERLINE, construction geometry to CONSTRUCTION, etc.
The first four steps are quick because QSELECT can filter by entity type. The fifth step—sorting the remaining lines, arcs, and polylines—is where most of the time goes, because these entity types are ambiguous.
Step 8: PURGE
Run PURGE to remove all unused layers, blocks, linetypes, text styles, dimension styles, and other definition objects. Run it multiple times—purging a block might make a layer unused, which was not purgeable on the first pass. I usually run PURGE three times in a row, or use -PURGE with the "All" option and "Yes" to nested items.
Step 9: Verify
Freeze each layer one at a time and visually verify that the right entities are on the right layers. Check that the cut layer has only cut geometry. Check that no dimensions are hiding on the cut layer. Check that construction geometry is on its own layer and not mixed with the contour.
This visual verification takes 10 to 15 minutes but catches mistakes that save hours (or thousands of dollars) later when the file hits the machine.
Total Time: 30-60+ Minutes Per File
For a simple drawing with 10 layers and a few hundred entities, you can do this in 30 minutes. For a complex drawing with 40+ layers, nested blocks, XRefs, and thousands of entities, it can take over an hour. And if you receive multiple files from the same vendor, you are repeating essentially the same process for each one.
Batch Processing: The Script Approach
If you receive batches of files that have similar problems, AutoCAD’s SCRIPT command can automate some of the repetitive steps. A script file is a plain text file with AutoCAD commands, one per line.
You can write a script that runs AUDIT, OVERKILL, sets all entity properties to ByLayer, runs PURGE three times, and saves the file. This handles the "housekeeping" portion of the cleanup automatically.
The limitation is that scripts cannot make judgment calls. They can run PURGE, but they cannot decide which of 34 vendor layers maps to your CUT layer. They can set properties to ByLayer, but they cannot classify ambiguous geometry. For the layer reclassification step, you still need either human judgment or a smarter tool.
AutoLISP Routines
If you know AutoLISP (or know someone who does), you can write custom routines that go further than scripts. An AutoLISP routine can iterate through entities, check their type, and move them to specific layers based on rules. It can find all dimensions and move them to DIMS. It can find all text and move it to TEXT.
The pros: it is free (if your time writing LISP is free), it runs inside AutoCAD, and you can customize it exactly to your needs. The cons: AutoLISP is a niche language that most people do not know, the routines need to be maintained as your standard evolves, and debugging LISP code is not exactly fun. Also, the same limitation applies—for ambiguous geometry (lines that could be cut geometry or construction lines), LISP has the same trouble distinguishing as a script does.
Automated Layer Normalization
The manual checklist works. Scripts and LISP handle some of the tedium. But the step that consistently takes the most time—reclassifying entities onto standard layers—is the step that benefits the most from automation.
This is what LayerGuard’s RebuildToStandard mode was designed for. Instead of manually sorting entities layer by layer, you run one command and the plugin classifies every entity in the drawing based on its type and properties, then assigns it to the appropriate standard layer.
Here is what a typical transformation looks like. You start with a vendor drawing that has 47 layers with names like "0", "Layer1", "CONTOUR_NEW", "DIMS - COPY", "notes_rev3", "XREF_BOUND_LAYER_42", and so on. After running RebuildToStandard, the drawing has 9 clean layers: LG_CUT, LG_DIMS, LG_TEXT, LG_HATCH, LG_CONSTRUCTION, LG_CENTERLINE, LG_BEND, LG_BORDER, and LG_OTHER.
Every dimension entity is on LG_DIMS. Every text entity is on LG_TEXT. Every hatch is on LG_HATCH. The cut geometry—the lines, arcs, and polylines that form the part contour—is on LG_CUT. Anything that could not be classified with confidence is on LG_OTHER for manual review.
The entire process takes seconds. Not 30 minutes. Not an hour. Seconds.
You still want to do your visual verification afterward—freeze each layer and check—but instead of checking 47 layers, you are checking 9. And instead of sorting through hundreds of unclassified entities, you are reviewing a small number on the LG_OTHER layer that the tool was not confident about.
Combining Manual and Automated Cleanup
In practice, the best workflow combines both approaches. Here is what I recommend:
- AUDIT the file first (always, regardless of method)
- Check units and fix scale if needed (this requires human judgment)
- Bind XRefs if present
- Run LayerGuard RebuildToStandard to handle the layer normalization
- Run OVERKILL to clean up duplicate geometry
- Run PURGE to remove unused objects
- Visual verification—freeze each layer and check
This combined workflow takes 5 to 10 minutes per file instead of 30 to 60. The automated step handles the classification that takes humans the longest, and the manual steps handle the judgment calls that software cannot make (unit conversion, XRef decisions, verifying that the automated classification is correct for your specific drawing).
Setting Up a Receiving Workflow
If you regularly receive vendor drawings, it is worth formalizing this cleanup process into a standard workflow so it happens consistently.
Designate a Gatekeeper
Have one person (or a small team) responsible for incoming drawing cleanup. This person receives vendor files, runs them through the cleanup process, and releases them into the production workflow. This prevents messy files from reaching the programmers or the shop floor.
Create a Cleanup Checklist
Document the cleanup steps (like the ones above) and post them at the cleanup workstation. Even experienced people benefit from a checklist—it prevents missed steps when you are processing 20 files in a row and your attention starts to drift.
Keep Originals
Always keep the original vendor file untouched. Save it to an "ORIGINALS" folder before starting cleanup. Work on a copy. If something goes wrong during cleanup, or if you need to reference the original layer structure later, you have an unmodified copy to go back to.
Track Vendor Quality
Over time, you will notice that some vendors consistently send clean files and others consistently send garbage. Use this information. Vendors who send clean files earn less scrutiny. Vendors who send messy files might need a conversation about their drawing standards, or at minimum they get extra time built into the schedule for cleanup.
The Real Goal: Minutes, Not Hours
Vendor drawing cleanup is never going to be zero effort. There will always be some manual judgment needed—checking units, verifying classifications, handling edge cases. But the difference between 30 to 60 minutes per file and 5 to 10 minutes per file is enormous when you multiply it across the number of files that come through the door.
If you receive 10 vendor files a week, the manual approach costs 5 to 10 hours. A combined manual and automated approach costs 1 to 2 hours. That is 4 to 8 hours per week back in your schedule. Over a year, that is 200 to 400 hours—the equivalent of 5 to 10 full work weeks—spent on production instead of cleanup.
Vendor drawing cleanup should take seconds, not your entire morning. Get the checklist right, automate the parts that can be automated, and stop treating cleanup as an unavoidable cost of doing business. It is a solvable problem, and the solution pays for itself the first week you use it.