A top-down, multi-body design approach for complex parametric systems. One source of truth. Automatic change propagation. No broken mates. This is how you design hundreds of interdependent parts without losing your mind.
Most CAD environments are built bottom-up. Each part modeled in isolation, then assembled and mated together. At low complexity, this works. At the complexity of a real product — hundreds of interdependent panels, brackets, and systems, all constrained by a geometry that changes — it becomes a maintenance nightmare. Change one dimension and spend the rest of the day chasing broken mates across dozens of files.
The Master Modeling Technique solves this by inverting the workflow. Everything is designed top-down, relative to everything else, inside a single master part file. The enclosure, the internal components, the structural mounts — all defined in context of each other. When something changes, every downstream feature that references it updates automatically.
This is not a workaround. It is the correct tool for any product where parts don't exist in isolation — where the shape of one surface drives the shape of the next, and where engineering changes are a certainty rather than an exception. This is especially true if you do any amount of surface modeling. Surfaces are incredibly powerful design tools — for defining complex shapes, building trim boundaries, controlling split lines, and driving downstream solid geometry — and they thrive inside master files where they can reference each other directly. The MMT workflow treats surfaces as first-class citizens, not afterthoughts. (Surface modeling itself is a deep topic that deserves its own dedicated treatment — stay tuned.)
Design everything relative to everything else. Push geometry downstream when ready to manufacture. Never rename active files. Revision control happens at export, not in the filename of editable CAD.
The distinction is fundamental. In a bottom-up workflow, each part is modeled independently, then assembled and constrained with mates. In the Master Modeling Technique, all bodies are defined relative to each other within a single part file. The difference in how these two approaches respond to change is where MMT earns its keep.
Each part modeled independently in its own file. Assembled and mated after the fact. When something changes, every affected downstream part must be manually updated. Mates break. Engineers chase failures for hours.
Good for: simple, low-part-count assemblies with minimal interdependency — hardware kits, fixtures, basic weldments.
All bodies defined relative to each other within a single master part file. When something changes, change one driving feature and every body, sketch, and exported child that references it rebuilds automatically.
Built for: complex systems with many interdependent parts — exactly the kind of products where design engineering actually matters.
Here's one of the most powerful and underappreciated benefits of this technique: if you start every master file by inserting the parent reference geometry first — whether that's another master or an exported subset — and then design everything around it, every file in your system shares the same coordinate origin. Your frame master, your enclosure master, your mounting master — all built on the same zero point.
The payoff comes when you build your top-level assembly. Drop in every master and they automatically locate exactly where they should be. No mates to define, no constraints to chase. Origin to origin. Done. The assembly just works.
This is an absolute game changer when you're working on deeply interdependent systems where every subsystem's geometry is driven by its neighbors. Mounting points reference the frame. Panels reference the enclosure. Brackets bridge the gap between them. In a bottom-up world, you'd spend hours constraining all of that in the assembly. In MMT, the spatial relationships are baked in from the start because everything was designed relative to the same coordinate system. The assembly is just a viewer — a way to see everything together — not a puzzle you have to solve.
Make "Insert Part → reference geometry" the very first feature in every new master file. Before you sketch anything, before you extrude anything — pull in the context you're designing against. This one habit is what makes the entire system self-locating downstream.
Every file in an MMT system has a specific role, identified by a suffix. These suffixes are permanent — they are part of the filename and are never changed or removed. Understanding these four roles is understanding the entire system.
These suffixes are a convention, not a SolidWorks feature. -MASTER, -MASSEM, -EXP, -SPLIT — pick whatever makes sense for your team as long as it's consistent and instantly identifiable in a list of files. The specific labels matter less than the discipline of using them. What matters is that anyone can glance at a filename and immediately know that file's role in the system.
-MASTER · Part file (.sldprt)
The top-level multi-body part file. All design intent lives here. Contains hundreds of bodies defined relative to each other. This is the only file you edit for design changes. Everything else is downstream.
-MASSEM · Assembly file (.sldasm)
An assembly composed of -MASTER files, -MASSEM sub-assemblies, and purchased components. Represents the full product or a major system. Geometry can originate here — you can create new in-context parts inside a -MASSEM — but it's not standard practice. Large assemblies with embedded part geometry get slow to open. Use it sparingly and intentionally: fixture design, one-off jigs, or bridging hardware that doesn't belong in any single master.
-EXP · Part file (.sldprt)
A lean part file containing specific bodies pulled from a master via Insert into New Part. Used to pass selected reference geometry to downstream models without exposing the entire master file. Think of it as a curated API surface for your CAD geometry.
To create one: right-click a face on any body you want to export. In the upper-left of the viewport where the feature breadcrumb appears, right-click the body listing and select Insert into New Part. Once the dialog opens, you can select whichever additional bodies you need — solid or surface — before confirming.
-SPLIT · Assembly file (.sldasm)
Auto-generated assembly produced by Save Bodies. Contains all pushed solid bodies in their correct spatial positions. Used to navigate and open individual manufactured parts. This is your BOM generator and your drawing source.
Consistent naming is what makes a project navigable at scale. The specific format matters less than the discipline behind it. The goal: every filename tells you what the file is, where it belongs, and what role it plays — at a glance, without opening it.
A good naming convention typically includes a few key segments: something to identify the project or platform, something to identify the system or category, a component descriptor, the MMT role suffix, and — for static exports only — a revision. Here's one way to structure it:
The project identifier can be a number, a code, an abbreviation — whatever your organization uses. The system or category code should match your folder structure so navigating from filename to file location is trivial. The component descriptor describes the specific part or group in plain language.
The format itself is flexible — what isn't flexible is consistency. Pick a convention, document it, and enforce it. A naming scheme only works if every file follows it. The moment someone starts freelancing filenames, the whole system starts to erode. The best convention is the one your team will actually use every time.
Establish clear rules for separators. One approach: underscores ( _ ) separate naming segments, hyphens ( - ) are reserved for role suffixes and compound words within a descriptor. The specifics don't matter as much as having a rule and sticking to it.
Example using one possible convention: 02_FR_Design-MASTER.sldprt for a frame system master model. 02_EN_HousingAssembly-MASTER.sldprt for an enclosure housing master. 02_FR_BracketPlate_RevA.step for a production-release STEP export.
Geometry flows from master files to children through four SolidWorks tools, split into two categories: Push (the parent initiates the transfer) and Pull (the child initiates). Choosing the right tool determines link behavior, file portability, and what breaks if something gets renamed.
Split divides a multi-body model into distinct bodies without necessarily creating child part files. Use it mid-design for organization. Save Bodies generates individual manufactured part files from solid bodies in a master — this is the production push step. Before running Save Bodies, name every body in the Solid Bodies folder of the feature tree, then use Auto Assign Names. Each part file inherits the body name. This is how your part-number-driven filenames are generated.
Do not run Save Bodies on a cluttered master. If your master contains dozens of bodies — construction geometry, intermediate shapes, suppressed leftovers — Save Bodies will generate a file for every single one of them. That's a flood of unwanted part files and a mess to clean up. Always use Insert into New Part first to isolate only the bodies you actually need to manufacture into a clean -EXP file. Name them there, then run Save Bodies from the -EXP. You can edit the Save Bodies feature after the fact to fix mistakes if you're careful, but it's far easier to be strategic upfront than to untangle a pile of ghost files after.
If things downstream of Save Bodies are truly buggered and editing the feature isn't cutting it — delete all the generated part files, then delete the Save Bodies feature itself. Fix whatever needs fixing in the source file (add a body, split something up, rename), then run Save Bodies fresh. It's the nuclear option, but sometimes a clean re-push is faster than trying to surgically repair a broken chain.
Insert into New Part exports selected bodies into a new -EXP file. Use this when you need to pass a clean subset of master geometry to another modeler or system without handing them the entire multi-hundred-megabyte master. Insert, Part lets a child reach out and pull bodies, surfaces, sketches, planes, axes, or coordinate systems from any other part file — the parent has no record of this.
The real power of this pairing: use Insert into New Part to isolate just the reference geometry you need — specific solid bodies, key surfaces, whatever's relevant — into a lightweight -EXP. Then start a new part and use Insert, Part to pull that -EXP in as reference. Now you've got a super-lightweight model that's still being fed live geometry from the master, without dragging in a 300 MB file every time you open it. This is often far easier to work with than inserting an entire master as reference, especially when multiple engineers are pulling from the same source.
This matters because master files get incredibly complex. A mature master might contain hundreds of solid and surface bodies, hundreds more reference planes, and thousands of features. Many of those surfaces exist only to serve a single operation — a Split, a Cut with Surface, a Knit — and have no downstream value whatsoever. The Insert into New Part → name → Save Bodies workflow, and the Insert, Part workflow for starting new designs from dynamic reference geometry, are what make this sustainable. You stop caring how complex the master gets. It's only ever as complex as it needs to be to get the job done. I've personally run multiple layers of master files with thousands of features each, all feeding each other through this approach, and the system stayed stable — because no downstream file ever sees that complexity directly.
| Operation | Type | Invoked From | Parent Aware? | Breaks if Parent Renamed? | Breaks if Child Renamed? |
|---|---|---|---|---|---|
Split |
Push | Parent | Yes | No ✓ | Yes ⚠ |
Save Bodies |
Push | Parent | Yes | No ✓ | Yes ⚠ |
Insert into New Part |
Pull | Parent | No | Yes ⚠ | No ✓ |
Insert, Part |
Pull | Child | No | Yes ⚠ | No ✓ |
The canonical path from design intent to a sendable file for fabrication. Every project follows this sequence — the only variable is whether you need the optional -EXP step.
CurrentRev/. The revision suffix is applied here and only here. Need to order a part? Go to CurrentRev, grab the zip, send it.That pipeline looks clean, but the real power is in the details of each transition. A -MASTER file might contain hundreds of bodies — every panel, bracket, reinforcement, and spacer for an entire system. But not all of those bodies are unique manufactured parts. You might have four identical pivot plates in the master, but only one part number. The -EXP step is where you distill the master down to only the unique, manufacturable geometry.
Step 1 — Isolate unique bodies. From the -MASTER, use Insert into New Part to push only the bodies you actually need to manufacture into a -EXP file. One instance of each unique part — not every duplicate. If you need four pivot plates in the final product but they're all the same part number, you export one.
Step 2 — Name and push. In the -EXP file, open the Solid Bodies folder and rename each body to its part number. Take your time — these names become permanent filenames and drawing callouts. Run Save Bodies with Auto Assign Names. Each body name propagates directly to the part filename. You now have individual .sldprt files named with real part numbers, plus a -SPLIT assembly with everything in its correct spatial position.
Step 3 — Build the drawing-ready assembly. Start a new assembly and insert the generated part files. Need multiples? Hold Ctrl and drag the part from the feature tree — instant duplicate, already the correct component with the correct filename. Populate the assembly with every instance: four pivot plates, six brackets, whatever the BOM calls for.
Now organize with sub-assemblies. Say you have a set of parts that gets used several times across the assembly — a hinge pack, a latch group, a mounting cluster. Mate everything for one instance until the positioning is right. Then select those parts and create a sub-assembly. The sub-assembly stays in context of the parent assembly — no additional files are generated. Now Ctrl+drag that sub-assembly to create as many instances as you need. Define a couple of mates to position each instance and the sub-assembly moves as a unit, with all its internal mates intact.
You can create as many of these in-context sub-assemblies as needed for different groupings, and you can layer them — sub-assemblies of sub-assemblies — if complexity demands it (though in practice two levels deep is usually the most you'll need). If a sub-assembly is a legitimate standalone product with its own part number, open it and Save As to create a separate file. Otherwise, leave it in context.
This is enormously helpful for drawings. Right-click any sub-assembly and Hide Component to collapse an entire group out of the view — critical when you're working with large assemblies that have many instances of the same hardware.
Step 4 — Add hardware and complete. This assembly becomes your -MASSEM — or at least the drawing source. Insert purchased hardware, fasteners, anything that isn't generated from the master. Every component now has a real identity in the feature tree.
Step 5 — Drawings that populate themselves. Create a drawing from this assembly. Insert Auto Balloon — SolidWorks reads each component filename and uses it as the balloon label. Every callout is already a real part number. Insert a BOM table and it populates from the same source. Create exploded views and every part is named, every quantity is counted, every callout is correct. No manual entry. No transcription errors. The drawing is as trustworthy as the model.
Export the assembly as a STEP file before sending to a vendor. In any CAD viewer — eDrawings, Fusion 360, FreeCAD — each body appears as a named component using the part number. Shop techs can hover over any piece and immediately read its identity without opening native CAD. Spatial relationships are preserved exactly.
You don't always need to run the full pipeline to get a rev-controlled export out. Two shortcuts worth knowing:
From the -SPLIT assembly: open the assembly, right-click any part in the tree, and open it. You now have the individual part file — save your rev-controlled STEP, DXF, or whatever format you need directly from there.
From the -EXP (without Save Bodies): click a body in the viewport, then select the full body from the feature breadcrumb in the upper-left. Go to File → Save As and choose the Selected Bodies option. This lets you save a rev-controlled export of individual bodies without ever going through the Save Bodies process — handy when you just need one part out the door fast.
You don't always need to push bodies into separate files to make a drawing. If you have a -MASTER full of sheet metal parts (or any multi-body part), you can start a drawing and insert the master directly. Before you confirm the view placement, click the small blue arrow in the top-right corner of the view preview — this opens a body selection dialog that lets you pick exactly which body or bodies to show on the print. One master file, as many drawing views of individual bodies as you need.
This is especially useful for sheet metal because it preserves the flat pattern option. If you instead use Insert into New Part to extract a sheet metal body, the child file receives it as imported geometry — the sheet metal feature is lost, and so is the flat pattern. You can always convert it back to sheet metal, but it's an extra step. Drawing directly from the master with body selection skips the problem entirely.
You've now seen how geometry flows downstream from master to manufactured part. Here's the trick for navigating that chain in reverse. When you're deep in a downstream file — say an individual part that was generated by Save Bodies — and you need to get back to the geometry's source, you don't have to go hunting through folders. Right-click anywhere on the part and select Edit in Context. SolidWorks opens the parent file that generated it. Need to go further upstream? Right-click again, Edit in Context again. You can swim all the way up the chain — from a manufactured part to the -EXP, from the -EXP to the -MASTER — without ever leaving the screen to manually navigate the file tree.
This is incredibly handy in practice. You spot something on a part drawing that needs to change, and within two right-clicks you're in the master file where the design intent actually lives. Make the change there, rebuild, and it flows back down through the entire chain. No guessing which file owns the geometry. No opening the wrong thing. Just follow the links upstream.
Filenames must remain constant for the life of the model. SolidWorks resolves all master and export references by filename and path. Renaming any active file breaks every downstream reference. If a rename is truly unavoidable, use SolidWorks Explorer — never Windows Explorer — to propagate the change.
Everything above happens inside part files — and that's where the vast majority of your design work should live. But there's a complementary approach for the cases where a part must be defined relative to components across separate master files: create the part inside an assembly.
Use Insert Component → New Part. Select a face on an existing component to initiate a sketch on that face. This is ideal when you can see the planar face you want to start from. If not, just select any planar face and click Exit Sketch — you now have a new in-context part started and should see it in the assembly tree. From there you can define sketch planes and features wherever you actually need them, using the assembly as your referencing geometry. Edit, add, and remove features using Edit Part — everything you build references the assembly context and updates when the assembly changes.
Use this for brackets that must conform to multiple existing parts simultaneously, or hardware that bridges two systems defined in separate -MASTER files. The in-context part stays embedded in the assembly — no new files are generated in your folder. If you need a standalone file you can locate in File Explorer, open the in-context part and Save As to create a physical copy.
The key insight: once you're in Edit Part mode inside an assembly, you have access to every tool you'd have in a standalone part file — sketches, extrudes, cuts, fillets, patterns, surface lofts, boundary surfaces, trims, knits, thickens — everything. The assembly isn't limiting you to mates and positioning; you're doing real part modeling with the full context of every surrounding component visible and referenceable. This is a game changer when you first discover it, because it means you can design geometry that conforms to multiple neighboring parts in a single session without ever leaving the assembly.
This applies everywhere upstream geometry is referenced — whether in an assembly context or a part file that pulls geometry from another part. Any feature that depends on an external parent will show one of two indicators:
→x means the feature is out-of-context — its parent file is not open. → means in-context — the parent is open and the child has rebuilt against it. Seeing →x is not an error. It is expected whenever you open a child without its parent.
To resolve it: open the parent -MASTER and rebuild. Or right-click the out-of-context feature and select Edit in Context — SolidWorks will open the parent file for you. With the parent open, the out-of-context indicator should flip to in-context → and the feature rebuilds against the current state of the parent.
Parent files must be open to push changes. A child opened without its -MASTER parent will not receive any changes made to the parent since the last session. Always open the -MASTER first, then open children, then rebuild all.
The system uses a split revision scheme. Editable "live" files never carry a revision suffix because CAD needs stable filenames to maintain references. Revisions are applied only when exporting static files for fabrication or vendor distribution.
.sldprt, .sldasm, .f3d, .xlsx
Never a revision suffix. The CAD resolves parent–child links by filename. A rev suffix on a live file means every downstream reference must be manually re-pointed every time a rev is cut.
.pdf, .step, .dxf, .x_t
Always a revision suffix. These are snapshots, packaged as a zip in CurrentRev/. The rev documents exactly what was sent, to whom, and at what design state.
Rev0, Rev1, Rev2… — Prototype stage. Early design iterations, first articles, proof-of-concept hardware. Expect frequent changes. RevA, RevB, RevC… — Production stage. Released for manufacturing on production units. Stable enough to cut parts from. RevA1, RevA2… — Minor production updates between full rev cycles. Field fixes, approved supplier substitutions, incremental improvements.
Before releasing a new revision, move the current manufacturing package from CurrentRev/ into Archive/. Then place the new rev's zip package — containing the PDF drawing plus all DXFs, STEPs, or Parasolid files — into CurrentRev/. The working CAD files keep their original names with no suffix. Never delete old packages — the archive is the paper trail.
These are the rules that, if broken, will cost you hours of repair work. They exist because every one of them was learned the hard way.
Never rename an editable file that has downstream references. The only safe time is before any children have been created, or after using SolidWorks Explorer to propagate the change to all known references.
Never open or edit an -archive file. It exists solely as a frozen snapshot. Treat it as read-only. If you need to reference old geometry, open the archive to look — then close it and work in the live file.
Never put a revision suffix on an editable file. Revision control belongs on static exports only. This is the single most common mistake and the single most expensive one to fix.
Open the -MASTER before opening its children. Otherwise children open out-of-context and may not reflect recent changes. The parent must be in memory for the child to rebuild against it.
Name every body before running Save Bodies. These names become part filenames and the -SPLIT assembly's component list. Unnamed bodies produce filenames like Body1.sldprt — useless for navigation.
Document dependencies. A comment in the feature tree description ("references XX_Design-MASTER") saves the next engineer from a scavenger hunt. Avoid circular references — Child A should not reference Child B if Child B already references Child A.
Export checklist: Open the parent master and confirm it is fully rebuilt. Verify geometry via section views and mass properties. Set units explicitly before STEP export. Apply the correct revision suffix. Package the PDF drawing with all manufacturing models into a zip. Move the outgoing rev package to Archive before placing the new one in CurrentRev.
A consistent folder structure is what keeps a complex project navigable. Every component system lives in its own folder containing the working CAD files, with a CurrentRev/ subfolder holding the latest manufacturing release packages and an Archive/ subfolder for superseded revisions.
Working CAD files — masters, assemblies, split assemblies, drawings, and all generated part files — live in the main component folder. This is where you design. CurrentRev/ holds manufacturing assets only: a zip package containing the PDF drawing and all DXFs, STEPs, or Parasolid models needed to build from. When you need to order a part, go to CurrentRev/, grab the zip, and send it. That's it.
Superseded rev packages move to Archive/ when a new revision is released. Never delete old packages — the archive is the paper trail. The working CAD files in the component folder keep their original names with no suffix, always representing the current state.
Do not create ad hoc subfolders for specific people, dates, or states. No "for review" folders, no date-stamped folders, no "v2 final FINAL" folders. Use the archive and the revision scheme. That's what they're for.
| Suffix | File Type | Role |
|---|---|---|
-MASTER | .sldprt | Multi-body design source. All design work happens here. |
-MASSEM | .sldasm | Assembly of master files and purchased components. |
-EXP | .sldprt | Lean geometry export for downstream reference. |
-SPLIT | .sldasm | Auto-assembly of manufactured bodies from Save Bodies. |
-archive | Any | Frozen historical snapshot. Never edit. |
| Format | Stage | Meaning |
|---|---|---|
| No suffix | Live | Editable CAD. Always the current version. |
_Rev0, _Rev1… | Prototype | Early iteration export. |
_RevA, _RevB… | Production | Released for manufacturing. |
_RevA1, _RevA2… | Minor update | Field fix or incremental production change. |
| Tool | Use When… |
|---|---|
Split | Dividing bodies within the master. No child files generated yet. |
Save Bodies | Generating individual manufactured part files (and optionally the -SPLIT assembly). |
Insert into New Part | Exporting a subset of master geometry into a -EXP file for downstream reference. |
Insert, Part | Having a child pull geometry directly from any existing part. |
This article is the playbook — but implementing it on your own product geometry is where it clicks. INTERPETR offers hands-on MMT training for engineering teams, either in person or virtual. We'll work through your actual CAD, on your actual projects, and build the system together.
Walk your team through the full MMT workflow on real project geometry. Half-day or full-day sessions, in person or virtual. Everyone leaves with a working system they understand — not a slide deck they'll forget.
Need an engineer who already thinks this way? From napkin sketch to manufacturing release — product design, CAD architecture, and DFM review. The same methodology, applied to your product.