xkcd's automation table, recomputed with upkeep counted

The xkcd chart Is It Worth the Time? says how long you can spend making a routine task faster before you lose time over five years. It counts 24-hour days, 365-day years and zero upkeep. We recomputed it for a working year and subtracted the hours an automation needs to keep running.

The change matters to anyone deciding what to automate at a small company, because upkeep is the line the chart leaves blank.

At an assumed hour a month of it, five of the seven common tasks in our table never pay back at all, however fast you build. This piece shows why the chart reads the way it does, what forces upkeep, and a 28-line Python script you can run with your own numbers.

The chart counts calendar time, not working time

Randall Munroe published the chart on 29 April 2013. Rows give the time shaved off one run, from 1 second to 1 day. Columns give how often you do the task, from 50 times a day to yearly. Each cell is the time saved over five years, which is the most you can spend on the fix and still break even.

The comic never prints its formula, so we checked one.

We multiplied time shaved by runs per year by five, using 24-hour days and 365-day years, for all 45 cells that hold a number. Every result landed within 27% of the printed cell, and the gaps match the comic’s rounding to whole units. A minute shaved off a daily task gives 30.4 hours; the comic rounds that to “1 day”. The other 9 cells read “n/a”, with no number to check.

Two of those assumptions do not fit office work. A task you do “daily” at work happens on weekdays, which is 52 times 5, or 260 days a year before holidays and leave, not 365. And a “day” of building is a workday of about 8 hours, not 24.

Guess which way the two corrections push. They pull in opposite directions. Counting 260 days cuts the hours saved by 29% for anything done daily or more often, and counting 8-hour days triples the number of days those hours buy.

Net, the minute shaved off a daily task is worth 21.7 hours over five years, or 2.7 workdays, where the comic says 1 day. Weekly, monthly and yearly tasks keep their hours, since they repeat the same number of times either way.

So the chart is not too strict for office work in days. It is too generous in one larger way: it assumes the automation, once built, costs nothing more.

Upkeep is forced by the platforms, on their schedule

The chart’s own sequel says as much. In xkcd 1319, “Automation”, the “theory” panel shows coding time ending as the automation takes over the task. In the “reality” panel, writing code turns into debugging, rethinking and “ongoing development”, and the original task gets no time at all.

That is a joke, but the platforms office workers build on put the same lesson in writing. Microsoft’s Power Automate limits page says a cloud flow that “isn’t triggered within a 90 day period might be turned off” unless its owner has a premium or capacity license. Owners are notified 30 days before. A flow whose trigger or actions “fail continuously” for 14 days is turned off too.

Zapier’s help center says it will turn off a Zap that errors 95% of the time it runs and has run more than 20 times in the past 7 days. Team plans get a 24-hour grace period and Enterprise plans 72 hours.

Scripts are not exempt. Google keeps a table of retired Apps Script features, and seven of them reached their sunset date between November 2022 and June 2026. One was the Rhino runtime: “Scripts running on Rhino will continue to function until January 31, 2026, after which they will no longer execute.” Others, such as the Contacts and Sites services, now simply no longer function.

None of these is a bug in your automation. Each one is a date or a rule set by someone else, and each one costs time you did not put in the chart.

The upkeep line decides most cells

Here is the recomputed table. The script below printed it in our sandbox on 20 October 2026. Rows are seven common cells from the comic, with its “1 day” row read as one 8-hour workday. Each column subtracts a different amount of yearly upkeep, meaning time spent checking, fixing and migrating.

The upkeep levels are inputs we chose, not measurements. We found no published measure of how much upkeep office automations need. Read 2 hours a year as “one small fix a year”, 12 as “an hour a month” and 24 as “two hours a month”.

Every other number is arithmetic on the comic’s rows. A “day” in the table is 8 working hours.

Saved per run, how often	Saved per year	Upkeep 0 h/yr	Upkeep 2 h/yr	Upkeep 12 h/yr	Upkeep 24 h/yr
30 seconds, 5 times a day	10.8 h	54 h (6.8 days)	44 h (5.5 days)	never pays	never pays
1 minute, daily	4.3 h	22 h (2.7 days)	12 h (1.5 days)	never pays	never pays
5 minutes, daily	21.7 h	108 h (13.5 days)	98 h (12.3 days)	48 h (6.0 days)	never pays
5 minutes, weekly	4.3 h	22 h (2.7 days)	12 h (1.5 days)	never pays	never pays
30 minutes, weekly	26.0 h	130 h (16.2 days)	120 h (15.0 days)	70 h (8.8 days)	10 h (1.2 days)
1 hour, monthly	12.0 h	60 h (7.5 days)	50 h (6.2 days)	never pays	never pays
1 workday, yearly	8.0 h	40 h (5.0 days)	30 h (3.8 days)	never pays	never pays

Each cell is the most you can spend building it and still break even over five years. “Never pays” means the upkeep alone eats the saving, so even a build that took no time loses hours. The hour-a-month task sits exactly on that line: 12 hours saved, 12 spent.

The pattern is simple once it is written down. The hours a task saves each year are the most upkeep it can carry. A minute shaved off a daily task saves 4.3 hours a year, so a little over half a day of fixes each year wipes it out. Thirty minutes shaved off a weekly task saves 26 hours a year and survives two hours of upkeep a month.

Rare tasks carry an extra risk

The rules above hit infrequent tasks hardest. A yearly task leaves its flow untriggered for far longer than 90 days, so on a standard license its Power Automate flow is exactly the kind Microsoft says “might be turned off”. A monthly flow stays inside the window.

The yearly row also has the thinnest margin, 8 hours a year in our working-time version. A migration like Rhino that took a few hours, once in five years, would take a real bite of its 40-hour budget. And a yearly job that breaks is found a year late, when the task is due.

A hypothetical shows the cost of a silent failure. Say a daily automation that saves 5 minutes stops for a month of 22 workdays before anyone notices. That is 110 minutes of work to catch up by hand, plus the time to find the fault, and it goes in the upkeep column too.

Our guide to scheduled scripts that fail silently covers how to make a failure reach a person the same day.

The case for automating anyway

There is an honest argument against all of this arithmetic.

In a December 2024 post titled Xkcd’s “Is It Worth the Time?” Considered Harmful, the author describes a fix to a pattern in about 10 spots in a codebase. By hand it would have taken a minute; automating it took an hour. “And I think that was the right choice,” the post says, because of what the author learned along the way.

The claim is that “automating the easy things is how you build the skills, mindset, and muscle-memory to automate the hard things.” The post also grants that doing a task by hand can make sense when all that matters is getting it done quickly. The post drew 27 points and 18 comments on Hacker News.

We think the post is right about one-off scripts that you run yourself and can throw away. Those carry almost no upkeep, because nobody depends on them next month.

The case weakens for a flow other people rely on, where every broken run lands on a colleague. Learning is a fine reason to build. It is a poor reason to leave something running that costs more than it saves.

What this means for you: run the numbers before the build

1. Count runs on a working calendar. Multiply minutes saved per run by runs per year: 260 for a daily task, 52 weekly, 12 monthly. Divide by 60. That is the most upkeep the automation can ever carry.
2. List what it depends on. Each connector, login, file layout and platform rule is a place upkeep comes from. Check the platform’s own limits page: Power Automate’s 90-day and 14-day rules, Zapier’s error rule, Google’s sunset table.
3. Guess upkeep high, then compare. If one hour a month would eat the yearly saving, as it does for five of our seven rows, keep doing the task by hand or make it a one-off script you run yourself.
4. Give rare tasks a reminder. For a yearly or quarterly job, put a calendar check a week before it is due, and test the run then.
5. Run the script with your own rows. Change tasks and upkeep_levels below. It needs Python 3 and nothing else.

# xkcd 1205 recomputed for a working year, with upkeep subtracted.
# Inputs: time shaved off each run, runs per year, upkeep hours per year.
YEARS = 5        # the comic's horizon
WORKDAYS = 260   # 52 weeks x 5 weekdays, before holidays and leave
HOURS_PER_DAY = 8

tasks = [  # (label, minutes saved per run, runs per year)
    ("30 seconds, 5 times a day", 0.5, 5 * WORKDAYS),
    ("1 minute, daily",           1,   WORKDAYS),
    ("5 minutes, daily",          5,   WORKDAYS),
    ("5 minutes, weekly",         5,   52),
    ("30 minutes, weekly",        30,  52),
    ("1 hour, monthly",           60,  12),
    ("1 workday, yearly",         60 * HOURS_PER_DAY, 1),
]
upkeep_levels = [0, 2, 12, 24]  # hours per year spent fixing and checking

print("| Saved per run, how often | Saved per year | " +
      " | ".join(f"Upkeep {u} h/yr" for u in upkeep_levels) + " |")
print("|---" * (2 + len(upkeep_levels)) + "|")
for label, minutes, runs in tasks:
    saved = minutes * runs / 60                      # hours a year
    cells = []
    for u in upkeep_levels:
        budget = YEARS * (saved - u)                 # build hours that still break even
        cells.append(f"{budget:.0f} h ({budget / HOURS_PER_DAY:.1f} days)"
                     if budget > 0 else "never pays")
    print(f"| {label} | {saved:.1f} h | " + " | ".join(cells) + " |")

If you have not picked a task yet, start with a one-week tally of what you repeat, then run the strongest candidates through the table. More guides are on the automation page. The comic’s alt text adds that the time spent finding the chart counts too. Upkeep is the same kind of time: small, easy to leave out, and billed again every year the automation runs.

Sources

• Randall Munroe, Is It Worth the Time?, xkcd 1205, 29 April 2013; transcript and date from info.0.json. Licensed CC BY-NC 2.5; linked, not reproduced.
• Randall Munroe, Automation, xkcd 1319.
• Microsoft, Limits of automated, scheduled, and instant flows, Power Automate documentation, updated 17 July 2026.
• Zapier, Zap is not running, help center, updated 15 October 2026.
• Google, Apps Script deprecations and sunsets.
• Xkcd’s “Is It Worth the Time?” Considered Harmful, will-keleher.com, 13 December 2024; Hacker News discussion.
• The table: our script above, run on 20 October 2026; formula check of all 45 numbered cells against the comic’s transcript, same day.