Throwing more processors at a slow program feels like it should make it proportionally faster. It doesn't, and Gene Amdahl proved why with a formula that has haunted parallel computing since the 1960s. The same math explains why throwing more people at a project hits a wall too.
Key Takeaways
- Amdahl's Law: the maximum speedup from parallelism is capped by the fraction of the work that must run serially (Amdahl's Law).
- The formula: speedup approaches 1/f as processors grow, where f is the serial fraction (Amdahl's Law overview).
- 10% serial work caps you at 10x, even with infinite cores.
- The lesson generalizes: the un-parallelizable part of any effort sets the ceiling.
The Math
Gene Amdahl's 1967 argument is simple and merciless. Split any task into a part that can be parallelized and a part that can't (the serial fraction, f). Adding processors only speeds up the parallel part; the serial part takes the same time no matter what. So the maximum speedup S with P processors is roughly S = 1 / (f + (1 - f)/P) (Amdahl's Law).
Push P to infinity and the parallel part shrinks to nothing, but the serial part remains, so speedup converges to 1/f (Amdahl's Law overview). If 10% of your program is inherently serial, your ceiling is 10x, forever, no matter how many cores you buy. If 1% is serial, the ceiling is 100x. The serial fraction, however small it sounds, is the whole game.
| Serial fraction | Max speedup (infinite cores) |
|---|---|
| 50% | 2x |
| 10% | 10x |
| 5% | 20x |
| 1% | 100x |
Why Small Serial Fractions Dominate
The counterintuitive part is how quickly the serial fraction takes over. Add a few processors and the parallel part shrinks fast, so within a handful of cores the serial part is most of your remaining runtime. From there, doubling the cores again barely moves the total, because you're only shrinking a piece that's already small. This is why real-world parallel speedups plateau so far below the core count, and why speedups beyond 100x demand almost impossibly tiny serial fractions (parallelization limits).
The Same Law Governs Teams
Amdahl's Law isn't only about processors. Any effort has a serial fraction, work that one person or step must do in sequence, that no amount of parallelism removes. That's precisely why Brooks's Law holds: some parts of a project can't be split, so adding engineers past a point buys almost nothing while adding coordination cost. A feature that's 30% "one person has to design the data model first" has a hard ceiling on how much parallel staffing helps, regardless of how many people you add.
A Concrete Version
A data pipeline takes an hour, and the team parallelizes the heavy transform step across sixteen workers, expecting roughly 16x. They get about 4x. The reason: a serial setup-and-load phase plus a serial final aggregation together make up around 20% of the runtime, so Amdahl caps them near 5x no matter the worker count. The fix wasn't more workers; it was attacking the serial 20%, parallelizing the load and streaming the aggregation, which moved the ceiling far more than doubling the worker pool ever could.
The Honest Counterpoint
Amdahl's Law describes a fixed problem size, and that assumption is its main limit. Gustafson's Law points out that in practice we usually scale the problem up as we add compute: with more cores we process more data, run bigger simulations, or serve more users, and there the serial fraction stays roughly constant while the parallel work grows, so effective speedup keeps rising. So Amdahl is the right lens when you're speeding up a fixed job (or a fixed project), and less pessimistic than it looks when your ambitions grow with your resources. Know which situation you're in.
What This Means for Teams
The practical takeaway for leaders is that the ceiling is set by the serial bottleneck, not the resource count, so the highest-impact move is usually to attack the serial part rather than to add more parallel capacity. In staffing terms, that means the design decisions, the dependencies, the one approval everything waits on, often matter more than headcount, which connects to the WIP and flow argument and to why adding people late disappoints. Find the serial fraction first. See available engineers.
Frequently Asked Questions
What is Amdahl's Law?
Gene Amdahl's rule that the maximum speedup from parallelism is limited by the fraction of a task that must run serially. As processors approach infinity, speedup approaches 1 divided by that serial fraction.
Why does 10% serial work cap me at 10x?
Because adding processors only speeds up the parallel 90%. The serial 10% takes the same time regardless, so once the parallel part shrinks toward zero, the serial part dominates and total speedup can't exceed 10x.
Does this apply to teams and projects?
Yes, in spirit. Any project has serial work that can't be split, which sets a ceiling on how much adding people helps. It's the mechanism behind Brooks's Law.
Isn't this too pessimistic?
For a fixed problem, no. But Gustafson's Law notes that we often scale the problem up as we add resources, and then effective speedup keeps growing. Use Amdahl for fixed jobs, Gustafson when ambitions grow with capacity.
The Bottom Line
Parallelism only speeds up the parallel part, so the serial fraction sets an unbreakable ceiling: 10% serial means 10x, full stop. The highest-return move is almost always to shrink the serial bottleneck rather than add more cores or more people. Find the part that can't be split, and fix that first.
Roberto Espinoza is CEO of Ruzora, which helps US startups hire pre-vetted senior LATAM engineers, with a vetted shortlist in 72 hours. See available engineers.
