30-40% of Your Engineering Capacity Is Missing. Here Is the Math.
TL;DR: Unplanned work typically consumes 30% to 50% of engineering capacity, driven by high rework rates and the high interruption cost of context switching. To reclaim this capacity, leaders must quantify the gap between "naive capacity" and "effective planned capacity" using a mix of ticket tagging and weekly developer sentiment surveys.
Most engineering leaders build roadmaps based on a fiction. They assume that if they have 20 engineers, they have 20 engineers’ worth of time to spend on product features. In reality, a significant portion of that time is lost to unplanned work engineering capacity drains—the bugs, outages, and "quick questions" that break focus.
This hidden tax is rarely audited because it is difficult to see in a Jira board. Yet, when you look at the data from Stripe, Accelerate, and frontline practitioners, a staggering picture emerges: 30-40% of your most expensive resource is effectively missing. This is not just a productivity issue; it is a headcount and budgeting crisis.
The numbers that survive scrutiny (and the ones that do not)
The industry often treats "unplanned work" as a nebulous vibe, but three major data points provide a rigorous foundation for how we should think about unplanned work engineering capacity.
Accelerate: 29% less unplanned work among high performers
The DORA (DevOps Research and Assessment) team, through years of research published in Accelerate, found a definitive link between organizational performance and the nature of work. High-performing teams spend significantly more time on new work than their lower-performing counterparts. Specifically, high performers spend 29% less time on unplanned work and rework. This suggests that the "natural state" for an efficient team still involves some maintenance, but as technical debt and fragile systems accumulate, that number balloons, eventually choking out innovation entirely.
Stripe Developer Coefficient: 42% of the week, ~$85B
In 2018, Stripe released a landmark report titled The Developer Coefficient. They surveyed thousands of developers and C-suite executives globally. The findings were sobering: developers spend an average of 17.3 hours per week dealing with maintenance, "bad code," and technical debt. According to Stripe, this equates to roughly 42% of the developer workweek. On a global scale, the report estimated this creates an $85 billion hit to global GDP. This is perhaps the most cited evidence for value-add time vs non-value-add time discrepancies in the modern enterprise.
A real team at 20/80 (Equal Experts telco case)
While survey data is powerful, anecdotal evidence from the field shows how extreme the decay can become. According to Equal Experts, a major telecommunications firm found that their "effective" development time had plummeted to just 20%. The remaining 80% was swallowed by support, manual deployments, and fixing regressions. This case study highlights the "death spiral" of unplanned work: when quality drops, engineers spend all their time fixing things, which means they have no time to build the automated safeguards that would prevent future fixes.
Key Takeaway: Unplanned work is not a minor nuisance; it is a structural drain that typically claims 30-50% of engineering resources, directly impacting both the roadmap and the bottom line.
The capacity math, worked example: a 20-engineer org
To understand the cost, we have to move from percentages to dollars and FTEs (Full-Time Equivalents). Let’s look at a hypothetical (but realistic) 20-engineer organization.
Naive capacity vs effective planned capacity in FTEs and dollars
In a "naive" planning model, a VP of Engineering might calculate capacity like this:
- Total Engineers: 20
- Average Salary + Benefits: $200,000
- Total Annual Investment: $4,000,000
- Planned Output: 100% of headcount assigned to the H1 Roadmap.
Now, let’s apply the rework rate percentage and unplanned work metrics observed in the data above. If this team spends 40% of their time on unplanned work (reactive fixes, technical debt, and interruptions), the math changes:
- Effective Planned Capacity: 12 FTEs
- Unplanned Work Drain: 8 FTEs
- Wasted Salary Capital: $1,600,000 per year
This $1.6M is the "hidden tax." When the CEO asks why the roadmap is behind, the answer usually involves "complexity" or "hiring needs." The reality is that the team is essentially missing eight people who are busy fighting fires that shouldn't have started in the first place.
Why nobody notices: unmeasured and unquestioned
If a factory lost 40% of its raw materials to scrap every day, the manager would be fired. In engineering, we call it "business as usual." This phenomenon is known as the normalization of deviance. Because unplanned work is granular—a 30-minute Slack thread here, a 2nd-hour post-mortem there—it doesn't show up as a single line item in the budget.
Most organizations lack the telemetry to see it. Our tools are optimized for what we plan to do (Jira/Linear backlog) rather than what we actually did. Consequently, the interruption cost remains invisible. Engineers feel the burnout, but leadership sees only a "velocity problem."
Why this matters
As we enter a period of increased scrutiny on "engineering efficiency" and AI-assisted coding, the focus is shifting from "how many features can we ship" to "where is our time actually going." If a GenAI tool helps an engineer write code 20% faster, but that code contributes to a higher rework rate percentage, the net gain to the business is zero—or even negative. Understanding the math of unplanned work is the prerequisite for any meaningful improvement in engineering ROI.
Measuring yours in two weeks
You do not need an expensive observability platform or a months-long audit to find your number. You can get a defensible estimate in 14 days.
1. One-question weekly survey
The most accurate data often comes from the engineers themselves. Every Friday, ask one question: "What percentage of your time this week was spent on work that was not on the sprint plan (incidents, ad-hoc requests, bugs)?" Aggregating this across a 20-person team for two weeks will give you a remarkably accurate baseline.
2. Ticket tagging and rework rate
Audit your last two weeks of completed tickets. Categorize them into:
- New Value: Features and capabilities.
- Maintenance: Upgrades and keep-the-lights-on work.
- Rework: Fixing something that was supposed to be done or fixing a regression. The rework rate percentage is often the most painful number to see, as it represents pure waste.
3. Interruption-cost multipliers for context switching
A 30-minute "quick question" on Slack does not cost 30 minutes. It costs the 30 minutes of the conversation plus the 20-30 minutes it takes for the engineer to regain "flow." When measuring unplanned work, apply a 1.5x or 2.0x multiplier to small interruptions to account for the interruption cost.
Common pitfalls in measuring capacity
- The "Shadow" Work Trap: Engineers often "fix" things in the margins of a feature ticket to avoid the overhead of a Jira bug. This hides technical debt.
- Blaming the Individual: High unplanned work is almost always a system failure (lack of CI, poor testing, brittle infra), not a developer performance issue.
- Over-measuring: Don't try to track every minute. Aim for "directionally correct" data that can drive a board-level conversation.
What actually moves the number
Once the math is clear, the goal is to shift the ratio of value-add time vs non-value-add time.
- Continuous Deployment Practices: Reducing the batch size of deployments reduces the blast radius of failures, lowering the time spent on incidents.
- Platform Standardization: According to Swarmia, reducing the cognitive load on developers by standardizing how infra and logs are handled can significantly decrease the time spent on "maintenance chores."
- Proactive Detection: Moving from "waiting for a user to complain" to "detecting the systemic root cause before the alert fires" is the difference between a high-performing and a low-performing org.
Sources & further reading
- According to the Stripe Developer Coefficient, developers spend 42% of their week on maintenance and bad code.
- According to Equal Experts, unplanned work can swallow up to 80% of capacity in legacy environments.
- According to Swarmia, tracking "Work Type Distribution" is a core metric for engineering leaders to ensure roadmap alignment.
- According to Boldstart, high-performing teams use automation to handle the "toil" portion of unplanned work.
The reality is that 30-40% of your engineering capacity is currently being spent on work you didn't plan for. This happens because production is complex, and investigating incidents is a manual, labor-intensive process. This is precisely why we built Operate.
Operate is a self-hosted AI SRE platform that handles the reactive "unplanned" heavy lifting. It watches production, investigates incidents across logs and infra, finds the root cause with evidence, and drafts the PR fix. By automating the investigation and resolution of operational work, it allows teams to shrink the reactive share of their week and reclaim their capacity for the work that actually moves the needle.