05 — Industrial & Product Design
Devices, machinery, plants
I design what I build — from a single device to a full industrial plant.
Industrial and product design across three scales, modeled in SolidWorks and Fusion 360 for engineering and Blender and Maya for form, with every model carried through CAD to CAM to fabrication.
Design, for me, is not a separate department — it is inseparable from the advanced-technology work. I draw what I intend to fabricate.
I am an industrial and product designer. The work spans three scales in one workflow: a single hardware device, a machine, and a full industrial plant. They are not separate practices — a device sits inside a machine, a machine sits inside a plant, and designing across all three keeps the interfaces between them honest.
The tools split by what they do best. SolidWorks and Fusion 360 (Autodesk) carry the engineering — parametric parts, assemblies, tolerances and the CAD-to-CAM bridge to fabrication. Blender and Maya carry form and motion — enclosure shaping, surfaces, renders and the exploded views that explain a machine before it exists.
What ties it together is the refusal to split the model from the thing it becomes. The design fluency here is integral to the hardware, automation and machinery work elsewhere on this site: the same hands that draw a part build it, so design intent never gets handed between two people and lost in translation.
scales I model in one workflow: a single device, a machine, and a full industrial plant
primary tools — SolidWorks and Fusion 360 for engineering, Blender and Maya for form and visualization
every model carries through to fabrication: the part I draw is the part that gets cut, printed or machined
design and build owned by the same hands — I draw what I intend to fabricate
Four tools, chosen by what each does best.
SolidWorks and Fusion 360 carry the tolerance-driven engineering; Blender and Maya carry form, surface and motion. Each tab is a tool I use daily, not a line on a list.
Parametric mechanical design and assemblies
SolidWorks is where most of the mechanical work lives. I build parts from a feature tree — sketch, extrude, revolve, fillet, pattern — so a design stays editable by intent rather than frozen as geometry. Change a driving dimension and the dependent features rebuild.
At the assembly level I mate components with constraints, check interference, and drive motion through the mates so a mechanism can be verified before anything is fabricated. The same model produces the drawings a shop needs.
- Feature-tree parts driven by dimensions and relations
- Mated assemblies with interference and clearance checks
- Motion verified through mates before fabrication
- Detailed drawings generated from the same model
Integrated CAD and CAM in one Autodesk file
Fusion 360 (Autodesk) is the tool I reach for when design and manufacturing need to live in the same file. The model, the toolpaths and the simulation share one timeline, so a change upstream flows into the CAM setup without a separate export.
I use its CAM workspace to define stock, tools and toolpaths for milling and turning, then generate the G-code that drives the machine. The CAD-to-CAM bridge is the point of it — the part I draw is the part the controller cuts.
- Parametric timeline shared by CAD and CAM
- Stock, tool library and toolpaths defined in one place
- G-code generated for milling and turning
- Design changes propagate into manufacturing setups
Form, organic geometry and visualization
Blender handles the work that is about form rather than tolerance — enclosure shaping, organic surfaces, and the high-fidelity renders that explain a device before it exists. Mesh modeling, modifiers and a node-based material system carry a concept from blockout to a presentable image.
It is also where I prepare exploded views and animated assembly sequences, so a complicated machine can be read in a single frame instead of a page of text.
- Mesh modeling and modifier-driven form
- Node-based materials and physically based rendering
- Exploded views and assembly animations
- Concept visualization ahead of detailed CAD
Surface, rigging and motion for complex mechanisms
Maya covers the cases that need controlled motion and clean surfaces — rigging a mechanism so its degrees of freedom can be exercised, and building NURBS and polygon surfaces where the transition between faces has to be exact.
Where Blender is my faster path to a render, Maya is the path to a rig and a repeatable animation of how a machine actually moves.
- NURBS and polygon surface modeling
- Rigging to exercise a mechanism degrees of freedom
- Repeatable motion for machine sequences
- Clean surface transitions for visualization
Toolset — what each tool is for
- SolidWorks
- Parametric parts, assemblies, drawings
- Fusion 360 (Autodesk)
- Integrated CAD + CAM, G-code
- Blender
- Form, organic surfaces, rendering
- Maya
- Surfaces, rigging, machine motion
- Model intent
- Feature trees and constraints, not frozen geometry
- Handoff
- CAD model carries through to CAM and fabrication
- Scales
- Device · machine · full industrial plant
The path from a sketch to a finished part.
A model is only finished when it produces what the shop needs — without losing the intent along the way.
The workflow runs in one direction, from a constrained sketch to a part on the floor. Design intent is captured first as dimensions and relations; the solid is built from features so it stays editable; the assembly is checked for motion and interference; and then the same model becomes the CAM setup that drives fabrication.
The CAD-to-CAM bridge is the point. In Fusion 360 the model, the toolpaths and the simulation share one file, so a change upstream flows into manufacturing rather than requiring a re-export. The part I draw is the part the controller cuts.
CAD to CAM — sketch to finished part
- 01 Sketch & constrain Define the part as a constrained 2D sketch — dimensions and relations that capture design intent, not just coordinates.
- 02 Parametric model Build the solid from features (extrude, revolve, fillet, pattern) so the model stays editable by intent.
- 03 Assembly & check Mate components, verify clearances and interference, and exercise motion before anything is cut.
- 04 CAM setup Define stock, tools and toolpaths in Fusion 360; the model and the manufacturing live in one file.
- 05 Simulate Verify toolpaths and motion in software to catch collisions and gouges before the spindle moves.
- 06 G-code & fabricate Post the toolpaths to G-code and machine, 3D-print or fabricate the part I drew.
One direction, no lost intent
The model that gets verified is the model that gets cut.
Every stage feeds the next without a hand-off that loses information. The constraints that define the sketch drive the features; the features define the assembly; the assembly defines the CAM setup; the CAM setup posts the G-code. There is no point where a drawing is reinterpreted by a second pair of hands.
That continuity is why the design work is inseparable from the fabrication work. The diagram below is the literal flow — from the parametric model on the left to the machine and the part on the right.
- Constraints drive features; features drive the assembly
- The assembly drives the CAM setup
- Toolpaths simulated, then posted to G-code
- No reinterpretation between design and fabrication
A device, a machine, a plant — one workflow.
The same modeling discipline applies whether the subject is a part you can hold or a building full of equipment. What changes is the level of detail in focus: a device is about the boards and connectors it houses; a machine is about frames, drivetrains and moving sub-assemblies; a plant is about equipment placement and material flow.
Designing across all three in one workflow is deliberate. A device that ignores the machine it sits in, or a machine that ignores the plant it stands in, creates an interface that someone else has to fix later. Owning the scales together keeps those interfaces honest.
Hardware devices
Enclosures, mounts, brackets and mechanisms for electronic devices — designed around the boards, connectors and thermal paths they have to house, then taken through to a fabricable model.
Machinery
Production and process machines as full assemblies: frames, drivetrains, guarding and the moving sub-assemblies, modeled so motion and clearance are verified before steel is cut.
Industrial plants
Whole-plant layout — equipment placement, material flow and the footprint that ties machines into a working line, drawn at the scale where the process and the building meet.
Fixtures & tooling
Jigs, fixtures and tooling that hold a part during fabrication or assembly, designed in the same CAD environment as the part they serve.
Fabrication-ready output
Drawings, toolpaths and printable geometry generated from the design model, so the intent survives the trip to the shop floor.
Visualization
Renders, exploded views and assembly sequences that explain a device or a machine before it exists, built in Blender and Maya.
A model built to stay editable.
Feature trees and constraints
Why I build parts from a tree, not from frozen geometry.
A parametric model is a record of intent. Instead of fixed coordinates, a part is a tree of features — a base sketch, an extrude, a fillet, a pattern — each one referencing the ones before it. Change a driving dimension and the dependent features rebuild rather than break.
At the assembly level the same idea scales up: components are mated by constraints, and the constraints hold the design together when something upstream changes. The tree below shows how a top-level assembly resolves into sub-assemblies and individual parts.
- Features reference each other, not fixed coordinates
- A driving dimension change rebuilds the dependents
- Assemblies held together by mate constraints
- Design intent survives revision
An enclosure drawn around the boards it has to house.
Exploded view
A device read as its parts — enclosure, board, fasteners, ports.
A hardware device is designed from the inside out. The boards, connectors and thermal paths come first; the enclosure, mounts and brackets are modeled around them so the parts fit, the heat has somewhere to go, and the connectors reach the panel.
The exploded view is how I check and explain that fit. Pulling the assembly apart along its axes shows the stack — cover, board, standoffs, base — and makes a mismatch obvious before any part is fabricated. This is the same design fluency that runs through the hardware and electronics work elsewhere on this site.
- Designed around the boards and connectors it houses
- Mounts, standoffs and thermal paths modeled in
- Exploded view exposes the stack and the fit
- Mismatches caught before fabrication
An exploded view is not decoration — it is the cheapest way to find out that two parts will not go together, before either one is cut.
Machines verified in software before steel is cut.
A machine is a full assembly — frame, drivetrain, guarding and the moving sub-assemblies — and every interface is a place something can go wrong.
Machinery is where the assembly discipline earns its keep. A production or process machine is modeled as a complete assembly so that motion, clearance and interference can be exercised on screen: a moving sub-assembly is driven through its range and watched for collisions against the frame and the guarding around it.
This is the design half of the machinery and automation work elsewhere on this site — the machines I design are the machines I build and control. Modeling them parametrically means a change to one component propagates through the assembly instead of quietly breaking a mate, and the verified model is the one that becomes the fabrication drawings.
Motion and clearance
The moving parts get exercised before they exist.
The value of modeling a machine as a constrained assembly is that motion is not a hope — it is something you drive and watch. A linkage, a carriage, a rotating sub-assembly: each is mated so its degrees of freedom match the real mechanism, then swept through its travel to confirm it clears everything around it.
When the motion is clean and the interference checks pass, the same model generates the drawings and, where a part is machined, the CAM toolpaths. Design and build stay one continuous problem.
- Machine modeled as a complete constrained assembly
- Moving sub-assemblies swept through their travel
- Interference checked against frame and guarding
- Verified model becomes drawings and toolpaths
The scale where the process meets the building.
Plant layout
Equipment placement and material flow, drawn as a footprint.
A plant is the largest scale I design at, and the questions change again. Now it is about where the equipment stands, how material moves between stations, and how the line fits the footprint of the building. The individual machines are known quantities; the design problem is the arrangement that turns them into a working process.
I draw the layout so the flow is legible — feed in at one end, product out at the other, with the reactors, machines and storage placed so material moves forward rather than crossing back on itself. This is the design layer under the process and automation work: the same plants I lay out are the ones the chemistry and machinery run inside.
- Equipment placement across the building footprint
- Material flow from feed to product, forward not crossing
- Stations sized and spaced for access and service
- The layout the process and automation run inside
At plant scale the machines are the known quantities. The design problem is the arrangement that turns a room full of equipment into a line that flows in one direction.
Why the design is inseparable from everything else.
Design is not a stand-alone service here — it is the connective tissue between the disciplines. The hardware devices need enclosures and mechanisms; the automation needs machines to control; the chemistry needs reactors, columns and the plants they stand in. Every one of those is a design problem first, and I model it before I build it.
Because the same hands draw and fabricate, the design stays honest to what is buildable. A model that cannot be machined, mated or laid out into a real footprint is not a finished design — and finding that out happens on screen, in SolidWorks, Fusion 360, Blender or Maya, rather than on the shop floor.
That is what design fluency means in this context: not a separate portfolio of renders, but the ability to take any of the other work from intent to a fabricable model and through to the part, the machine or the plant. I design what I build, and I build what I design.
Design what I build
The model is not a separate artifact handed to someone else — it is the same intent that becomes the device, the machine or the plant. I draw what I intend to fabricate.
Parametric over frozen
Parts are built from feature trees and constraints so a design stays editable by intent. Change a driving dimension and the dependents rebuild rather than break.
Verify before you cut
Interference, clearance and motion are checked in software, and toolpaths are simulated, so collisions are found on screen rather than on the machine.
Carry intent to the floor
A model is only finished when it produces what the shop needs — drawings, toolpaths, printable geometry — without losing the intent along the way.
Right tool for the surface
Tolerance-driven geometry goes to SolidWorks and Fusion 360; form and motion go to Blender and Maya. Each tool earns its place by what it does best.
One scale into the next
A device sits inside a machine; a machine sits inside a plant. Designing across all three in one workflow keeps the interfaces between them honest.
From brief to part — the path a design follows.
Brief, model, verify, visualize, fabricate — the same path whether the subject is a device, a machine or a plant.
Read in sequence, the work is one continuous method rather than a set of separate steps. A design starts from constraints, becomes a parametric model, gets verified for motion and interference, is visualized so others can read it, and ends as toolpaths and a fabricated part.
The thread through all of it is that the model never leaves my hands until it has produced the thing it describes. That is why the design and the build are inseparable: they are the same problem, followed from one end to the other.
- Brief Constraints before geometry A design starts from what it has to satisfy — the boards it houses, the loads it carries, the process it serves — captured as constraints before any solid is drawn.
- Model Parametric build The part or assembly is built feature by feature in SolidWorks or Fusion 360, kept editable by intent so it can absorb change without being redrawn.
- Verify Motion, clearance, interference Assemblies are mated and exercised, clearances and interference checked, and CAM toolpaths simulated before anything is fabricated.
- Visualize Renders and exploded views Blender and Maya turn the model into renders, exploded views and assembly sequences that explain the design before it is built.
- Fabricate CAD to CAM to part Toolpaths are posted to G-code; parts are machined, printed or fabricated. The part that comes off the floor is the part that was drawn.
Define the constraints, build the model parametrically, verify it before you cut, and carry the intent all the way to the part — everything else is detail.
Open to the right work
If your problem is a device, a machine or a plant that has to be designed and actually built, that is the work I want.
If you are holding a problem that doesn't fit inside one field, that is the conversation I want.