Skip to main content

Amdahl’s Law and Parallel Work

flow
teamwork
productivity
continuousIntegration
Dividing work can enlarge the serial part, while the parallel stage lasts from the first start to the last finish. Either can consume the saving.
Published

November 28, 2026

If four people each take a quarter of the work, shouldn’t it be done in a quarter of the time?

Sometimes we get a very nice improvement. Sometimes we get four busy people and a delivery date that keeps moving away.

I explored this in Shouldn’t It Be Faster? at Industrial Logic. That blog is a reasonable introduction to Amdahl’s Law and certain pitfalls we face when trying to parallelise the work of humans.

A team is not a multi-core CPU. People are not computers. But that doesn’t mean that Amdahl’s Law is not applicable. It just means that we have to consider context.

For a process arranged as successive serial and parallel stages, elapsed time is the sum of those stages. Each parallel stage lasts from its first start to its last required finish.

Dividing the work adds coordination and integration effort. Where that effort must precede or follow the divided jobs, it enlarges the non-parallel part.

The parallel stage lasts from the start of the first job to the completion of the last job in the set. Whatever extends that time, all the delays and interruptions, can cause the parallel section to be longer than if it had been serialized.

However, it seems that we should be able to win this game. Parallelism is a powerful technique and handling it well should give us a big advantage.

The part we can divide

Suppose a job takes ten hours. One hour at the front and one hour at the end must happen in sequential time.

Say the remaining eight hours can be divided into four entirely independent pieces.

With capable workers, all available immediately, those eight hours might take only two hours of elapsed time. The two serial hours still take two hours.

The job takes four hours. That’s a 2.5-fold speedup.

Two stacked timelines: ten hours with one lane, four hours with four ideal lanes. Both retain two serial hours.
Figure 1: The baseline has two serial hours and eight divisible hours, totaling ten. With four ideal parallel lanes, the divisible portion takes two hours, and the total is four.

The usual fixed-work form of Amdahl’s Law is:

\[ S(N) = \frac{1}{(1-p) + p/N} \]

Here, \(p\) is the fraction of the original execution time that can benefit from parallel execution. \(N\) is the number of ideal parallel workers, and \(S(N)\) is the speedup of the whole job. This assumes the same work, perfect division of the parallel portion, and no added overhead. Cornell’s explanation walks through the derivation.

In this example, \(p = 0.8\).

Ideal parallel workers Elapsed hours Overall speedup
1 10 1.00×
2 6 1.67×
4 4 2.50×
8 3 3.33×
16 2.5 4.00×

Even unlimited parallel capacity cannot get this unchanged job below two hours. The speedup approaches five times the original rate.

Calculated Amdahl curves for 80 and 95 percent divisible work. At sixteen workers, speedups are 4 and 9.14 respectively.
Figure 2: With 80 percent divisible work, ideal speedup rises from one at one worker to four at sixteen workers, approaching a five-fold ceiling. A second curve with 95 percent divisible work reaches 9.14 at sixteen workers.

Making the serial part smaller can change that limit. Adding more workers to the divisible part cannot.

People aren’t processors

This is a model of executing a fixed computation. Software development involves discovery, judgment, and changing our minds.

The simple equation doesn’t represent delayed starts, interruptions, communication between people, or status reporting. Those are crucial to our comparison. Computer systems can also have scheduling delays and communication overhead; the ideal arithmetic leaves them out rather than making them disappear.

We can’t count developers, substitute that number for \(N\), and announce a delivery date. Nor can we infer \(p\) from the percentage of tickets labelled “coding.”

The useful question is: which time on the route to a usable result actually gets shorter when we divide the work?

Amdahl’s model makes us identify the part we expect to improve. It doesn’t establish how much parallelism a particular team can achieve, or whether pairing would improve that team’s work.

For our practical decision, the alternative is two or three people collaborating on the whole job. The split must save enough time to cover its additional planning, communication, status reporting, integration, and disruptions, and still beat that alternative. Those comparisons need observation.

We can enlarge the non-parallel part

There is another catch. Dividing the job can create work that wasn’t in the original ten hours.

Before the divided jobs can start, we may have to negotiate interfaces, decompose the work, and arrange assignments. Afterward, we may have to assemble the results, reconcile incompatible assumptions, and verify the whole. To the extent these activities must precede or follow the divided jobs, they enlarge the non-parallel part of the process.

Those costs need their own accounting. They aren’t magically included in a fraction measured before we changed the process.

Robert G. Brown’s parallel-performance treatment explicitly adds setup, communication, and idle-time costs to the simple model.

For a simple process with preparation before the divided jobs and final integration after them, we can account for the elapsed time as:

\[ T_{\text{split}} = B + E + A \]

\(B\) is the time before the first divided job starts. \(E\) is the elapsed interval from the first start to the last required completion. \(A\) is the remaining time to integrate, verify, and finish afterward.

In our ten-hour example, the original serial time totals two hours. Four ideal lanes reduce the eight-hour portion to two hours, giving us four hours overall. If division and final integration add three more hours outside that stage, we now take seven. If they add six, we’re back to ten. Add more and the split loses time, even with perfect parallel execution.

For this simple arrangement, the split wins only when the saving inside the divided-work stage exceeds the extra time outside it.

This is elapsed-time accounting, not a sum of person-hours. If preparation or integration overlaps the jobs, count that time once, where it occurs on the timeline. More complex workflows need their actual dependency schedules. These are illustrative calculations, not measured team data.

The parallel stage is first start to last finish

The clock for the parallel stage starts when the first divided job starts. It stops when the last required job is actually complete, including any corrections needed for that piece to be accepted. It keeps running when one worker is waiting, interrupted, or doing something else.

Time between assignment and the first start still counts toward delivery; it falls before this interval. Unfinished integration after the last piece falls after it. Moving a delay across those boundaries doesn’t make it disappear.

Imagine four independent pieces, each needing two hours. They are assigned together, but one specialist can’t start until hour six.

Two schedules of four two-hour pieces. All start together and finish at hour two; one delayed start moves completion to hour eight.
Figure 3: Four two-hour tasks finish at hour two when all start together. If the fourth waits six hours, the last task finishes at hour eight. In this example, final integration waits until all four pieces are ready.

The gathering point is governed by the last required result. Closing three tickets early doesn’t move that point. The stage took eight hours, even though each job needed only two hours of active work.

Now combine the two ways to lose. Keep the original two serial hours, add three hours for division and final integration, and let the supposedly parallel stage stretch to eight hours. Our ten-hour job now takes thirteen hours.

Everyone can have worked quickly on their own piece, and we can still have made delivery slower.

This timeline shows only the divided-work stage. Any required work before or after it extends the delivery time further.

My Scatter-Gather article illustrates another important detail: the workers can be busy with other jobs while this feature’s pieces occur at different places in their individual queues. The feature is waiting even when nobody is idle. The interval we must shorten belongs to the feature, not to an individual’s task list.

How we lose time inside the parallel stage

We need to distinguish work that cannot overlap under the present constraints, work that could overlap but doesn’t, and work that overlaps without saving much time. All three can spoil our plan, but they call for different improvements.

A blocker is a cause of delay: it can prevent a job from starting or interrupt one already underway. It isn’t another duration to add to the interruption or wait it causes. The examples below explain why the interval stretches; they aren’t separate penalties to sum.

Two jobs, one worker

Suppose two independent jobs each require two hours of a person’s active attention. Assign both to the same person and they need four hours of that person’s time. Alternating between them doesn’t create a second worker.

The jobs might be logically independent, but their staffing makes them compete. The same applies when several jobs need the same reviewer, test rig, or exclusive environment.

Suppose we divide a job into seven pieces. One needs eight hours; the other six need one hour each. We assign the eight-hour piece and one of the one-hour pieces to the same worker, and distribute the remaining five among five other available workers.

That worker has to serialize their two pieces. Even if everybody starts immediately, with no interruptions or rework, their assigned work needs nine hours. The other five workers finish at hour one, but the divided-work stage cannot finish before hour nine.

For this illustration, suppose the same work would have taken fourteen hours without the split, and the durations don’t change when we divide it. Our best possible saving inside the stage is five hours. That is the entire budget for the additional division and final integration if we want to break even.

That fourteen-hour baseline is an arithmetic assumption for this example. It doesn’t tell us how long two or three collaborators would take. The split must beat their actual alternative, including a reasonable allowance for disruptions, before we can call it a practical win.

Added division and integration time Earliest overall completion Compared with fourteen hours
2 hours 11 hours 3 hours saved
5 hours 14 hours No saving
6 hours 15 hours 1 hour lost

The two jobs could be done in either order, but changing their order doesn’t reduce their combined nine hours. Adding another worker helps only if some of that work can actually be transferred or divided. The question is whether we can finish the last worker’s required work soon enough to pay for the split.

There is a substantial literature on scheduling around these constraints. For example, Povéda, Alvarez, and Artigues (2023) explicitly model worker skills, calendars, precedence, and which activities can be interrupted. A list of assignments isn’t yet a feasible schedule.

One job needs another’s result

If B needs a result from A, that part of B must wait for that result. Adding people to B doesn’t make A’s result arrive earlier.

Sometimes B needs only part of A’s output, so some overlap is possible. We need to identify the actual information dependency rather than automatically waiting for the whole ticket to close.

The critical path is the longest chain of dependent work. The work-and-span model makes this limit explicit: even unlimited workers cannot finish a fixed computation sooner than its longest dependency chain permits. In development, we also have to account for resource conflicts and waits, which can extend the schedule beyond that bound.

The worker isn’t available, or becomes unavailable

Someone may have the necessary skill but be on another job, on leave, or waiting for access. The work is ready; its worker isn’t. A task requiring several people together needs a common period of availability.

Availability can also change after the work starts. Someone is pulled into an incident, becomes ill, or is reassigned. Their piece pauses while the clock for the parallel stage keeps running.

For example, all four two-hour jobs start together. One worker completes an hour, becomes unavailable for four hours, and then returns to finish the remaining hour. The other jobs finish at hour two; this one finishes at hour six. The parallel stage takes six hours, despite everyone having been available at the start.

Handing the job to someone else may help, but the replacement needs enough understanding to continue and verify it. Shared knowledge, recoverable work, and someone able to take over give us options. A name on a ticket doesn’t guarantee continuing capacity.

That makes personal queues, competing priorities, and calendars part of the delivery timeline. It also means an idle developer doesn’t necessarily provide capacity for a job requiring a different skill or authority.

These are constraints of our current arrangement. We may be able to change assignments, share knowledge, or remove an access restriction. They aren’t necessarily inherent properties of the work.

The pieces aren’t the same size

Divide eight hours into four independent, indivisible jobs of five, one, one, and one hour. With four suitable workers starting together, the stage takes five hours. It cannot take the two hours suggested by dividing eight by four.

The five-hour piece sets the finish. Splitting it further might help, if it really can be divided independently. Just adding people doesn’t establish that.

The Lawrence Livermore parallel-computing tutorial treats load imbalance and synchronization as distinct performance concerns. Unequal pieces can run in parallel; they simply don’t give us perfectly balanced parallel execution.

Work comes back

A piece isn’t finished merely because someone submitted it. Failed tests, review findings, and incompatible assumptions can send it back through development and verification. Other pieces may need to change too.

There is a particular risk when B starts using a preliminary result from A. If A changes, some of B may need to be redone. Loch and Terwiesch’s concurrent-engineering model (1998) weighs overlap savings against rework and communication time.

Their subsequent study of 140 electronics-development projects (1999) found that resolving uncertainty early influenced the benefit of overlap. This is evidence from product development, rather than a software-team speedup formula, but it gives us a useful question: how stable is the information we’re asking someone else to build on?

One implementation changes another job

There is a more troublesome interaction than waiting for a known prerequisite. Implementing A can reveal something that changes B, even though we planned to develop them independently.

For example, implementing authorization might reveal that the operation needs a tenant identifier. That discovery changes the API, the client, and the audit record. Some of those pieces may already have been declared complete.

Now they need to be reopened, changed, and checked together. A change in B may reveal another consequence for A. We have a feedback loop across the divided work, rather than a fixed sequence of independent jobs.

The loss can be larger than the effort of making the extra edits. People may have moved on, so we must regain their availability and understanding. Earlier tests and integration results may no longer establish that the changed combination works.

This can hurt both parts of our accounting. Discovered during the jobs, it can push out the last required completion. Discovered during final integration, it can enlarge the time spent reconciling the pieces. Count that time once, wherever it occurs; calling it an integration problem doesn’t make it disappear.

Cataldo and Herbsleb’s software study is relevant here: coordination needs evolve with technical dependencies. The authorization example is illustrative, but the risk of treating those dependencies as fixed is central to their research.

We can look for shared decisions before splitting, bring uncertain interactions together early, and integrate small changes while the people involved still have the work in mind. When every discovery in one piece keeps reopening the others, that is evidence to reconsider the division itself. Those pieces may be better developed together until the shared decision settles.

Other constraints worth looking for

Constraint How it limits the saving
Shared mutable state Two changes to the same underlying state may require an order or reconciliation. Separate files don’t guarantee independent changes.
Required gathering points A test, decision, or release may require several results together. Early finishes wait for the last required result.
Limited shared capacity Parallel producers can converge on a constrained review, build, test, or deployment service.
Pieces too small to justify the split Assignment, setup, communication, and assembly can consume the saving from dividing the work.
Required uninterrupted time A free half hour is insufficient for a step that needs an uninterrupted two-hour window.
Unknown or changing dependencies Discovery can reveal that supposedly independent jobs need to exchange results or revise a common decision.

The computing examples of state dependencies, synchronization, and granularity are discussed in the Livermore tutorial. The software examples here are applications of those mechanisms, not measured equivalences between developers and processors.

Finding out where everything stands

Divided work also creates a status-reporting job. Someone has to find out which pieces have started, which are waiting, which have passed verification, and which have been reopened. Updates, dashboards, meetings, and chasing answers take effort from the people doing and coordinating the work.

That effort can extend the schedule when it takes people away from required work, or when decisions wait for an accurate picture of progress. Coordination can itself compete for a specialist’s availability.

A whole outcome being developed together still needs coordination and reporting. The comparison is whether scattering its status across people, queues, and branches adds a burden that the collaborative approach avoids. Count the elapsed consequences once on the timeline, and count the reporting effort in the labor comparison too.

Dependencies also change as we learn. Cataldo and Herbsleb’s study of two software projects (2013) found that gaps between required and actual coordination were associated with more failures, while better alignment was associated with improved productivity. Drawing module boundaries doesn’t remove the need to notice and manage dependencies.

For each delayed job, ask: what result, person, shared resource, decision, or correction is it waiting for? Then ask whether that constraint is necessary, or something about the way we’ve organized the work.

The bricks can be finished before the building works

Completing the separate pieces doesn’t establish that they work together. If we defer that discovery until final integration, the finishing stage still contains uncertain work.

Brun and colleagues (2011) studied nine open-source systems and found conflicts beyond overlapping text edits: changes could merge but then fail to build or pass tests. A clean merge isn’t evidence of a working combination.

Vale and colleagues (2022) examined about 81,000 merge scenarios and surveyed 140 developers. Dependencies involving both conflicting and non-conflicting code contributed to the difficulty of resolution. Integration requires understanding the changes, not merely removing conflict markers.

There is a quality risk too. In Brindescu and colleagues’ study of 143 projects (2020), code associated with merge conflicts was about twice as likely to be associated with bugs. This is an observational association, not proof that delaying integration doubles defects.

These studies support treating final integration as substantive work with uncertain cost. They don’t establish a fixed penalty for each day we postpone it, or a numerical advantage over two or three collaborators. For our comparison, however, “all the pieces are done” is plainly too early to stop the clock.

Can we plan our way out of this?

Looking at these risks, we might decide to spend more time up front: settle every interface, anticipate interactions, balance the assignments, and secure everyone’s availability.

But that preparation enlarges the non-parallel part. We are spending some of the possible saving before the parallel jobs even start.

Can that win? Yes, if the added preparation prevents more elapsed delay than it introduces. Suppose two extra hours of preparation remove four hours from the first-start-to-last-finish interval, with everything else unchanged. We gain two hours. If they remove only one hour, we lose an hour.

The cost is incurred before we know whether the hoped-for saving will materialize. Planning may resolve an uncertainty, but implementation can still reveal something we didn’t anticipate, and availability can still change.

There is also a limit to what remains available to save. In our ten-hour example, perfect parallel execution already leaves only two hours inside the divided-work stage. More preparation cannot reduce that stage below its feasible minimum. Every extra serial hour uses more of the margin that could have made dividing the work worthwhile.

Expanding the non-parallel part can help us win, but it raises the saving we must achieve elsewhere. We shouldn’t mistake a more orderly parallel stage for an earlier delivery.

Before paying for more preparation, ask what specific delay it is likely to prevent. Could we instead make the split simpler, reduce the size of the outcome, or work through the uncertain interaction together? Those options also have costs, but they may require less advance coordination.

How can we win the parallel game?

The two realizations suggest two kinds of improvement: keep division and integration inexpensive, and shorten the interval from first start to last finish.

For the same usable outcome, at the same required quality, separately scheduled split work finishes sooner than working together when:

\[ B + E + A < T_{\text{collaborating}} \]

Here, \(T_{\text{collaborating}}\) is the elapsed time for two or three people to complete the whole outcome together at the same required quality. It isn’t the sum of estimates for solo tasks, divided by the number of collaborators. We need evidence from how the people actually work. Count preparation, communication, reporting, interruptions, verification, and finishing on both sides.

For a decision made before starting, an ideal-case advantage isn’t enough. The expected speedup must leave enough margin that, under credible delayed-start and interruption scenarios, the split still finishes sooner. A split that wins only if everybody starts immediately and nothing interrupts them has not made a convincing case.

This is confidence based on observed conditions, not a guarantee against every possible disruption. If the comparison is too close to call, the ideal equation gives us no reason to be sure that splitting will help.

The conditions that make this inequality easier to satisfy are quite concrete:

Favorable condition What it gives us
Substantial independent work Enough work can actually overlap to produce a useful saving. Necessary inputs and shared decisions are sufficiently settled.
Inexpensive division Useful boundaries are easy to identify and explain, without extensive advance design or assignment work.
Suitable people available together Jobs can overlap in practice, with few competing priorities, personal queues, or exclusive-resource conflicts.
A manageable longest workload No worker’s combined assignments or dependency chain consumes nearly the whole serial duration. Exact equality between pieces isn’t required.
Cheap communication and integration People can resolve questions quickly and combine small changes frequently, keeping final assembly short.
Limited propagation of changes Discoveries and defects usually stay local, rather than repeatedly reopening other pieces. Fast feedback helps reveal when this assumption is wrong.
Capacity to adapt When someone becomes unavailable or a piece grows, others can help or take over at an acceptable handover cost.

Each condition protects the margin between the possible saving and the cost of obtaining it. None requires perfect foresight or zero overhead; we need enough saving left after the actual costs.

In Scatter-Gather, I suggest gathering the people around a whole outcome. They can still divide work, but with a common priority, direct communication, and frequent integration. This gives us a way to address both losses together, rather than paying for increasingly elaborate advance coordination of separate schedules.

My Progressive Admission Pattern gives us one concrete way to proceed. Start with an end-to-end system that explicitly rejects unsupported cases. Then admit one input shape or behavior at a time, implementing and testing its whole path. The first closed skeleton establishes the path; subsequent admissions make it useful without waiting for every planned case.

This fits DORA’s guidance on small batches and frequent integration. DORA also warns against making small batches and then gathering them into a large batch for downstream testing or release. Our admissions should remain integrated and testable, with deployment and feedback as appropriate. An admission may build on earlier admissions; it doesn’t have to be an independently schedulable job.

For this approach, two or three collaborators can complete the next admission together, dividing work briefly where it helps. We can exploit useful overlap while keeping the amount of work awaiting integration small. That changes the size of the gamble: we don’t need the entire large job’s pieces to converge before we have a working result.

The coordination and status-reporting burden belongs among those costs. A worker who spends time reporting or chasing an answer has less time available for the required implementation; account for the resulting schedule rather than adding the same interruption again under another label.

In the seven-piece example, the worker with nine hours of assignments leaves at most five hours to cover added costs against the fourteen-hour baseline. Transferring their one-hour piece could shorten the stage to eight hours, if another suitable worker can do it in time. That buys one hour, less any transfer cost. It doesn’t solve an eight-hour piece that dominates the schedule.

Making the last required job finish sooner matters more than making an already early job finish earlier. Sometimes the best contribution from someone who has finished is to help remove what is holding up that last completion.

DORA’s guidance on loosely coupled teams emphasizes the ability to change, test, and deploy independently. That’s a useful test of independence: can this piece reach use without waiting for another team’s coordinated release?

For people contributing to the same delivery, continuous integration brings changes together frequently and uses fast automated feedback. That gives us opportunities to discover incompatible changes while they are still small.

Neither source proves that a particular staffing arrangement will win. They give us practices to try and outcomes to inspect.

Pick a small delivery. Record when it becomes available to work on, when each required piece starts and finishes, and when the integrated result reaches use. Include waits and rework. Compare similar deliveries, watching for differences in scope and difficulty.

Compare the time before the first start, the first-start-to-last-finish interval, and the time remaining afterward. Try reducing one delay and see whether the whole delivery improves. An earlier start alone is no victory if it merely creates a longer wait inside the interval.

We need to know whether the result arrives sooner, not merely whether more work starts.

Faster and more efficient are separate wins

A job can finish sooner while consuming more total effort. Parallel execution overlaps work; it doesn’t by itself remove any of it. Added planning, coordination, integration, and rework still consume people’s time.

If we mean efficiency as less total labor for the same outcome and quality, that needs a separate comparison of person-hours, including those added activities. Parallel work can improve that measure if, for example, it avoids enough waiting-related recovery, duplicated investigation, or rework to outweigh its extra effort. The timing inequality alone doesn’t establish that.

An earlier delivery may be worth extra effort. That’s a choice we can make explicitly, rather than calling every shorter schedule more efficient.

More work in the same time?

There is a useful companion to this argument. In Reevaluating Amdahl’s Law (1988), John Gustafson considers growing a computation to use the available parallel capacity within a time budget.

Finishing the same calculation sooner and doing a larger calculation in the same time are different goals. Parallel capacity may be valuable for the second even when the first has a stubborn limit.

For teams, that distinction suggests another measurement question. Did we shorten the time to one usable outcome, or increase the number of independent outcomes delivered over a period? Either can be valuable. Starting more interdependent pieces doesn’t demonstrate either result.

Before dividing the next job, ask where the saving will come from, what the split will cost, and how we’ll know whether it worked.

Then follow the delivery all the way through.