Skip to content
LumenaryAcademy
Design 75 min

The engineering design process and CAD

From a need to a toleranced drawing — requirements, concepts and how to choose between them, embodiment and detail design, parametric CAD, fits and GD&T, and the arithmetic of tolerance stack-ups.

Code tested · 5AI-draftedAwaiting review by a mechanical engineer

Your guides: Chloe · The Designer, Margaret · The Test Engineer, Gideon · The Checker

MotivationH

From a need to a drawing someone can make

In How things are made you met the design cycle: understand the problem, sketch ideas, prototype, test, improve. That loop never goes away, but a professional team building a gearbox, an infusion pump or a farm machine needs more: a precise statement of what "good enough" means, a fair way to choose between very different ideas, a model precise enough to make thousands of identical parts from, and a way of saying how imprecise each part may be.

This lesson follows a human-powered irrigation pump for smallholder farms, and a gearbox shaft, through requirements, concepts, embodiment, detail, and the CAD and tolerancing that carry a design to the factory. You will compute a weighted decision matrix and test how fragile its answer is, work out the clearance in a standard fit, and add up a chain of tolerances three ways.

DefinitionsH

Requirements and specifications

A need is what a person wants, in their words: "I want to water my vegetables in the dry season without paying for fuel." Engineers translate needs into requirements that a design can be checked against, and collect them in a specification (in industry often called a product requirements document or, in the German tradition, a Lastenheft and Pflichtenheft).

Definition— requirement

A statement of something the product shall do or be, written so that it can be verified by test, measurement, inspection or analysis. A good requirement is necessary, unambiguous, verifiable, and free of any particular solution. It has a metric, a target value and, often, a limit beyond which the design is unacceptable.

Compare "the pump should be easy to use" with "a 60 kg adult shall deliver at least 0.7 L/s against a 4 m head for 30 minutes at a mechanical power input of no more than 75 W." The second can be tested on a rig with a stopwatch and a bucket; the first cannot. Here is a fragment of a specification for our pump, written with a farming cooperative's members after field visits:

IDRequirementMetricTargetLimitVerified by
R1Delivers water from a shallow wellflow at 4 m head, 75 W input1.0 L/s≥ 0.7 L/srig test
R2Affordable for one householdfactory costUSD 60≤ USD 90cost model
R3Repairable in the villagespecial tools needednonenoneinspection
R4Survives a season's usehours to first failure1500 h≥ 800 hendurance test
R5Carried by one personmass15 kg≤ 25 kgweighing

Requirements may be functional (what it does), performance (how well), interfaces (a 40 mm hose, a standard bicycle chain), constraints (regulations, standards) or about the whole life cycle: manufacture, maintenance, recycling. Gerhard Pahl and Wolfgang Beitz's German school divides them into demands, which must be met, and wishes, which are traded against each other, much like the "limit" and "target" columns above.

Quality function deployment, developed in Japan from the late 1960s by Yoji Akao and others, links each customer need to the engineering metrics that serve it in a matrix (the "house of quality"), and benchmarking measures existing products against the same metrics, showing whether a target is ambitious, ordinary or impossible.

IntuitionH

The shape of the design process

Design textbooks from Germany, Britain, Japan and the United States draw the process slightly differently, but they agree on its shape: a funnel that starts wide and abstract and ends narrow and concrete, with loops back whenever something learned later breaks an earlier decision.

Clarifythe taskConceptualdesignEmbodimentdesignDetaildesignMake andverifyspecificationchosen conceptlayout, materials,processesmodels, drawings,bill of materialsproduct thatmeets the speciterateabstract and cheap to change → concrete and expensive to change
The stages of engineering design and what each hands to the next. Iteration is normal: a failed test or a manufacturing problem sends the team back to an earlier stage, and the later the loop starts, the more it costs.

The bottom arrow is the reason for all the discipline: changing a requirement on day three costs a meeting; changing it after the moulds are cut costs the moulds. Organisations formalise this with stage gates (reviews a project must pass before more money is spent) and, in aerospace and medical devices, the V-model of systems engineering, which pairs each requirement with the test that will verify it. Verification asks "did we build the product right?", against the specification; validation asks "did we build the right product?", with real users in the real setting.

Worked examplesH

Generating concepts and choosing one

A concept is a working principle and a rough form: how the product will do its job. The commonest mistake at this stage is falling in love with the first idea. Good teams generate many on purpose.

  • Function decomposition. Break the overall function ("lift water 4 m using leg power") into sub-functions: accept human power, convert it to a pumping motion, move water, prevent backflow, connect to a hose.
  • Morphological chart. List several ways of achieving each sub-function in a table, then combine one from each row. Four ways to accept power, three pumping principles, three kinds of valve and two frames already give 4×3×3×2=724 \times 3 \times 3 \times 2 = 72 combinations, most of which nobody would have thought of one at a time.
  • Analogy and nature. See how other industries and living things solve the same sub-problem, like the kingfisher-nosed Shinkansen of the Start level.
  • TRIZ, developed in the Soviet Union from the 1940s by Genrich Altshuller from a study of patents, treats inventive problems as contradictions (stronger and lighter) with general principles for resolving them.

Then the concepts must be compared. Stuart Pugh, at the University of Strathclyde, popularised a quick first filter: pick one concept as the datum and mark every other one better, same or worse on each criterion. For the final choice, teams use a weighted decision matrix.

Definition— weighted decision matrix

Choose criteria j=1,…,mj = 1, \dots, m from the specification and give them weights wj≥0w_j \ge 0 with ∑jwj=1\sum_j w_j = 1. Score each concept ii on each criterion, sijs_{ij}, on a common scale (here 1 to 5). The concept's weighted score is

Si=∑j=1mwj sij,S_i = \sum_{j=1}^{m} w_j\, s_{ij},

a matrix–vector product S=s w\mathbf{S} = \mathbf{s}\,\mathbf{w}. The highest score is the preferred concept, if the margin is larger than the uncertainty in the weights and scores.

Our cooperative's team considered four concepts: a treadle pump (two pistons worked by stepping, long used on small farms in Bangladesh and East Africa), a rope-and-washer pump (washers on a loop of rope drawn up through a pipe), a lever-operated diaphragm pump, and a small solar-powered pump as a benchmark. After building rough prototypes, they scored each concept against six criteria drawn from the specification.

ComputationC

Computing it: the decision matrix and its sensitivity

The program computes the weighted scores, then asks the question too many reports skip: if the weights had been a little different, would the answer change? It redraws the weights 20 000 times from a Dirichlet distribution centred on the agreed ones (a convenient way to generate random weights that are positive and sum to 1), and finally scans the weight on purchase cost.

python
import numpy as np

# Concept selection for a human-powered irrigation pump for small farms.
criteria = ["flow at 4 m head", "purchase cost", "local repair", "user effort", "durability", "portability"]
weights = np.array([0.25, 0.25, 0.20, 0.15, 0.10, 0.05])
concepts = ["treadle pump", "rope-and-washer", "lever diaphragm", "small solar pump"]

# Scores from 1 (poor) to 5 (excellent), agreed by the team after prototype tests.
scores = np.array([
    # flow cost repair effort durab. portab.
    [4,    4,   4,     3,     3,     3],   # treadle pump
    [3,    5,   5,     3,     2,     2],   # rope-and-washer
    [2,    3,   2,     4,     4,     5],   # lever diaphragm
    [5,    1,   1,     5,     4,     3],   # small solar pump
])

assert abs(weights.sum() - 1) < 1e-12
totals = scores @ weights                      # weighted sum, out of 5
order = np.argsort(-totals)
print("concept              weighted score   rank")
for rank, i in enumerate(order, start=1):
    print(f"{concepts[i]:18s}   {totals[i]:6.2f} / 5       {rank}")

# How fragile is the ranking? Re-draw the weights many times near the agreed ones.
rng = np.random.default_rng(2026)
trials = 20000
w = rng.dirichlet(weights * 40, size=trials)   # random weights, mean = agreed weights
winners = np.argmax(w @ scores.T, axis=1)
print("\nshare of 20 000 perturbed weightings won by each concept:")
for i, name in enumerate(concepts):
    print(f"  {name:18s} {np.mean(winners == i):6.1%}")

# What weight on purchase cost would change the winner?
print()
for cost_w in [0.25, 0.20, 0.15, 0.10, 0.05, 0.0]:
    ww = weights.copy()
    ww[1] = cost_w
    ww = ww / ww.sum()                         # keep the weights summing to 1
    best = concepts[int(np.argmax(scores @ ww))]
    print(f"cost weight {cost_w:4.2f} (renormalised {ww[1]:.3f}): best = {best}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The rope-and-washer pump scores 3.75 and the treadle pump 3.70, with the solar pump at 3.00 and the diaphragm pump at 2.90. A difference of 0.05 on a five-point scale is far smaller than the uncertainty in anyone's scores, and the sensitivity test says so plainly: the rope pump wins about 64% of the perturbed weightings and the treadle pump about 35%. Lower the weight on purchase cost from 0.25 to 0.20 and the treadle pump takes the lead; set it to zero and the solar pump wins.

Notice also what a matrix cannot do. It cannot rescue a concept that fails a hard limit (the solar pump's cost of several times the limit in R2 should exclude it before scoring), and it cannot correct criteria that overlap: "purchase cost" and "local repair" both reward simple construction, so simplicity is counted twice.

ExplanationH

Embodiment and detail design

With a concept chosen, embodiment design gives it a definite form. The team decides the overall layout and the main dimensions, chooses materials and manufacturing processes, sizes the parts that carry load (with the stress analysis of axial load, torsion and bending and the checks of failure and fatigue), and selects standard parts such as bearings, seals and fasteners, the subject of the next lesson. Several principles guide this stage:

  • Clarity, simplicity, safety. Each function should have one clear carrier; fewer parts mean fewer failures; a failure should be safe and visible.
  • Design for manufacture and assembly (DFM/DFA). Parts easy to make with the chosen process; assembly with parts that cannot go in the wrong way, screws from one direction, and as few parts as the functions allow.
  • Failure modes and effects analysis (FMEA). For each part, list how it could fail, the effect, its likelihood and detectability, and fix the worst risks in the design rather than in the instructions.

Detail design then fixes every dimension, tolerance, surface finish, material grade, heat treatment and coating, and the bill of materials (BOM), and writes the test plan that will verify each requirement. Design reviews at each stage bring in people who did not do the design, because the designer is the person least able to see what was assumed.

ExplanationH

CAD: parametric modelling, assemblies and drawings

Gaspard Monge's descriptive geometry, in France in the 1790s, gave the projections still used on every drawing; Ivan Sutherland's Sketchpad at MIT in 1963 brought drawing to the computer; and the parametric, feature-based solid model that defines modern mechanical CAD reached the market in the late 1980s.

Sketches, constraints and features

A part begins as a 2-D sketch: lines, arcs and circles tied by geometric constraints (horizontal, tangent, coincident, concentric, symmetric) and dimensional constraints (lengths, radii, angles). Each free point has two degrees of freedom and each constraint removes some; a fully constrained sketch has none left, so it changes only when you change a dimension. A constraint solver handles the resulting nonlinear equations, by the kind of Newton iteration you will use in mechanisms and linkages.

A feature turns a sketch into solid (a pad, pocket, revolve, sweep or loft) or dresses it (a fillet, chamfer, shell or draft). Features are stored in order in a feature tree, and the model is rebuilt from it whenever anything changes.

60⌀ d = 122·d + 20HV=symBodySketch (plate)Pad, 6 mmSketch001 (holes)Pocket, through allFillet, r = 4change d → every feature rebuilds
A parametric part. Left: a fully constrained sketch of a mounting plate, in which the plate width is an expression of the hole diameter d. Right: the feature tree that turns the sketch into a solid. Changing d from 12 to 16 mm rebuilds every feature, and the plate grows to keep the edge distance.

The skill of parametric modelling is capturing design intent: dimensioning a hole from the datum face it must line up with, not from whichever edge was handy; making the plate width depend on the hole size if that is the real rule; driving a family of parts from a table of parameters. A well-built model can be stretched to a new size in seconds; a badly built one collapses when the first early feature changes, because later features referred to edges that no longer exist (the "topological naming" problem, which every CAD kernel has to manage and which FreeCAD's 1.0 release in 2024 tackled for its own kernel).

Underneath, the solid is a boundary representation (B-rep): exact surfaces (planes, cylinders, NURBS) and the edges and vertices where they meet, maintained by a geometry kernel such as Parasolid (Siemens), ACIS and CGM (Dassault Systèmes) or the open-source Open CASCADE that FreeCAD uses. Models travel between programs as STEP files (ISO 10303), and as STL or 3MF meshes for printing.

Assemblies and drawings

An assembly places parts with mates or joints (coincident faces, concentric axes, revolute or slider joints), which remove relative degrees of freedom as kinematic pairs do in a mechanism; the software then checks interference, measures clearances, computes mass properties and animates motion. Large products are built top-down from a skeleton model, so that moving a mounting point updates everything attached to it.

From the model the software projects 2-D drawings (views, sections, dimensions, tolerances, title block). Increasingly, the tolerances and notes are attached to the 3-D model itself as product and manufacturing information (PMI), called model-based definition, and product lifecycle management (PLM) systems control versions, approvals and changes.

The tools

FreeCAD is free and open source (LGPL), and covers the whole workflow above in its Sketcher, PartDesign, Assembly and TechDraw workbenches, with finite element and CAM workbenches besides; it is scriptable in Python. Among commercial packages, Dassault Systèmes in France makes SOLIDWORKS and CATIA (dominant in aerospace and car making); Siemens makes NX and Solid Edge; PTC in the United States makes Creo, descended from the first commercial parametric modeller, and the browser-based Onshape; Autodesk makes Inventor and Fusion; and ZWSOFT in China makes ZW3D. They share the concepts in this section and differ in price, licensing, specialist tools (sheet metal, surfacing, moulds, piping) and handling of large assemblies; most offer free or educational licences to students, on terms that change, so check each maker's.

CAD can also be written as code. Here is a mounting plate in CadQuery, a Python library built on Open CASCADE. It is shown for reading and is not run here, because CadQuery is not available in the browser:

python
# CadQuery (not run here: needs the cadquery package and its geometry kernel)
import cadquery as cq

d = 12.0                     # hole diameter, mm
plate = (cq.Workplane("XY")
         .box(2 * d + 20 + 60, 2 * d + 20, 6)        # length, width, thickness
         .edges("|Z").fillet(4)
         .faces(">Z").workplane()
         .pushPoints([(-30, 0), (30, 0)]).hole(d))
cq.exporters.export(plate, "plate.step")

Code-based models are easy to version-control and to generate in families; interactive CAD remains faster for shaping and checking most parts.

DefinitionsH

Tolerances, fits and GD&T

No part is made exactly to size. A tolerance is the permitted variation, and choosing it is a design decision with consequences both ways: too loose and parts do not work together; too tight and every part costs more to make and inspect, because the process must be slower, the machine better, or the parts sorted.

Definition— limits, fits and the ISO system

A size tolerance sets an upper and a lower limit, for example ∅250+0.021\varnothing 25^{+0.021}_{0}. A fit is the relationship between a hole and the shaft in it: a clearance fit always leaves a gap, an interference fit always overlaps (the shaft must be pressed or shrunk in), and a transition fit may do either. In the ISO system (ISO 286) a fit is written like ∅25 H7/g6\varnothing 25\ \text{H7/g6}: the letter gives the position of the tolerance zone relative to the nominal size (capital for holes, lower case for shafts; H puts the hole's lower limit exactly at nominal), and the number gives the international tolerance grade, IT6, IT7 and so on, how wide the zone is.

The grades are not arbitrary. The standard defines a tolerance unit that grows with the cube root of the size, i=0.45D3+0.001Di = 0.45\sqrt[3]{D} + 0.001 D micrometres for DD in millimetres, and each grade is a fixed multiple of it (IT6 is 10i10i, IT7 is 16i16i). A larger part is harder to make to the same absolute accuracy, so it is allowed more. The program computes the grades from the formula and the limits of two common fits on a 25 mm bearing seat.

python
import numpy as np

# How big is a tolerance grade? The ISO system grows tolerances with the cube root of size.
def tolerance_unit_um(D):
    """Standard tolerance factor i in micrometres for a nominal size D in mm (sizes up to 500 mm)."""
    return 0.45 * D ** (1 / 3) + 0.001 * D

GRADE = {"IT6": 10, "IT7": 16, "IT8": 25, "IT9": 40, "IT11": 100}   # multiples of i

print("size (mm)   i (um)   " + "   ".join(f"{g:>5s}" for g in GRADE))
for D in [3, 10, 25, 50, 100, 250, 500]:
    i = tolerance_unit_um(D)
    print(f"{D:8d}   {i:6.2f}   " + "   ".join(f"{m * i:5.0f}" for m in GRADE.values()))

# A 25 mm bearing seat. The standard groups sizes into ranges; 25 mm lies in 18-30 mm,
# and the formula is evaluated at the range's geometric mean.
D = np.sqrt(18 * 30)
i = tolerance_unit_um(D)
IT6, IT7 = 10 * i, 16 * i
print(f"\n25 mm (range 18-30 mm): IT6 = {IT6:.1f} um, IT7 = {IT7:.1f} um")

# Hole H7: lower deviation 0, upper +IT7.  Shaft g6: upper deviation -2.5 D^0.34, lower = upper - IT6.
hole = (0.0, round(IT7))
es = -round(2.5 * D ** 0.34)
shaft = (es - round(IT6), es)
print(f"hole  25 H7: +{hole[0]:.0f} to +{hole[1]:.0f} um")
print(f"shaft 25 g6: {shaft[0]:.0f} to {shaft[1]:.0f} um")
print(f"clearance: min {hole[0] - shaft[1]:.0f} um, max {hole[1] - shaft[0]:.0f} um  -> a sliding (clearance) fit")

# Shaft k6 for comparison: lower deviation +0.6 D^(1/3)
ei = round(0.6 * D ** (1 / 3))
shaft_k = (ei, ei + round(IT6))
print(f"shaft 25 k6: +{shaft_k[0]:.0f} to +{shaft_k[1]:.0f} um")
print(f"with H7: from {hole[0] - shaft_k[1]:.0f} um (interference) to {hole[1] - shaft_k[0]:.0f} um (clearance) -> a transition fit")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

At 25 mm, IT7 is about 21 µm and IT6 about 13 µm: a quarter of a human hair. An H7 hole with a g6 shaft always slides, with 7 to 41 µm of clearance, as for a gear that must slide along a shaft. An H7 hole with a k6 shaft ranges from 15 µm of interference to 19 µm of clearance, a transition fit that locates a part accurately yet assembles with a light press. The standard rounds and tabulates these values by size range; for a real drawing, take the limits from ISO 286 or your CAD system's fit tables, and follow bearing makers' advice for bearing seats.

Geometric dimensioning and tolerancing

Size limits say nothing about form, orientation or location. A shaft can be within its diameter limits and still be bent like a banana; a hole can be the right size in the wrong place. Geometric dimensioning and tolerancing (GD&T) adds a language for these. It is specified by ASME Y14.5 in the United States and by the ISO geometrical product specification (GPS) standards, chiefly ISO 1101, elsewhere; the two are similar but not identical.

4030BCdatum A: back face⌀ 0.2MABCtolerance zone ⌀ 0.2 (enlarged)dot: actual axis of the hole
GD&T in outline. Three datum features A, B and C fix the part in a reference frame, the way it will sit in its assembly. The hole's ideal position is given by basic (boxed) dimensions, and the feature control frame says its axis must lie within a cylinder of diameter 0.2 mm around that position, measured from datums A, B and C in that order; the circled M lets the zone grow as the hole departs from its smallest size.

The essentials:

  • Datums are real features of the part (a flat face, an edge, a bore) that define a reference frame, chosen to match how the part is located when assembled. The order matters: the primary datum takes three degrees of freedom, the secondary two, the tertiary one, just as a part rests on a table, slides against a fence and stops against a pin.
  • Basic dimensions, in boxes, give the exact ideal geometry; the tolerance lives in the feature control frame, not on the dimension.
  • Tolerance zones have a shape: a cylinder around a hole's ideal axis for position, two parallel planes for flatness. The round zone matches function better than "±0.1 in x and y": that square allows 0.141 mm of error along a diagonal, and a hole that works there works 0.141 mm off in any direction, so the functional zone is the circle through the square's corners, ⌀0.283 mm, with π/2≈1.57\pi/2 \approx 1.57 times the square's area.
  • Material condition modifiers. The circled M (maximum material condition) lets the zone grow by however much the hole exceeds its smallest size, since a bigger hole leaves more room for a bolt; this bonus tolerance suits quick checks with functional gauges.
ComputationC

Computing it: a tolerance stack-up

When several toleranced parts sit end to end, their variations add up in the dimension that matters, usually a gap. Finding that dimension's range is a tolerance stack-up. Our example is the output shaft of a small gearbox: two ball bearings, a spacer and a gear hub sit in a housing bore, held by an internal circlip, and the bearings need between 0.20 and 0.80 mm of axial end float GG to run freely without the shaft rattling.

bearing 1spacergear hubbearing 2GcirclipA: housing bore depth (+)B1 (−)S (−)H (−)B2 (−)GC (−)
An axial stack-up (schematic, not to scale). The gap G equals the housing bore depth A minus the five parts in the bore. Arrows to the right increase the gap, arrows to the left reduce it.

Write the gap as a sum of signed dimensions, G=A−B1−S−H−B2−CG = A - B_1 - S - H - B_2 - C. Then there are three ways to find its spread, given each dimension's tolerance ±tk\pm t_k:

  • Worst case: GG varies by ±∑ktk\pm \sum_k t_k. Every part could be at its worst limit at once, so this guarantees 100% assembly, at the price of tight (expensive) part tolerances.
  • Statistical, root-sum-square (RSS): ±∑ktk2\pm\sqrt{\sum_k t_k^2}. If the dimensions vary independently and each tolerance is three standard deviations of a centred normal distribution, the variances add, and the result covers 99.73% of assemblies. With many parts this is much narrower than the worst case.
  • Monte Carlo: build a large number of virtual assemblies from randomly drawn parts with whatever distributions the processes really produce, and count the failures.
python
import numpy as np

# Axial stack in a small gearbox: the end float G between the circlip and the outer bearing.
# sign +1: making this part bigger makes the gap bigger; -1: makes it smaller.
#            name               nominal   +/- tol   sign
stack = [("housing bore depth",  62.00,   0.10,   +1),
         ("bearing 1 width",     12.00,   0.06,   -1),
         ("spacer",              21.70,   0.05,   -1),
         ("gear hub",            14.00,   0.05,   -1),
         ("bearing 2 width",     12.00,   0.06,   -1),
         ("circlip thickness",    1.75,   0.03,   -1)]
G_min, G_max = 0.20, 0.80             # end float the bearings need (mm)

nominal = sum(s * n for _, n, _, s in stack)
wc = sum(t for _, _, t, _ in stack)
rss = np.sqrt(sum(t ** 2 for _, _, t, _ in stack))
print(f"nominal gap        {nominal:.2f} mm")
print(f"worst case         {nominal - wc:.2f} to {nominal + wc:.2f} mm  (+/- {wc:.2f})")
print(f"statistical (RSS)  {nominal - rss:.2f} to {nominal + rss:.2f} mm  (+/- {rss:.3f})")
print(f"requirement        {G_min:.2f} to {G_max:.2f} mm")

# Monte Carlo: build 200 000 gearboxes from parts drawn at random.
rng = np.random.default_rng(7)
N = 200_000
for shape in ["normal, tol = 3 sigma", "uniform over the tolerance"]:
    G = np.zeros(N)
    for _, n, t, s in stack:
        if shape.startswith("normal"):
            x = rng.normal(n, t / 3, N)
        else:
            x = rng.uniform(n - t, n + t, N)
        G += s * x
    bad = np.mean((G < G_min) | (G > G_max))
    print(f"\n{shape}: gap mean {G.mean():.3f}, std {G.std():.4f} mm")
    print(f"  0.1th-99.9th percentile {np.percentile(G, 0.1):.3f} to {np.percentile(G, 99.9):.3f} mm")
    print(f"  out of specification: {bad * 1e6:.0f} per million")

# Which tolerance matters most? Contribution to the variance of the gap.
print("\ncontribution to the variance of the gap:")
for name, _, t, _ in stack:
    print(f"  {name:20s} {t ** 2 / rss ** 2:6.1%}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The nominal gap is 0.55 mm. The worst case runs from 0.20 to 0.90 mm and breaks the 0.80 mm limit, so a worst-case designer must tighten tolerances or adjust nominals. The RSS estimate, 0.40 to 0.70 mm, sits comfortably inside the requirement, and the Monte Carlo run with normal, centred parts agrees: no failures in 200 000 assemblies. But if each part is equally likely to be anywhere in its tolerance band (a uniform distribution, typical of a process that drifts between tool changes), the spread grows by 74% and about 800 assemblies per million fail. The variance breakdown shows where to spend money: the housing bore depth alone contributes 43% of the variance, so tightening that one tolerance does more than tightening the other five together.

ExplanationH

How it is done in industry

In a company these stages run inside a quality system. ISO 9001 requires documented design and development controls (planned reviews, verification and validation records, controlled changes); medical-device and aerospace makers add stricter rules on risk management and traceability; and a change after release goes through an engineering change process, so that factory, suppliers and service manuals move together.

Tolerances are increasingly analysed in 3-D tools that run stack-ups on the CAD model's GD&T directly, and set against the process capability data the factory measures, which you will compute in manufacturing processes. Simulation moves earlier every year, and topology optimisation and generative design now propose shapes from loads and constraints, the subject of simulation-driven design. None of this replaces the judgement this lesson is about: deciding what the product is for, writing it down so it can be checked, and choosing honestly between alternatives.

Common misconceptionsH

Common misconceptions

Misconception

"The highest score in the decision matrix is the answer." A matrix organises judgement; it does not replace it. If the top two scores are within the uncertainty of the weights, the matrix has not decided, and a sensitivity check or a test should.

Misconception

"Tighter tolerances make a better product." They make a more expensive product. The right tolerance is the loosest one that still guarantees the function, found from the stack-up, not from habit.

Misconception

"RSS is always fine because worst cases never happen." RSS is fine when its assumptions hold. A process that drifts, a supplier who ships parts all near one limit, or a stack of only two parts can all make the worst case real.

Misconception

"Once the 3-D model is done, the design is done." A model with no tolerances, materials, finishes or verification plan cannot be bought, made or inspected. Detail design is where most of a product's cost and quality are fixed.

Exercises

Exercises

1. The engineering design process and CAD

Warm-upHuman

A team is writing the specification for the handle of a hand-operated water pump. Which statement is a well-written requirement?

Choose one

2. The engineering design process and CAD

Warm-upHuman

A team designing a pedal-powered maize sheller fills in a morphological chart. Power input: pedal crank, hand crank or treadle (3 options). Transmission: chain, belt or gears (3). Shelling: pegged drum, abrasive disc, rollers or beaters (4). Separation: sieve, fan, or sieve and fan (3). The team decides that a treadle cannot drive a belt in their design. How many combinations remain?

3. The engineering design process and CAD

CoreHuman

A drawing specifies a hole ∅400+0.025\varnothing 40^{+0.025}_{0} and a shaft ∅40+0.043+0.059\varnothing 40^{+0.059}_{+0.043} (limits in mm). What kind of fit is this?

Choose one

4. The engineering design process and CAD

CoreHuman

A gap is set by three parts with tolerances ±0.03 mm, ±0.04 mm and ±0.12 mm. Assuming each tolerance is three standard deviations of an independent, centred normal distribution, what is the root-sum-square (RSS) tolerance of the gap, in micrometres?

5. The engineering design process and CAD

CoreHuman

A slot of width A=50.00±0.08A = 50.00 \pm 0.08 mm holds two blocks side by side, B=20.00±0.05B = 20.00 \pm 0.05 mm and C=29.70±0.05C = 29.70 \pm 0.05 mm. What is the smallest possible gap G=A−B−CG = A - B - C by worst-case analysis, in micrometres?

6. The engineering design process and CAD

StretchHuman

A hole is specified as ∅10.0\varnothing 10.0 to 10.210.2 mm, with a position tolerance of ∅0.2\varnothing 0.2 at maximum material condition (the circled M) relative to datums A, B and C. An inspector measures a finished hole at ∅10.15\varnothing 10.15 mm. What diameter of position tolerance zone does this hole actually have, in micrometres?

7. The engineering design process and CAD

CoreComputational

Write weighted_ranking(scores, weights). scores is an n×mn \times m array (one row per concept, one column per criterion) and weights a length-mm array of non-negative weights that need not sum to 1. Return a pair:

  1. totals, a NumPy array of the nn weighted scores computed with the weights normalised to sum to 1, and
  2. order, a list of the concept indices from best to worst (if two totals are equal, the lower index comes first).

Raise ValueError if any weight is negative or all weights are zero.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

8. The engineering design process and CAD

StretchComputational

Write stack_up(stack), where stack is a list of (nominal, tol, sign) tuples: a nominal dimension in mm, its symmetric tolerance ±\pmtol, and sign =+1= +1 or −1-1 for how it enters the gap. Return a tuple (nominal_gap, worst_case, rss): the nominal gap, the worst-case half-width ∑tk\sum t_k and the root-sum-square half-width ∑tk2\sqrt{\sum t_k^2}.

The tests use the lesson's gearbox stack and a slot holding two blocks.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Further reading and resources

  • FreeCADFree and open-source parametric CAD, built on the Open CASCADE geometry kernel, with sketcher, part design, assembly, technical drawing and FEM workbenches.
  • FreeCAD documentation wikiTutorials for the Sketcher, PartDesign, Assembly and TechDraw workbenches.
  • Open CASCADE TechnologyThe open-source boundary-representation geometry kernel underneath FreeCAD and several other programs.
  • CadQueryA Python library for building parametric CAD models as code.
  • OpenSCADA free program that builds solid models from a short script.
  • ASMEPublishes ASME Y14.5, the American standard for dimensioning and tolerancing (GD&T).
  • ISOPublishes the ISO system of limits and fits (ISO 286), the geometrical product specification standards (ISO 1101, ISO 8015 and others) and STEP (ISO 10303).
  • Engineering Design: A Systematic Approach · Gerhard Pahl, Wolfgang Beitz, Jörg Feldhusen and Karl-Heinrich Grote · 2007The classic German account of the design process, from task clarification to detail design.
  • Product Design and Development · Karl T. Ulrich and Steven D. EppingerA widely used textbook on requirements, concept selection and product development in industry.
  • MIT OpenCourseWareSearch for MIT's design and manufacturing courses (2.007, 2.008) for lecture notes and projects.