The Part That Broke Everything

Love Letter to Planning

David’s part looked perfect. Every fillet was smooth. Every chamfer was precise. The rendering was stunning enough for the cover of a trade magazine.

Then he tried to change the mounting hole diameter from 8mm to 10mm.

SolidWorks froze. Five minutes passed. Ten minutes. Finally, an error message: “Rebuild failed. Multiple features could not be regenerated.”

The part had 247 features. The error didn’t say which ones failed. David’s “perfect” part – three weeks of meticulous work – was essentially broken. One simple change had cascaded through his poorly planned feature tree like dominoes, each failure triggering the next.

The assembly using this part? 847 instances. All broken. The project deadline? Tomorrow.

That night, David learned what every veteran SolidWorks user knows but nobody tells beginners: Beautiful parts mean nothing if they can’t be changed. And parts that can’t be changed are worthless in engineering, where change is the only constant.

This is the story of how David learned to build intelligent parts instead of just pretty ones, and why planning matters more than CAD skills.

The Eight Questions Nobody Asks

Three months before David’s catastrophe, his manager had asked him to design a custom bracket for their new product line. David did what most engineers do: he opened SolidWorks and started modeling immediately.

What he didn’t do was ask eight critical questions that would have saved him three weeks of rework:

1. Where should the origin be?

David placed his origin at a random corner of the part because that’s where he started his first sketch. Seemed logical at the time.

Six weeks later, when assembling 50 of these brackets, the assembly team discovered they couldn’t use symmetry mates. Every bracket had to be precisely positioned and constrained. What should have taken 30 seconds per bracket took 5 minutes. Across 50 brackets, David’s random origin choice cost the project 3.75 hours.

The right answer? Place the origin on planes of symmetry. If the bracket is symmetric about its centerline, put the origin there. Now you can mate using coincident planes and the part automatically centers itself. One mate instead of three. Thirty seconds instead of five minutes.

2. Is there symmetry? How many planes?

David modeled his bracket completely from one end to the other. Left side features, then middle features, then right side features.

When manufacturing requested a mirror-image version for the opposite side of the assembly, David had to create an entirely new part. Two hours of modeling, essentially duplicating work.

The smarter approach? His manager showed him: model half the bracket, mirror it about the plane of symmetry. Need a left-hand version? Suppress the mirror feature. Need a right-hand version? Unsuppress it. Two configurations, one model, zero duplicate work.

Symmetry isn’t just about saving modeling time – it’s about preventing errors. When you model something twice, you’ll make it different twice. Mirrored geometry is mathematically identical.

3. Which elements need their own features?

David’s part had 247 features. His manager’s version of the same part? 43 features.

The difference wasn’t complexity – it was thinking. David created a separate fillet feature for every filleted edge. Twelve mounting bosses? Twelve separate extrude features. Six identical holes? Six separate hole wizards.

His manager combined: one fillet feature containing all fillets of the same radius, one extrude feature with a multi-contour sketch creating all twelve bosses simultaneously, one hole wizard with a pattern creating all six holes.

Why does this matter? Every feature creates a parent-child relationship. Every relationship is a potential failure point. 247 features created 1,843 parent-child relationships. When one failed, dozens more failed with it. That’s why changing a simple hole diameter brought David’s part to its knees.

4. Will any features need in-context relationships?

David created several holes by referencing edges from mating parts. These in-context relationships seemed convenient – the holes automatically updated when the mating parts changed.

Until they didn’t. When the assembly was opened without those reference parts, the in-context relationships went “out of context.” Errors everywhere. The assembly wouldn’t open without error warnings. The part couldn’t be used in different assemblies without bringing its parent assembly along for the ride.

The veteran approach? Minimize in-context relationships. Use them during initial design, then lock or break them before release. In-context is powerful during design but poison in production.

5. What configurations will I need?

David created one configuration: the full detail version with every fillet, chamfer, and engraving.

The problem? This part was used in a top-level assembly with 4,000+ parts. Every cosmetic fillet on David’s part created triangles that had to be rendered. His beautifully detailed part was one of 15 parts slowing the assembly to a crawl.

The solution? Configurations. Create a “Full Detail” configuration for manufacturing drawings and renderings. Create a “Simple” configuration for assembly use that suppresses cosmetic fillets, chamfers, and text engravings. The simplified version loads 5x faster and looks identical at assembly scale.

One company David later worked with had a standard: every part must have a “SIMPLE” configuration (exact capitalization – SolidWorks is case-sensitive). When opening assemblies, select “SIMPLE” for all components. The 4,000-part assembly that took 12 minutes to open? Now opened in 2 minutes.

6. Can patterns help?

David created 24 mounting holes one at a time. When manufacturing requested the hole spacing change from 25mm to 30mm, he updated 24 separate features.

The pattern approach: Create one hole, create one pattern. Change the pattern spacing once, all 24 holes update together. Bonus: patterns can drive assembly-level patterns. Add Smart Fasteners to the assembly, and SolidWorks automatically puts bolts in all 24 holes. No mates required.

But David learned patterns can also hurt performance. He created a pattern, then patterned the pattern, then added features that referenced the patterned pattern. Rebuild time: 45 seconds. After restructuring to a single comprehensive pattern: 3 seconds.

7. Which view will be the front when detailing?

David’s front view made perfect sense during modeling – it showed the mounting surface clearly. When the drafting team created manufacturing drawings, they discovered this “front” view was useless for dimensioning. They needed a completely different view as the primary. Now all the dimensions and annotations were on auxiliary views instead of the main view.

The time cost: What should have been a 2-hour drawing took 6 hours because dimensions and views were fighting the model orientation.

8. What properties are needed?

David’s part had no custom properties. When it showed up in the Bill of Materials, it appeared as “Bracket-final-version3-ACTUAL.sldprt” with no description, no material information, no part number.

The purchasing department sent him emails weekly: “What material is this?” “What’s the actual part number?” “Who designed this?” All information that should have been in custom properties from the start.

The template solution: David’s manager showed him part templates with pre-filled custom properties that automatically populated BOMs, title blocks, and data management systems. Fill them out once when creating the part, never answer those questions again.

The Feature Tree from Hell

Let me show you what David’s feature tree looked like after three weeks of “perfect” modeling:

• Sketch1
• Extrude1
• Fillet1
• Fillet2
• Fillet3
• Fillet4
• Fillet5
• Fillet6
• Fillet7
• Extrude2
• Sketch2
• Revolve1
• Fillet8
• Fillet9
• Hole Wizard1
• Fillet10
• Fillet11
• …
• (230 more features)
• …
• Fillet243
• Chamfer1
• Chamfer2
• Chamfer3
• Chamfer4

Fillets scattered throughout the tree. Chamfers at the end. Holes referencing sketches referencing edges that no longer existed. Parent-child relationships so tangled that the Rebuild Error message essentially said “good luck figuring this out.”

Here’s what his manager’s feature tree looked like:

• Sketch-BaseProfile (fully defined)
• Extrude-MainBody (from midplane, symmetric)
• Pattern-MountingBosses
• Hole Wizard-MountingHoles
• Pattern-HoleArray
• [Folder: Cosmetic Features]
  • Fillet-Edges_R3
  • Fillet-Edges_R5
  • Fillet-Edges_R1
  • Chamfer-AllExternalEdges
  • Text-PartNumber (suppressed in Simple config)

Clean. Organized. Every feature had a descriptive name. All fillets and chamfers grouped at the end in a folder. The folder could be suppressed for the simplified configuration with one click.

The rebuild time difference:

• David’s part: 8.3 seconds
• Manager’s part: 0.7 seconds

Same geometry. Same function. One was efficient. One was chaos.

The $12,000 Remodeling Decision

Six months after David’s initial disaster, he faced a choice that would define his career trajectory.

He’d inherited a part from a colleague who’d left the company. The part functioned correctly but was horrendously inefficient. The feature tree showed the history of someone learning SolidWorks while designing – false starts, abandoned approaches, features built on top of temporary geometry that should have been deleted.

Rebuild time: 23 seconds. The part was used in 15 different assemblies. Every time anyone opened an assembly, they waited. And waited.

David calculated: the assembly team opened these assemblies an average of 8 times per day. 23 seconds × 8 times × 5 days × 50 weeks × 3 engineers = 767 hours per year spent waiting for this one part to rebuild.

At $50/hour loaded cost, that’s $38,350 per year in lost productivity.

Remodeling the part from scratch would take David about 8 hours. Cost: $400.

The payback period: 3.8 days.

But David hesitated. The deadline was tight. Remodeling seemed risky – what if he introduced errors? What if he missed a critical dimension? The existing part worked, even if it was slow.

His manager made the decision for him: “Remodel it. The part you create in 8 hours will be better than the part someone created in 3 weeks while learning. You already know what the final form should be. You won’t waste time exploring dead ends. Just do it right this time.”

David remodeled it in 6 hours. The new rebuild time: 1.2 seconds.

The actual annual savings: $36,683.

Over the five-year production life of those assemblies: $183,415 in productivity saved. For 6 hours of work.

That calculation changed how David thought about “efficiency.” The question wasn’t “does it work?” but “does it work efficiently?” Because inefficient parts don’t just slow down your computer – they slow down every engineer who touches that assembly, forever.

The Magic of Symmetry

David’s next assignment was a heat sink – a complex array of fins dissipating heat from a processor.

His first instinct: model all 47 fins. He started on fin #1. Got to fin #12 and realized his approach wasn’t working. Changed strategy. Now fin #1 through #12 didn’t match fins #13 through #47.

His manager stopped him: “How many planes of symmetry does this have?”

David looked. The heat sink was symmetric about two planes. Four-way symmetry.

The efficient approach: Model 1/4 of the heat sink (about 12 fins). Mirror it once. Mirror the result perpendicular. Done. All 47 fins, created from modeling 12.

The benefits:

• 4x faster to model
• Changes to one fin automatically update all fins
• Perfect consistency – no variations between fins
• 3x faster rebuild (mirroring surfaces is faster than rebuilding geometry)

But the real magic came during assembly. When mating the heat sink to the processor:

David’s approach (no symmetry): Coincident mate to one face, coincident mate to second face, coincident mate to third face to fully constrain. Three mates, carefully selected to avoid over-constraining.

Symmetry approach: Coincident mate to one plane, coincident mate to second plane. Two mates. The part automatically centers itself. Impossible to make an error.

When the design changed and the processor mounting holes shifted 5mm, David’s original assemblies required updating three mates per heat sink. The symmetrical version? The parts automatically repositioned correctly. Zero updates required.

Symmetry isn’t just about modeling efficiency. It’s about designing intelligence into your parts so they behave predictably in assemblies.

The Template That Transformed Everything

David joined a new company and discovered something that changed his entire workflow: comprehensive part templates.

His old workflow:

1. Open SolidWorks → New Part
2. Spend 5 minutes setting units, dimension standards, materials library
3. Start modeling
4. Remember halfway through that he forgot to set image quality settings
5. Finish part
6. Before saving, manually enter custom properties: description, material, part number, designer name, date, revision
7. Repeat this process for every single part

His new company’s workflow:

1. Open SolidWorks → New Part → Select appropriate template (AluminumPart, SteelPart, PlasticPart, etc.)
2. Start modeling (everything already set correctly)
3. Finish part
4. Save (custom properties automatically populated from model properties)

The template pre-configured:

• Document properties (units, dimensions, tolerances)
• Material (appropriate to template type)
• Visual properties (appearance, background, shadows)
• Image quality settings (optimized for performance)
• Custom properties (company info pre-filled, designer name auto-populated from login)

Time saved per part: 5-10 minutes Parts created per year: ~150 Annual time savings: 12-25 hours Five-year career savings: 62-125 hours

That’s 1.5 to 3 full work weeks saved over five years, just from using proper templates.

But the real value wasn’t time – it was consistency. Every engineer’s parts looked the same. BOM export formats matched. Drawing title blocks auto-populated correctly. The CAM team knew exactly where to find information. New engineers got up to speed faster because everything followed predictable patterns.

The template rule: Five minutes creating a good template saves 500 minutes using it.

The Configuration That Prevented a Crisis

David’s company landed a massive contract: 5,000 assemblies for a multinational client. The main assembly contained 2,847 parts.

Week 1: Assembly opened in 14 minutes. Painful but manageable.

Week 4: Assembly opened in 31 minutes. People made coffee while waiting.

Week 8: Assembly crashed during opening. Out of memory errors. The project was in jeopardy.

The diagnosis: Every part was loading in full detail. Thousands of cosmetic fillets. Hundreds of threaded holes showing helical threads. Text engravings with TrueType fonts creating thousands of tiny surfaces. The graphics card was rendering millions of triangles for details invisible at assembly scale.

The solution: Simplified configurations.

David and his team spent one week creating simplified configurations for the 200 most complex parts:

• Suppressed all fillets under R2mm
• Suppressed all cosmetic chamfers
• Suppressed text engravings
• Changed cosmetic threads to simplified display
• Suppressed internal details not visible in assembly

Then they created an assembly configuration that opened all components in their “SIMPLE” configuration.

The result:

• Assembly open time: 3.5 minutes (down from 31+ minutes)
• Memory usage: 6.4 GB (down from 18+ GB causing crashes)
• Assembly rotate/pan responsiveness: instant (previously laggy)

The project was saved. Manufacturing used full-detail configurations for drawings. Assembly team used simplified configurations for design work. Everyone was productive again.

The lesson: Detail is beautiful until it becomes a burden. Know when to hide it.

The Fastener Philosophy

David once spent two full days adding bolts to an assembly. 847 bolts. Each required:

1. Find the hole
2. Insert Smart Fastener (or Toolbox component)
3. Select size and type
4. Add mates
5. Repeat 846 more times

His coworker showed him a different approach:

Step 1: Create one pattern of holes in the base part
Step 2: Insert Smart Fasteners → Select hole series → SolidWorks automatically adds fasteners to all holes in pattern
Result: 847 bolts added in 90 seconds

But there was a choice to make: Master parts or Copied parts?

Master parts method:

• Toolbox keeps master fastener files
• Each size is a configuration of the master
• Advantage: Fewer total files
• Disadvantage: Toolbox files stored on network, opening them is slow

Copied parts method:

• Each fastener is a unique file
• Advantage: Files can be stored locally, fast access
• Disadvantage: More files to manage

For their 5,000-assembly project, David’s team chose copied parts. Result: 43,000 fastener files, but they loaded from local SSD drives in milliseconds instead of network drives in seconds. The trade-off was worth it.

Thread display philosophy:

• Simplified: Just geometry showing thread limits (fastest)
• Cosmetic: Appearance applied to surface (looks good, still fast)
• Modeled: Actual helical geometry (looks perfect, completely destroys performance)

David learned: Never model threads unless the threads themselves are being machined or analyzed. Cosmetic threads for renderings, simplified threads for everything else.

One engineer on David’s team ignored this advice and modeled threads on 300 bolts. The assembly gained 4.7 GB of file size and 12 minutes of open time. Converting to cosmetic threads: file size dropped 4.2 GB, open time dropped 11 minutes. One setting change, massive impact.

The In-Context Trap

Let me tell you about David’s most expensive mistake.

He discovered in-context modeling and thought it was magic. Need a mounting bracket that perfectly matches the mating surface? Edit the assembly, insert new part, convert the mating surface geometry. Perfect fit, automatically updates if the surface changes.

He created 47 parts this way. They all fit perfectly. The assembly looked great.

Then manufacturing requested the assembly be split into two sub-assemblies for production efficiency. When David opened the first sub-assembly without the second, 23 parts went “out of context.” Error messages everywhere. Features failed because their reference geometry wasn’t loaded.

The problems compounded:

• Parts couldn’t be used in other assemblies (they needed their parent assembly loaded)
• Part origins were far from part geometry (projected from assembly origin)
• Assembly rebuild time tripled (solving in-context relationships at assembly level)
• Simple mates mysteriously changed part geometry (external reference propagation)

David learned the hard way: In-context modeling is powerful during design, dangerous during production.

The safe workflow his manager taught him:

1. During design: Use in-context modeling freely for rapid development
2. Before release: Lock all external references (freeze them, stop propagation)
3. Before final release: Break external references or Save As with “copy without references”

Locking external references keeps the geometry but stops updates. The feature tree shows “->*” symbols for locked references. Changes to parent parts won’t propagate. Perfect for parts that need to stay as-is.

Breaking external references is permanent. The feature tree shows “->x” symbols. The geometry stays but the link is severed forever. Use this for parts being released to manufacturing.

The even better approach: Avoid in-context modeling for any part that will be reused. Use in-context only for truly unique, one-time-use parts specific to one assembly.

David rebuilt those 47 parts without in-context references. It took three days. But the assemblies became stable, parts could be reused, rebuild times dropped 70%, and engineering stopped getting emergency calls about “out of context” errors.

The Pattern Paradox

David discovered that patterns could either save him or destroy him.

Good pattern (example 1):

• Created mounting boss geometry
• Created single bolt hole
• Patterned the hole 6 times
• Result: Clean feature tree, fast rebuild, easy to change

Bad pattern (example 1):

• Created mounting boss geometry
• Created 3 bolt holes, patterned 2x
• Created different bolt holes, patterned on top of first pattern
• Result: Nested patterns, slow rebuild, pattern-of-pattern dependencies

When manufacturing requested hole spacing changes, the good pattern updated in 0.3 seconds. The nested pattern took 4.7 seconds and sometimes failed with circular reference errors.

The pattern rule: One comprehensive pattern beats multiple nested patterns.

Pattern positioning strategy:

• Place large patterns at the bottom of feature tree
• Allows suppressing them without breaking child features
• Other features build first, pattern adds finishing touches
• Much faster when working on other aspects of the part

Assembly-level benefits:

• Feature patterns can drive assembly patterns (feature-driven component pattern)
• Smart Fasteners use patterns to automatically add hardware
• Changes to part pattern automatically update assembly pattern

David’s heat sink project used this brilliantly: One pattern of fins in the part became one pattern of heat sinks in the assembly. Change the pattern count from 47 to 63 fins? Assembly-level patterns automatically added 16 more heat sinks in the array. Zero assembly mates required.

The Performance Evaluation Revelation

David’s parts were getting slow. Some took 15-20 seconds to rebuild. He didn’t know which features were the culprits.

His manager showed him: Tools → Evaluate → Performance Evaluation (formerly Feature Statistics)

A window opened showing every feature ranked by rebuild time:

1. Loft-ComplexShape: 4.2 seconds
2. Pattern-FinArray: 3.7 seconds
3. Fillet-TinyEdges: 2.8 seconds
4. Sweep-ThreadDetail: 2.1 seconds
5. Text-Logo: 1.4 seconds …

The revelation: Five features consumed 14.2 of the part’s 18.7-second rebuild time. The other 38 features only took 4.5 seconds combined.

David’s optimization strategy:

For the loft: Could he achieve the same shape with an extrude or revolve? (Lofts are computationally expensive). In this case, yes – converted to swept boss, rebuild dropped from 4.2 to 1.1 seconds.

For the pattern: Moved it to bottom of feature tree, suppressed it in simplified configuration. Working configuration rebuild time dropped by 3.7 seconds.

For the fillet: Combined dozens of tiny fillets into one feature. Rebuild dropped from 2.8 to 0.4 seconds. (Fewer features = less overhead)

For the sweep: The helical thread detail nobody saw at assembly level. Suppressed in simplified configuration. Saved 2.1 seconds.

For the text: TrueType font creating 847 tiny entities. Replaced with decal in simplified configuration. Saved 1.4 seconds.

Result: Part rebuild dropped from 18.7 seconds to 6.3 seconds. Assembly containing 200 instances: opened 41 minutes faster.

The Feature Freeze trick: Set Feature Freeze bar at bottom of tree. Nothing rebuilds. Change configurations instantly. Useful when you need to check different configurations rapidly without waiting for rebuilds.

The Import Nightmare

David’s company received a STEP file from a vendor. He imported it, added mounting holes, created a drawing, released it to manufacturing.

Three weeks later, manufacturing called: “This part won’t machine correctly. There are gaps in the surface geometry.”

David checked the feature tree. 127 features after his import. His added features looked fine.

The problem? The imported geometry had surface gaps from the vendor’s CAD system. David had built on top of a broken foundation.

The tools he should have used immediately after import:

1. Import Diagnostics (Tools → Evaluate → Import Diagnostics)

• Scans imported geometry for errors
• Identifies bad surfaces, gaps, short edges
• Only works on unmodified imported body
• Should be run BEFORE adding any features

2. Check (Tools → Evaluate → Check or Evaluate toolbar)

• Finds geometry errors at any time
• Locates short edges (often cause downstream failures)
• Identifies invalid faces
• Can be run anytime, even after adding features

David learned: Fix import errors before building on imported geometry. Building on broken geometry is like building a house on quicksand. Everything you add is unstable.

The vendor file had 23 surface gaps. Import Diagnostics found them all. David sent it back to the vendor: “Fix these before we can use it.” Vendor reissued clean geometry. David’s added features worked perfectly.

The cost of not checking: Three weeks of manufacturing delays, emergency meeting with client, rushed air freight of replacement parts, damaged reputation. All preventable with five minutes of diagnostics.

The Error Philosophy

David’s old approach to errors: “I’ll fix them later.”

Rebuild error in feature 12? Keep building. Now at feature 45 with errors in features 12, 18, 27, 31, and 42. Time to fix them.

Problem: Which error happened first? What caused the cascade? Each error might be caused by the previous error. Fixing them is like untangling Christmas lights in the dark.

His manager’s philosophy: “Fix errors immediately. Not when convenient. Immediately.”

Rebuild error appears? Stop. Fix it now. Before adding one more feature.

Why?

• You know exactly what you just did that caused the error
• The solution is obvious because you just made the change
• No cascade of dependent errors to untangle
• 2 minutes to fix now vs. 2 hours to fix later

David learned this the hard way several times. One memorably painful example: Continued building despite an error in feature 31. By feature 87, he had 14 errors. Spent six hours untangling them. Later calculated that stopping to fix each error immediately would have taken about 20 minutes total.

The ratio: 20 minutes of immediate fixes prevented six hours of debugging. That’s an 18:1 return on time investment.

The foundation principle: Every feature you build depends on features before it. If early features have errors, everything built on them is suspect. It’s like building floors 2-10 of a building while floor 1 has structural cracks. The entire building is compromised.

The Level of Detail Wisdom

David purchased detailed vendor models for pneumatic cylinders, servo motors, and linear actuators. Beautiful models. Every bolt hole, every text engraving, every chamfer perfectly modeled.

He inserted 47 pneumatic cylinders into his assembly. Open time jumped from 8 minutes to 23 minutes.

The problem? Each vendor model was designed for marketing renders, not assembly use. Each cylinder had:

• Modeled threads on every adjustment screw (helical geometry = massive file size)
• Company logo (TrueType text = thousands of tiny surfaces)
• Every internal component (invisible in assembly, still calculated)
• R0.5mm fillets on every edge (invisible at assembly scale)

David learned to simplify purchased components before use:

Unnecessary detail to remove:

• Threads (use simplified or cosmetic, never modeled)
• Text engravings (use decals, not geometry)
• Tiny fillets invisible at assembly scale
• Internal components not visible externally
• Complex surface geometry that could be simplified

For a cylinder:

• Replace detailed end cap with simple cylinder
• Remove internal piston details
• Simplify rod threads to cylinder
• Remove all R<1mm fillets
• Remove text engravings

Result: 7.2 MB vendor file reduced to 0.8 MB simplified file. Rebuild time: 3.4 seconds reduced to 0.4 seconds. Multiply by 47 cylinders: Assembly opened 2.4 minutes faster.

The spring case: Vendor provided model with helical coil geometry. File: 14.3 MB. David replaced with simple cylinder representing spring envelope. File: 0.1 MB. Looked identical in assembly. Mated the same. Interference detection still worked. Performance: 100x faster.

The bolt case: Don’t model threads. Ever. Unless you’re manufacturing the threads themselves. Use cosmetic threads for renderings (texture map, looks real, minimal performance impact). Use simplified for everything else.

The Origin Strategy That Changed Assembly

David’s company assembled industrial equipment with hundreds of bolt-on components. Every component required three mates to fully constrain.

One engineer – Jessica – placed all her part origins on planes of symmetry and at natural mating surfaces.

Her typical part:

• Origin at geometric center
• Front plane at primary mating surface
• Top plane at another mating surface

Assembly process:

• Mate component Front plane to assembly face: coincident
• Mate component Top plane to assembly face: coincident
• Done. Part fully constrained, automatically centered.

David’s typical part:

• Origin at random sketch starting point
• No relationship to assembly reference
• No planes at mating surfaces

Assembly process:

• Mate face to face: coincident
• Mate edge to edge: coincident
• Mate second face to face: coincident
• Add distance mate to position correctly
• Oops, over-constrained, delete one mate, try again
• Finally constrained after three attempts

Time difference: Jessica’s parts: 30 seconds to mate. David’s parts: 3-5 minutes to mate.

Across 200 components in an assembly: 1 hour (Jessica’s method) vs. 10+ hours (David’s method).

David rebuilt all his standard parts with origins on symmetry planes. The time investment: one week. The payback: every assembly using those parts became 90% faster to build.

The Configuration Philosophy

David’s final lesson came from observing his company’s most experienced engineer – Michael – who’d been using SolidWorks for 15 years.

Michael created multiple configurations for almost every part:

1. Master (Full Detail)

• Every feature, every detail
• Used for manufacturing drawings
• Used for photorealistic rendering
• Highest quality, slowest performance

2. SIMPLE (company standard name)

• Suppressed cosmetic features (small fillets, chamfers, text)
• Simplified threads
• Essential geometry only
• Used in assembly work

3. Drawing

• Suppressed tangent-edge-creating fillets
• Made drawing views cleaner
• Reduced drawing clutter

4. Analysis (when needed)

• Suppressed features irrelevant to FEA
• Sometimes added features for mesh control
• Optimized for simulation, not manufacturing

5. SpeedPak (for sub-assemblies)

• External faces only
• Massive assembly performance improvement
• Advanced users only

David asked: “Doesn’t managing all these configurations take more time?”

Michael: “Creating configurations takes 10 minutes. Using them saves 10 hours per assembly. And we use parts in dozens of assemblies. The return is enormous.”

The company standardized on the “SIMPLE” configuration name. When opening any assembly, select Advanced options, choose “SIMPLE” for all components. Every engineer’s parts had this configuration. Result: standardized workflow, predictable performance, massive time savings.

The Morning After

Remember David’s catastrophic part rebuild failure? The one that took down 847 assembly instances the day before the deadline?

After learning everything in this article, David rebuilt that part from scratch. Started with a plan:

1. Origin on planes of symmetry ✓
2. Features combined intelligently ✓
3. Single pattern instead of multiple ✓
4. All fillets grouped at end ✓
5. Simplified configuration created ✓
6. Custom properties filled out ✓
7. No in-context references ✓
8. Features named descriptively ✓

Original part: 247 features, 8.3-second rebuild, broke with minor changes
New part: 41 features, 0.9-second rebuild, robust to any reasonable change

He made the requested change: 8mm holes to 10mm holes. Rebuild time: 0.9 seconds. No errors.

Changed five other dimensions to test robustness. All worked perfectly.

His manager reviewed it: “This is what intelligent modeling looks like. Not just modeling what you need today, but anticipating how it needs to change tomorrow.”

The Wisdom David Carries Forward

Five years later, David mentors new engineers. He tells them what nobody told him:

“Beautiful parts are worthless if they can’t be changed. Robust parts might look simple in the feature tree, but they embody deep thinking about design intent, symmetry, patterns, and assembly requirements.”

“The difference between a junior modeler and a senior engineer isn’t CAD skill – it’s planning. Anyone can make a part in SolidWorks. An engineer makes a part that can evolve with the design, perform efficiently in assemblies, and survive the chaos of real product development.”

“Every part you create is a message to your future self and your colleagues. That message can be ‘good luck figuring this out’ or ‘I’ve made this easy for you.’ Choose wisely.”

The checklist David gives every new engineer:

• [ ] I know where the origin should be and why
• [ ] I’ve identified all planes of symmetry
• [ ] I’ve planned which features should be combined
• [ ] I’ve created a simplified configuration
• [ ] All fillets/chamfers are grouped at the end
• [ ] Patterns are comprehensive, not nested
• [ ] Custom properties are filled out
• [ ] The part has a descriptive name
• [ ] I’ve verified it rebuilds quickly
• [ ] I’ve tested making typical design changes
• [ ] Import errors are fixed (if applicable)
• [ ] In-context references are locked or removed (if applicable)

If you can check every box, you’ve created an intelligent part. If not, you’ve created technical debt that someone will pay for later – probably you.

What’s your part modeling disaster story? Have you discovered techniques that transformed your workflow? Share in the comments – we all learn from each other’s hard-won wisdom.

This article is part of our Engineering Design Excellence series, where we transform CAD operations into engineering intelligence.