A twenty-person software company has nobody with "SRE" on the payroll, and the work of keeping production up exists all the same. It lands on whoever knows the system best, without anyone having decided it in any meeting. The measure of how heavy it is comes from outside: Catchpoint's SRE Report 2026, built on 418 responses from reliability and operations practitioners, puts median toil at 34% of working time, against 20% the year before. Those people have a name for that work, a job grade and an annual survey. In your company it has none of the three.
What counts as toil (the definition matters)
The English word is toil, and the canonical definition comes from Google's SRE book, which does not talk about "sysadmin tasks" or "infrastructure work". It says this: "Toil is the kind of work tied to running a production service that tends to be manual, repetitive, automatable, tactical, devoid of enduring value, and that scales linearly as a service grows". Two of those words carry the whole definition. Automatable: what cannot be automated is engineering, not toil. And linearly: it grows with the service, so the day you have twice the customers you will have twice this, and not because you did anything wrong.
In a product company that translates into a list everybody recognises and nobody logs. Restoring the test database because somebody left it unusable. Working out why the deploy left two containers on the previous version. Growing the disk that hit 95%. Renewing by hand the certificate that failed to renew itself. Opening the firewall rule for the new office. Easy things, which cannot be left undone, and which leave nothing built behind.
The sum that is in nobody's budget
Put the hours in yourself. With 220 working days a year —a reasonable figure for Spain once you take out public holidays and leave— 34% is 75 days. Fifteen weeks. Three and a half months of one full-time person spent on work the definition itself calls devoid of enduring value. And those 75 days come out of the calendar of whoever knows the production system, who in a small company is usually the hardest person to replace.
What keeps this standing for years is an accounting matter. Cloud, licences and hardware each have their budget line, with an invoice and a depreciation schedule. Those 75 days have no line. They are not invoiced, not approved in committee and not in any monthly report, so they are never decided either: they happen, one Tuesday afternoon after another. The first job is not hiring anyone or buying anything, but giving that time a name and a number, and the cheap way to do that is two weeks of writing down where each interruption went, with whom, and how long it lasted.
It is worth saying what is known and what is not about that jump from 20% to 34%, because fourteen points in a year is a lot of points. The report answers part of it: the survey "has used a consistent methodology" for eight years, so the questions did not change. The rise did not start this year either, but in 2025, when reported toil grew for the first time in five years. And Catchpoint offers a hypothesis drawn from Google's DORA research: that AI accelerates value realisation and teams then fill the regained capacity with additional operational work rather than eliminating it. It could be that, and it could also be that work once filed under a project is now counted as repetitive. What survives any reading is the order of magnitude: between a fifth and a third of the time. In the SRE book, published in 2016, Google reported an average of 33% measured through quarterly surveys, against its own goal of keeping it below 50%. The big number is not an anomaly of this year.
AI has not removed it: it has moved it
The same report has the split: 49% say AI has decreased their toil, 35% say nothing changed and 16% say it increased. The sentence they summarise it with is worth more than the percentages: "AI does not remove toil automatically; it redistributes it". And they list where it goes: maintaining the AI tools, reviewing their suggestions, tuning prompts, and checking that what was done is correct. Anyone who has put automation into production recognises the pattern: doing the task becomes reviewing the task, and reviewing takes up the afternoon too.
The figure that genuinely stings is a paragraph further down, where the data is segmented by role: 60% of directors say AI reduced toil, against 38% of individual contributors. Twenty-two points of difference inside the same survey. Catchpoint is careful about it —"this gap does not imply that one group is wrong", they write; each group is looking at something different— and we think that reading is right: the person deciding sees the quarterly dashboard and the person executing sees Tuesday afternoon. The practical consequence is less comfortable. If the conversation about how much this hurts only ever happens at the deciding layer, you are measuring with the instrument that has the documented bias.
Buying more hardware does not fix this
The usual reaction when this starts to hurt is to spend on capacity: more machines, a bigger plan, faster disks. The reference work on why large services fail is still Oppenheimer, Ganapathi and Patterson at USENIX 2003, and it says two things that bear directly on this. The first, caveat included: "operator error is the largest single cause of failures in two of the three services" —in the third it was networking, with 76% of the outages— and "configuration errors are the largest category of operator errors". The second is the one that disarms the urge to buy: "operator errors arose when operators were making changes to the system, e.g., scaling or replacing hardware, or deploying or upgrading software". Growing the hardware is not a neutral activity; it is one of the activities during which the errors that take the service down show up.
That same study already gave us material for another post, and there is no point repeating it here: what would have prevented the most outages was testing the live system, 26 out of 40, against the 9 from more redundancy. What does belong here is how it connects to the figure above. Toil does not only cost days; it is the ground where those configuration errors get made. A manual task for the fiftieth time, at seven in the evening, with a customer waiting, is exactly the scenario the paper describes. Hence the warning in Google's book about what happens when it piles up —"Too much toil leads to burnout, boredom, and discontent", and "you motivate the team's best engineers to start looking elsewhere"— and hence that the engineering which prevents it sounds unglamorous: a staging environment identical to production, deploys in slices, real one-click rollback, and telemetry that warns on symptoms before a customer calls. What happens when that last part is missing is what we wrote about in the retry storm piece.
What can leave the building and what cannot
Here the conversation becomes self-interested on our side, so let us be concrete. The split does not run on "technical outside, strategic inside", which means nothing. It runs on a simpler question: does this task have a known right answer, or does something have to be decided? The first can be operated from outside. The second stays in.
When not to outsource it
We sell infrastructure consulting and operations, so this list runs against our own commercial interest. Five situations where signing a contract with someone like us is the wrong call, and we say so because we run into them:
- 1The infrastructure IS the product. If what you sell is a platform, operations are your edge and not an incidental cost. There you need to hire in-house, and the sensible thing on our side is to help out at the margins, on what is not your core.
- 2There is nobody inside who can say yes. An operations provider needs a counterpart who can approve or stop a change. If that person does not exist, what gets outsourced is not the work but the ownership vacuum, and that costs more with an invoice attached than without one.
- 3What you need is a project. Getting off a platform, building the cluster, redoing the network: these have a start and an end. Calling it a "managed service" to spread it into instalments helps nobody; it gets quoted as a project, and it finishes.
- 4You want minutes-level response on an office-hours budget. Two different things with two different prices. If nobody says the number out loud, the expectation surfaces on the day of the incident, the worst possible moment to find it. Better beforehand: what 24×7 actually means, and what it does not.
- 5The real problem is three years of undocumented decisions. If nobody knows why that machine has that static route, no contract fixes it in the first month. The prior job is the inventory, cheaper than any service: until it exists, whoever comes in works blind, us included.
The three questions that bring it out
If you would rather not set up the two-week measurement, there is a shortcut. We take these three questions into management meetings, and what informs you is not the yes or the no: it is how long the room takes to answer.
- 1. What happens today if any one machine in the system dies? And any means I pick it, not you.
- 2. When did you last restore a backup? Actually restore it, stopwatch running, not "have" it.
- 3. Who reviews the next change before it touches production? If the answer is one name and that name is the person making the change, there is your risk.
The second one produces the most silence, and it is not a small-company problem: in that same SRE Report 2026, 34% of organisations have never tested failure in production and only 17% run chaos experiments regularly. When the day comes, the real numbers are the ones in the recovery report we discussed a few weeks ago: four out of more than eight hundred client engagements came close to their recovery target. We run timed drills every quarter; the last full recovery came out at 14 minutes. That is an internal figure and we present it as what it is: a test we ran, not a contractual promise. Its value is not in being low, it is in existing: there is a measurement and a date, and that is what makes it arguable.
The axis we design around gets repeated a lot around here: failure is inevitable, an outage is a design decision. Applied to people instead of disks, it comes out like this. Manual work pulling at your company is inevitable and grows with you, because that is how it is defined. That the work gets absorbed, unbudgeted and unmeasured, by the person your product depends on is a decision taken by omission, on a Tuesday afternoon, many times in a row. And if 34% is what comes out of organisations that have the role and the survey, the reasonable question is not how to drive it to zero, but who is carrying it in your company and whether they know it.
Sources (verified at origin): the 34% median against the previous year's 20%, the 418 responses, the eight years of consistent methodology, the DORA hypothesis, the 49/35/16 split, the sentence "AI does not remove toil automatically; it redistributes it", the 60% of directors against 38% of individual contributors, and the chaos figures (17% regularly, 34% never) — SRE Report 2026, Catchpoint and its companion analysis. The definition of toil, the goal of keeping it below 50%, the 33% average and the lines on burnout and losing engineers — "Eliminating Toil", Google SRE Book (2016). The quotes on operator error, configuration errors and the changes during which they arise — Oppenheimer, Ganapathi and Patterson, "Why Do Internet Services Fail, and What Can Be Done About It?", USENIX 2003. The 75-day sum is ours, on the stated assumption of 220 working days a year; the 14 minutes of our last full recovery drill is an internal everyWAN figure, not a service guarantee. We are not resellers of any platform and we do not sell anybody's licences.
How many days a year does your best engineer lose to this?
We run infrastructure for software companies that are done having their product compete for calendar space with patching. If you want to know which part of that list can leave your building and which cannot, we will go through it with you before talking contracts: get in touch.
Talk to everyWAN