Critical Path Analysis for Prototype Builds With Mixed Processes
Parallel manufacturing paths need different critical path analysis than single-process builds.

EVT, DVT, PVT. Three stages, three different bottlenecks, and most programs plan them as if the same rules apply across all three. Most programs plan the three stages as if the same rules apply across all of them, but they do not. Critical path analysis tells hardware teams which manufacturing steps set the floor on how fast a prototype build can move, and which ones have slack to spare. Get that distinction right on a mixed-process build and you ship on schedule. Ignoring it means finding out, three weeks before a design review, that a casting nobody was watching just became the whole problem.
CPM (critical path method) finds the longest chain of dependent tasks in a project. That chain sets the minimum time the whole build can take, full stop. Tasks on it have zero float: they can't slip a day without pushing the finish date back by the same amount. Everything else carries some float, some cushion, and can start late or run long without touching the end date. CPM answers three questions that matter to anyone running a build: which tasks can't move, where people or machines can get reassigned without risk, and what the real minimum duration looks like for the whole program. The math runs in two passes, a forward pass (earliest finish equals earliest start plus duration) and a backward pass (latest start equals latest finish minus duration). Float is just the gap between them.
What makes mixed-process prototype builds structurally different from single-process jobs
A single-process job, say everything gets CNC'd at one shop, behaves like a queue. One line, one bottleneck, one thing to watch.
Mixed-process builds don't work that way, and treating them like a bigger version of a single-process job is exactly where most schedules start bleeding time. A single BOM might call for CNC machining, sheet metal, cast parts, carbon fiber layup, tube bending, custom springs, urethane casting, wire EDM, and two or three finishing steps, all running at different shops, on different equipment, with different lead times and different failure modes. A machined bracket and a cast housing don't share a bottleneck just because they end up bolted into the same assembly.
Sort the tasks into three buckets. The main path is the primary sequence of operations that defines the structural or functional core of the part. The feeder path is where something built elsewhere gets inserted into the main path at a specific point: custom springs, gaskets, tube bends feeding into a housing assembly are the classic case. A rework path appears when a batch fails inspection, gets pulled, reworked, and reinserted at or before the point it left the line. Castings and composite layup are among the more yield-sensitive processes in a mixed-process build, and a rework path for them needs to exist in the plan from day one. Bolting one on after the first failed batch is already too late.
Putting those three pieces together turns CPM for a mixed-process build into a map of parallel feeder paths that all have to land at the same merge points, on time, or the whole build stalls.
Mapping the dependency graph for a mixed-process prototype BOM
Start by writing down every manufacturing task on the BOM, including the machined parts everyone remembers to track and everything else besides. Finishing operations, anodizing, heat treatment, assembly steps, inspection hold points: all of it goes on the list. Skipping the boring stuff causes the model to break later, usually at the worst possible moment.
From there:
- Classify each task as main path, feeder path, or rework path.
- Establish predecessors for every task. Powder coating can't start until welding's finished. Spring installation waits on a machined and deburred housing.
- Watch castings specifically. A casting has to arrive before any secondary CNC work on it can begin, so casting lead time belongs on the critical path as its own line item, never folded into a generic "fabrication" bucket.
- Give every task a real duration estimate. CPM runs on numbers, not moods. A task pegged at "somewhere between two days and two weeks" isn't an estimate, it's a guess wearing an estimate's clothes, and it wrecks the model's accuracy the moment two or three of those guesses stack on the same path.
How long each process takes and what that means for where the critical path runs
Material procurement sets the critical path more often than fabrication does, and it isn't close. Domestic material procurement lead times for common steel forms routinely run from several weeks to several months depending on the grade and form factor. Specialty metals and exotic alloys run longer still, since the supplier base for them is thin. The critical path frequently runs straight through the mill, not the machine shop. Compliance-driven sourcing, code-rated structural steel, traceable aerospace alloys, piles engineering paperwork on top of that: stress analyses, weld procedure qualifications, inspection hold points, all adding time before a single chip gets cut.
Leading domestic sheet metal shops can turn standard-complexity prototypes around in days. International ocean freight adds weeks of transit on top of that, and that's the math that matters when an offshore quote looks cheaper on paper but the schedule says otherwise. Carbon fiber rapid prototypes, pultrusion or filament winding plus the needed CNC work, can turn around in a matter of days under the right shop conditions. CNC machining of cast parts depends entirely on when the casting arrives: the machining itself might take a day, and none of that matters if the casting takes six weeks to land.
At program level, the cycles stack up fast. EVT runs 6 to 12 weeks. DVT runs 8 to 16 weeks once full compliance and reliability testing get folded in. PVT runs 4 to 10 weeks covering ramp validation and pilot builds.
Float only means something relative to the longest path in the whole network. A part that machines in two days can still carry zero float if it feeds into a casting arriving in week six. Fast doesn't mean safe. Slack is a property of the network, not of any single task sitting inside it, and a fast task feeding a slow one inherits the slow one's urgency whether anyone planned for that or not.
Where DFM decisions before fabrication starts shift the critical path
Most engineers treat DFM (design for manufacturability) as a way to catch errors before they turn into scrapped parts. Fair enough, but that framing undersells the scheduling damage. A DFM failure that becomes visible after fabrication has already started doesn't just cost material. It creates a rework path that never existed in the original network, and that path eats calendar time nobody budgeted for.
Design work gets credited with setting around 80% of a product's life-cycle cost, and the scheduling version of that figure holds up just as well: choices made at the design stage set a large share of the minimum build duration, long before a single PO goes out. A prototype can run perfectly on the bench and still fail in the field because a weak point never got flagged, and in a mixed-process build the sharper cost is that the failure gets caught late. Late failures always cost more calendar time than early ones.
DFM splits into two stages. Process selection comes first: CNC versus casting versus sheet metal versus carbon fiber for a given part. Get that wrong and the part can't hit the tolerance or geometry the design calls for, no matter how well the chosen process gets run afterward. Getting that decision wrong means every downstream step is affected, since no later process fix can correct a part that can't hit the required tolerance or geometry. Then comes intra-process manufacturability review, checking feasibility inside whatever process got picked. Sheet metal has a well-known rule here: flange length should run at least four times material thickness (the 4t rule) to hold angle consistency and avoid an unstable grip in the press brake. Violate that, and the part scraps and reruns from scratch.
How to calculate float and identify which tasks can be compressed
Float is LF minus EF, or equivalently LS minus ES. Zero float means critical: no room, no slip. Positive float means exactly that much scheduling room exists before the task starts threatening the end date.
The forward pass walks from the first task in the network to the last, calculating earliest start and earliest finish at every node. Whichever chain comes out longest is the critical path. The backward pass runs the other direction, from the project's end date back through every path, calculating latest start and latest finish. Any task where latest start equals earliest start has zero float. Those tasks are critical whether or not they sit on what looks like the main path, and most program managers miss that a feeder task can be more dangerous than half the tasks sitting on the headline sequence.
What float actually buys a program manager on a mixed-process build:
- A feeder task with plenty of float, custom spring fabrication, say, can get ordered later without touching the schedule. No reason to rush it or pay an expedite fee.
- A feeder task with float close to zero is critical in every way that matters, even if it never touches the main path.
- Rework eats float first, wherever non-critical tasks have some to spare. Once that float runs dry, rework pushes the project end date directly, no cushion left to absorb it.
How sourcing structure, consolidated vs. fragmented vendors, interacts with critical path risk
Every handoff between vendors is a node in the dependency graph, and every node adds time. A part waiting in queue between a machining shop, a finishing shop, and an assembly house accumulates dead time on the critical path, and that dead time appears on the project schedule only after it has already blown the date.
Consolidating those processes under one supplier typically cuts total lead time by 20 to 40%, mostly because parts stop sitting in queue between vendors and stop traveling between facilities running on different schedules. Consolidation is the right default for a schedule-constrained prototype build, not a nice-to-have. Beyond the raw time savings, it keeps institutional knowledge about the part in one place, runs a single quality system across every operation instead of three separate ones, skips re-inspection at each handoff, and avoids the classic failure where a downstream vendor quotes off the wrong BOM revision because nobody synced up.
None of that comes free. Single-sourcing means single-source failure risk, weaker pricing leverage, and the slow creep of supplier complacency once a vendor knows it isn't getting shopped around. Those are real risks, and the fix for them is picking financially stable, certified partners, building in contingency plans, and writing performance-based contracts that keep incentives lined up, not fragmenting the sourcing back out. Fragmenting to dodge single-vendor risk usually costs more calendar time than it saves in leverage, and calendar time is the one thing a prototype program can't buy back.
How prototype stage (EVT, DVT, PVT) changes the critical path and the location of schedule risk
EVT builds, typically a small number of units, run on speed and learning, not production fidelity. The process mix leans heavily on 3D printing technologies such as SLA with selective CNC work layered in where it matters. The dependency network stays shallow, since fewer processes are in play, and the critical path tends to run through design finalization and first-article iteration rather than long-lead procurement. Nobody's waiting on a casting yet.
DVT builds, covering a larger unit count than EVT, need hardware that behaves like the real thing, and that's where the network gets teeth. SLS and MJF cover plastics, CNC covers the metal parts, and urethane casting often bridges the gap between prototype tooling and production tooling. Compliance and reliability testing appear as nodes in their own right at this stage, each with a duration that has to get planned for instead of assumed away. Schedule risk shifts here, from design iteration to procurement and test, and treating DVT like a bigger EVT build is how programs blow their timeline. The teams that get burned are the ones still budgeting DVT schedules off EVT instincts, expecting design risk when the real risk moved to the supply chain months earlier.



