You’ve seen this before.

Two machined plates. Clean prints. Tight inspection reports. Every feature is “in spec.”
And yet—during assembly—the parts fight each other:

• Fasteners pull components into stress

• Sliding elements bind

• Gaps open where they shouldn’t

Nothing is technically wrong… but nothing works the way you expected.

The root cause is often hiding in plain sight: parallelism was incorrectly applied.

Parallelism doesn’t guarantee alignment. It only guarantees that deviation stays within a defined orientation zone relative to a datum.

If the datum strategy is wrong—or if the control is misapplied—you’re not going to get the assembled result you need. 

What Parallelism does and does NOT control

At its core, parallelism is an orientation control.

It defines how a feature must sit relative to a datum—nothing more, nothing less.

✅ What it DOES control:

• Orientation relative to a datum reference

• Angular variation between features

⛔ What it does NOT control:

• Size

• Location

• True form (beyond limiting it within the tolerance zone)

Parallelism is always relative; without a functional datum, it has no real meaning in the assembly.

A prismatic parts controls a surface between two parallel planes. 

An axial part controls a cylinder within a cylindrical tolerance zone.

The Engineering Perspective

Similar to flatness, parallelism is one of the most commonly misused controls in GD&T, but when it's applied intentionally, it's a powerful tolerancing tool. 

👎 Where it goes wrong

Most parallelism misuses occur as a result of skipping one important question: what functional relationship am I trying to protect? 

If you don't ask that question beforehand, here are some of the common failure patterns you'll see. 

• Using parallelism when flatness is the real requirement (for when you care about surface quality, not orientation) 
• Calling parallelism to a non-functional datum (if the datum doesn't reflect how the part is located in assembly, the control is meaningless) 
• Over-constraining multiple surfaces (stacking parallelism callouts across multiple features increases cost without improving function) 
• Designing for inspection instead of function (just because you can measure it doesn't mean you should control it) 

👍 When it goes right

Parallelism should only be used when orientation directly affects function (e.g., linear guide rails with sliding interfaces, sealing surfaces where gap consistency matters, or multi-part stacks where alignment drives performance). 

Let's use an example. 

A bearing seat must remain parallel to a mounting face to prevent uneven load distribution.

That’s a true functional requirement—and a valid use of parallelism.

If orientation doesn’t impact function during assembly or operation, parallelism probably isn’t the right control.

A decision guide like the one below will help you determine which geometric control your part actually needs. 

It all starts with the datum strategy

Parallelism without a solid datum structure is just noise on a drawing.

Your primary datum needs to control where the part actually "sits" in the assembly.  Your secondary and tertiary datums need to constrain orientation and rotation. 

• Bad datum: parallelism to a cosmetic or non-contact surface

• Good datum: parallelism relative to the actual mounting interface

You’re not controlling “parallel surfaces.” You’re controlling how variation propagates through an assembly. If your datum doesn’t reflect reality, your tolerance doesn’t either.

This is especially important for inspection. Parallelism is only as good as your ability to measure it correctly. Common inspection methods include a surface plate and indicator (for simple cases) or a CMM (for complex geometries). 

If inspection can't replicate your datum structure, your parallelism isn't measurable, which means it's not controllable. This is where things really start to break down: 

• Poor datum simulation during inspection
• Part deformation during clamping
• Measurement taken relative to the wrong reference 

Final thoughts

Parallelism looks simple on a drawing; it rarely is in production. It also has massive implications on a part's final cost:

• Multiple setups required to maintain datum alignment
• Precision fixturing to simulate datums accurately
• Grinding operations for tight tolerances
• Increased inspection complexity (often requiring CMMs)

Holding tight parallelism relative to a datum often means the part must be carefully located, minimally distorted, and precisely re-referenced across operations.

Turns out, it’s incredibly expensive to achieve tight parallelism, especially on complex parts.

If you're designing parts with parallelism controls, keep these design guidelines in mind: 

✅ DO

• Tie parallelism to functional datums
• Use it only when alignment matters to function
• Think in terms of assembly behavior, not isolated features
• Evaluate manufacturability before tightening tolerances

⛔ DON'T

• Use parallelism as a substitute for flatness
• Stack redundant controls across multiple surfaces
• Apply orientation controls without a clear datum strategy
• Ignore inspection feasibility

Every time you add a parallelism callout, ask yourself: what failure am I preventing—and is this the best way to prevent it? 

And if you made it this far, here are some more resources that may help on the datum and technical drawing side of things: 

• Anatomy of an Engineering Drawing
• 10 GD&T Best Practices from our Engineering Team
• Tolerances Cheat Sheet 📄
• Technical  Drawing Checklist 📑

Was this email forwarded to you? Sign up here to receive our monthly newsletter. 

We created Tolerance Stack to help engineers who design with microns in mind and understand that manufacturability is just as critical as innovation.

Whether you're optimizing a part for 5-axis milling, selecting materials for a Class III medical device, or navigating the complexities of GD&T, Tolerance Stack delivers the insights you need to make confident, production-ready decisions.