Our build took 14 minutes. Nobody complained because it had always been 14 minutes. We treated it like weather. Just something you deal with.
Then we cut it to 90 seconds and everything changed.
PR throughput went up 28%. Developers stopped batching changes into massive PRs (because the feedback loop was fast enough to ship small ones). Code review quality improved because PRs were smaller. The flaky test rate dropped because developers could actually re-run tests without losing their afternoon.
All from fixing something nobody thought was a problem.
Build time isn't just "time waiting." It's a chain reaction of behavioral changes that compound into massive productivity loss.
Context switching. When a build takes more than about 90 seconds, developers switch to something else. Slack, email, Twitter, another task. Research on interrupted programming examines the work needed to resume a task. It does not justify adding a fixed 15-25 minutes to every build. Measure waiting and resumption in the workflow you are changing.[1]
PR bloat. When builds are slow, developers batch changes to avoid triggering the pipeline repeatedly. Instead of three focused PRs, they submit one monster PR with 800 lines changed. Reviewers skim instead of reading. Bugs sneak through. Merge conflicts multiply.
Reduced experimentation. Fast builds encourage experimentation. "Let me try this approach and see if it works." Slow builds discourage it. "I'll just go with the first approach because I don't want to wait another 14 minutes to validate the alternative." Over time, this leads to worse technical decisions.
Flaky test tolerance. When re-running tests is cheap (30 seconds), developers investigate failures immediately. When re-running tests costs 14 minutes, they hit retry and hope. Flaky tests accumulate. Trust in the test suite erodes. Eventually, developers stop writing tests because they view the suite as unreliable.
This is the single biggest win for most projects. Tools like Turborepo, Nx, or Gradle's build cache store the results of previous builds and skip unchanged work.[2]
For a TypeScript monorepo, Turborepo's remote cache was transformative:
When developer A builds package X and pushes the cache, developer B skips that build entirely. In a monorepo with 20+ packages, most builds become cache hits. Our cold build went from 14 minutes to 6 minutes just from this.
Four parallel shards cut our test time from 8 minutes to 2.5 minutes. The wall-clock time is bounded by the slowest shard, so balance your test distribution.
Jest to Vitest: Benchmark the actual suite, including startup, transforms and test environment setup. Migration effort and speed depend on the project.
Webpack to Vite/Turbopack: Modern bundlers are dramatically faster for development builds.
ESLint to Biome: Compare the rules and framework support you need before trying a timed run. Tooling changes also have compatibility and configuration costs.
We replaced Jest with Vitest and our unit test suite dropped from 90 seconds to 18 seconds. No test changes required.
# The Contrarian Take: Don't Optimize the Wrong Build
I see teams obsess over CI build times while ignoring local development speed. That's backwards. Developers run local builds 10-50x more often than CI runs. A 30-second improvement in local incremental build time is worth more than a 5-minute improvement in CI.
The priority should be:
Local incremental build (developers feel this hundreds of times per day)
Local test execution (developers run this dozens of times per day)
CI pipeline (developers wait for this a few times per day)
Cold build / environment setup (developers hit this a few times per week)
Optimize in that order. Most teams start at the bottom and work up, which is exactly wrong.
Set a build time budget for your team. Make it explicit and visible. Here's how:
Set targets. Local incremental: under 2 seconds. CI: under 10 minutes. Cold: under 3 minutes.
Monitor weekly. Add build time to your CI and track the p50, p90, and p99 over time.
Create an alert. When the p90 exceeds your target by 20%, file a ticket automatically.
Dedicate capacity. Reserve 10% of sprint capacity for build performance. This isn't overhead. It's investment in every other task moving faster.
The teams that treat build time as a first-class metric are, in my experience, the teams that ship the fastest. Not because fast builds are the most important thing. But because caring about builds means caring about the developer experience. And that mindset permeates everything.
Start measuring. Start caring. The 14-minute build you're tolerating right now is costing you far more than you think.
Frequently asked questions
Which build time should I measure first?
Measure the local incremental build, cold build and test lanes separately. Start with the delay developers encounter most often, then use the same machine, inputs and cache conditions to compare a change.
Does remote caching make every build faster?
Caching helps when work can reuse a valid earlier result. Declare the relevant inputs and outputs correctly and measure cache hits, because changed inputs, missing artifacts or cache overhead can affect the result.
Will adding more test shards divide execution time evenly?
Sharding runs different files on separate workers, and the slowest shard bounds completion time. Include worker setup and shared resources in the measurement and check whether the suite can safely run in parallel.
Should I replace the test runner before profiling?
Inspect where the existing run spends time and try a representative comparison. A migration can require configuration or mock changes, and the result depends on the suite rather than a universal speed multiplier.
Your PR data reveals team bottlenecks invisible in standups. Here's how to measure TTFR, review distribution, and cycle time with the REVIEW framework.
Small frictions cost more than big blockers. 47 micro-frictions consume 96 minutes per engineer per day. Here's the TAX Return framework for finding and eliminating the developer productivity tax.
Set up continuous code quality monitoring with CI gates, trend metrics and alerts. Establish a baseline, define thresholds and review changes with your team.
Engineers spend 38% of their time on repetitive, automatable work. Here's a toil audit process that identifies where time disappears and a framework for systematic elimination with measurable ROI.
Developer experience is a systems design problem, not a culture problem. Platform engineering reduces cognitive load from 12 concepts to 3 for common tasks. Here's the LOAD assessment framework.