A permitting team runs a zoning check and a fire-safety check in parallel when they're independent, but runs them sequentially when the fire-safety check needs the zoning outcome as an input. What principle explains why the team switches patterns between cases?
Select an answer to reveal the explanation.
Short Explanation
You wouldn't try to frost a cake before it's baked, even if frosting is the faster step — order matters when one step genuinely needs the other's output. Letting the real dependency between tasks drive the pattern, rather than defaulting to one approach out of habit, is exactly what keeps a workflow correct.
Full Explanation
The governing principle is dependency-driven design: when fire-safety review genuinely needs the zoning outcome, sequential execution is correct because running them in parallel would have fire-safety evaluating incomplete or missing input; when the two checks are independent, parallel execution is correct because there's no reason to force one to wait on the other. Defaulting to parallel execution purely to save cost ignores cases where a real dependency exists — forcing independence onto tasks that aren't independent produces wrong or incomplete results, which costs more to fix than the compute saved. Defaulting to sequential execution for everything wastes time on truly independent tasks that could run concurrently, treating caution as free when it actually has a latency cost. Choosing the pattern based on team familiarity with a framework optimizes for developer comfort rather than for what the workflow's actual data-flow requires, which can produce a pipeline that's easy to build but structurally wrong. Scope note: dependency analysis should happen per task pair, not once for the whole workflow — a pipeline can mix sequential and parallel stages, as this permitting example does. Operational check: for each pair of stages, ask whether one's output is required as the other's input; if yes, sequence them, if no, parallelize them.