The Prototype-to-Volume Playbook

Five phases from prototype to a line that holds.

Hardware programs rarely stall because the engineering is wrong. They stall in the gap between a prototype that works and a line that holds at volume. This is the method I use to get programs through that gap — built over a decade of launches across automotive, consumer electronics, and robotics.

PHASE 1

Assess

// Understand before changing.

Every struggling program wants you to start fixing on day one. Don't. The first job is building an accurate mental model of how the process actually works — not how the documentation says it works.

Walk the line before you touch it

The first time I walk a line, I'm not solving anything. I'm following the product from where it enters to where it leaves: the major process steps, the inspection gates, where defects escape. I watch the operators — the workarounds, the hesitations, the tribal knowledge. I follow the material and note where inventory piles up and whether the buffers are intentional or hiding problems. And I compare the SOPs and work instructions against what people actually do.

When reality and the documentation don't match, trust reality.

Then I ask operators one question: "If you could change one thing about this station tomorrow, what would it be?" That answer is usually worth more than another hour of observation. Operators know where the real problems are long before the dashboards do.

Establish a real baseline

Before changing anything, baseline the process across safety, quality, delivery, equipment, cost, and — the one most teams skip — process stability. If you don't understand variation, you'll spend months chasing noise instead of solving problems. Without a baseline, you can't know whether your changes are improving anything or just moving it around.

PHASE 2

Diagnose / Sort

// The right problems, the right owners, the right order.

Most production problems get treated as one big pile. That's why teams stall. The breakthrough usually isn't a fix — it's a sort.

Sort by source

A failure traces to one of four sources: the design, the process, the supplier, or operator execution. Naming the right bucket determines the entire fix path. Process problems — fixtures, tooling, station layout — get fixed inside the four walls of the factory, fast feedback, tight loop. Design problems mean going back to engineering: a slower conversation about what manufacturability actually requires. Mix them into one backlog and both stall.

And not every issue needs a heroic engineering solution. Sometimes the answer is retraining, an SOP clarification, or operational discipline. Reaching for a redesign when the real gap is execution wastes months.

Contain first, optimize second

Before chasing the perfect long-term fix, stabilize. Put containment in place to protect the customer, then investigate without production pressure. Teams that skip this end up firefighting while trying to debug.

Stabilize → diagnose → permanently fix. Never all three at once.

Prioritize by impact, not count

Safety first, then customer-facing quality, throughput constraints, cost, and finally cosmetics. A defect affecting 0.1% of units that shuts down production outranks ten cosmetic issues customers never see. The goal isn't closing the most tickets — it's removing the biggest constraints. And keep asking "why" until the corrective action changes from containment to prevention: a recurring defect is evidence, not the root cause.

PHASE 3

Structure the team

// Build operating mechanisms, not dependency on yourself.

No single function ever has the full picture. Process, quality, automation, design — each sees a slice. The job is getting each function working the right list, with ownership that can't fall into the gaps between teams.

Ownership singular, support shared

Every issue gets one directly responsible owner, even when five functions contribute to the solution. Accountability can't be a committee. Deliverables, due dates, and decision owners get defined before the work begins.

Ambiguity creates delays. Clarity creates momentum.

Resistance is a signal before it's a problem

When a function pushes back, they're usually protecting a legitimate constraint, working from different data, or optimizing for a different incentive. Most resistance isn't personal — it's a disagreement about risk. Surface the constraint, align on the data, frame the tradeoff. If consensus still isn't possible, escalate the decision with a clear recommendation — not the conflict.

The test of this phase: the work keeps moving whether or not you're in the room.

PHASE 4

Execute

// A cadence that makes the program measurably different every week.

Every sync answers four questions

  • What did we accomplish since the last sync?
  • What issues came up — what's blocking?
  • What support is needed to clear them?
  • What's the plan for next, and who owns it?

That structure forces progress, surfaces blockers, and assigns forward action every single time. No status theater.

Communicate at the altitude of your audience

The team needs task-level detail. Executives need to know five things: what changed, the key metrics, the risks, the decisions needed, and whether we're still on schedule. Report status, risks, and decisions — not activity.

Close the loop

Every action item moves to done, becomes a risk, or generates new learning. Nothing disappears into meeting notes.
PHASE 5

Validate & hold

// Make it stay solved after you've moved on.

Validate at production scale, not pilot scale

A successful trial demonstrates possibility. A successful production run demonstrates capability. A fix has to survive normal production — multiple shifts, operators, equipment, and material lots, at sustained volume — before the issue is closed. And validate the side effects, not just the fix: a temporary solution that improves throughput today can create instability tomorrow. Temporary fixes that don't hold are debt, not progress.

Standardize before declaring victory

Every corrective action has predefined exit criteria: the fix validated, the baseline improved, the SOP updated, the team trained, recurrence monitored. A fix isn't complete until it's repeatable without engineering standing beside the line.

Leave the system stronger than you found it

A clean handoff means the knowledge doesn't leave with you: documentation current, owners identified, open risks written down, and the team able to monitor the process without outside support.

If the line depends on me after I'm gone, the job isn't finished.
Put it to work

Heading into this stretch on a real program?

This is the method. Applying it to your specific line, team, and timeline is the work. If you're staring down the gap to volume, let's talk — 30 minutes, and you'll leave with my read on your situation either way.

Book a call → or follow the writing — I break each phase down further there.