Toil in Software Engineering: Finding and Eliminating It
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.
Google's SRE team popularized the concept of toil: work that's manual, repetitive, automatable, and scales linearly with system size. They set a target of keeping toil below 50% of an SRE's time. Most software engineering teams I've worked with don't even measure their toil, and when they do, the number is usually horrifying. The developer productivity guide places this work alongside delivery and developer experience.[1]
I ran a toil audit on my team last quarter. The result: engineers spent 38% of their time on work that was repetitive, manual, and could be automated. That's 38% of salaries, 38% of energy, 38% of your team's finite capacity spent on tasks that a script could do. And unlike Google's SRE-focused definition, engineering toil extends far beyond operations into the daily development workflow.
# The Contrarian Take: Most Engineering "Best Practices" Create Toil
Here's what nobody talks about: many of the processes teams adopt in the name of quality and rigor are actually toil generators. Manual QA checklists. Required approval from 3 reviewers. Hand-written changelog entries. Manually updated dependency graphs. Each one sounds responsible. Together, they create a death spiral where the process of building software takes longer than actually building it.
The question isn't "is this process valuable?" The question is "is this process valuable enough to justify its cost in human time, given that it could be automated?"
Not all manual work is toil. Designing a system architecture is manual but not toil. Writing a one-off migration script is manual but not toil. The following four-property screen is an engineering heuristic. Google also considers whether work is tactical and has no enduring value, and says a task need not have every attribute:[2]
Repetitive: You've done this task before, in essentially the same way
Manual: A human has to execute the steps
Automatable: A computer could do this with the right tooling
Scaling: The work grows as your system or team grows
typescript
// A toil classifierinterface EngineeringTask { name: string; isRepetitive: boolean; // Done more than once per month isManual: boolean; // Requires human execution isAutomatable: boolean; // Could be scripted/automated scalesWithGrowth: boolean; // More instances as system grows}function isToil(task: EngineeringTask): boolean { return task.isRepetitive && task.isManual && task.isAutomatable && task.scalesWithGrowth;}// Examples:const tasks: EngineeringTask[] = [ { name: "Update version numbers before release", isRepetitive: true, // every release isManual: true, // engineer edits files isAutomatable: true, // semantic-release does this scalesWithGrowth: true, // more packages = more version updates }, // TOIL { name: "Design API for new feature", isRepetitive: false, // each API is unique isManual: true, isAutomatable: false, // requires human judgment scalesWithGrowth: false, }, // NOT TOIL];
# The Toil Catalog: Where Engineering Time Disappears
After auditing 4 teams, I've cataloged the most common sources of engineering toil. The percentages represent the average share of total toil each category represents.
Don't overthink this. A shared spreadsheet works fine. The goal is to make invisible work visible. The engineering productivity audit adds delivery and workflow evidence to the same investigation.
Figure 1. Track the work, compare its cost and assign the selected automation work.
Aggregate the data and compute your team's toil percentage:
Total Toil Hours/Week = sum of all toil entries
Total Available Hours/Week = team size x 40
Toil Percentage = Total Toil Hours / Total Available Hours
Set a target. Google targets below 50% for SRE. For product engineering teams, I target below 20%. If you're above 30%, toil elimination should be your top priority because it's consuming almost a third of your engineering investment.
Annual Time Cost = frequency_per_year x time_per_occurrence x engineers_affected
Automation Cost = estimated engineering days to build automation
Gross annual time-saving ratio = Annual Time Cost in hours / Automation Cost in hours
For the example below, one build day = 8 hours. Maintenance is additional.
Take the top 3 items after comparing the gross time-saving ratio, upkeep and implementation risk. Assign them to engineers as first-class project work, not side projects. Track completion and impact.
The most important cultural shift: toil elimination is not optional "when you have time" work. It's engineering work with measurable ROI that deserves sprint allocation.
Review the dashboard monthly. A code quality dashboard can carry the related technical actions and their owners. Celebrate toil elimination the same way you celebrate feature launches. An automation that saves 5 hours per week is equivalent to hiring 12.5% of an engineer. That's worth celebrating.
Here's what makes toil elimination so powerful: the savings compound. When you automate a task that took 5 hours per week, you don't just save 5 hours this week. You save 5 hours in each week the automation continues to replace the task. At 52 weeks with unchanged demand, that is 260 gross hours before upkeep. Over three years, 780 hours. And the engineer-hours freed up can be spent on more toil elimination, creating a virtuous cycle.
I tracked this on my team. In Q1, we automated 8 hours per week of toil. In Q2, using some of those freed hours, we automated another 12 hours per week. By Q4, we'd reduced total toil from 38% to 14%. The team shipped 40% more features that year with the same headcount.
That's not magic. It's arithmetic. But you have to actually do the work of identifying, measuring, and eliminating toil. Most teams never start because toil feels like "just part of the job." It isn't. It's waste, and your team deserves better.
Frequently asked questions
Is all manual engineering work toil?
Manual work can require judgment or produce a lasting improvement. Architecture design and a one-off investigation can be worthwhile engineering work. Use repetition, automation potential and growth in effort to identify candidates for a closer look.
Should product teams copy Google’s 50% toil target?
Google describes this limit for its SRE organisation. A product engineering team needs a target suited to its responsibilities and delivery constraints. The article’s lower target is a proposed operating choice, which the team should review against its own baseline.
How should I compare automation cost with time saved?
Express both quantities in the same units. Convert estimated build days to hours before dividing annual saved hours by build hours, then account for maintenance and how often the task will still run. A large gross ratio can still hide expensive upkeep.
Which toil items should we automate first?
Start with recurring tasks whose cost is visible and whose automation is feasible. Compare the expected savings, implementation effort and ongoing upkeep, then assign an owner. Review the measured result before extending the same automation to other work.
A 3-tier succession planning framework for engineering orgs, with a 90-day sprint for accelerating candidates from potential to ready. Based on succession plans built at 4 companies.
The CTO's real job in product development isn't attending every meeting or making every technical call. It's connecting feasibility, viability, and capacity while letting EMs handle the day-to-day.
Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.
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.
A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.
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.