Overestimating the build time is the main reason a small automation sits undone for months while you keep doing the task by hand. The fix is to size the real work in three parts, schedule a short first pass, and stop treating “I don’t have time to figure this out” as a true estimate.
- The sentence “I don’t have time to figure this out” is a feeling about size, not a measured estimate of the work.
- Most stalled builds are not big. They feel big because the real timeline was never broken into parts.
- A real estimate splits into three pieces: the first working version, the testing, and the break and fix.
- You do not need the full automation on day one. A rough first pass that saves ten minutes is worth scheduling.
- The task you keep doing by hand has a running cost that nobody writes down, which is why the delay hides so well.
Why does overestimating the build time keep the work from getting scheduled?
Overestimating the build time keeps the work off your calendar because a vague, inflated guess feels too large to fit into any normal day, so you default to doing the task by hand again instead of blocking an hour to build the thing once. The guess is never tested. It just sits there as a wall. And a wall you never measure stays exactly as tall as your worst mood about it.
Overestimating the build time is treating an unknown task as bigger than it is because you have not broken it into real steps yet. That is the whole trap. The excuse is cheap to say and expensive to keep. You spend six months doing something that a four hour build would have ended.
I watch this happen with work that would genuinely pay for itself in two weeks. The task is not hard. The problem is that “figure this out” is a fog, and fog has no size. So the mind rounds it up to “someday” and moves on to the urgent thing in front of it.
An estimate you have never broken into steps is not an estimate. It is a mood wearing a number.
The anatomy of the excuse
“I don’t have time to figure this out” does two sneaky things at once. First, it bundles the learning and the building into one scary lump. Second, it assumes the whole thing must be done in one sitting. Neither is true. You can learn the first step today and build it next Tuesday.
There is real science behind why your gut guess runs high. The planning fallacy is the well documented pattern where people underestimate how long their own projects will take. The flip side also bites. For work you dread or do not understand yet, you overestimate so heavily that you never start. Researchers describe an “outside view” that uses past similar tasks as a reference instead of your gut. Your gut is the problem. Past evidence is the fix.
What is a real timeline for a small automation build?
A real timeline for a small automation build is the honest sum of three separate phases: a first working version that does the core job, a round of testing against real inputs, and a break and fix pass to handle the odd cases, each sized on its own instead of lumped into one dreaded unknown. Split that way, most “someday” builds turn out to be a single afternoon of focused work.
Here is the pattern I use when I size anything. I refuse to write one number. I write three.
| Phase | What happens | Honest time range |
|---|---|---|
| First version | Build the core path that handles the normal case | 1 to 2 hours |
| Testing | Run real inputs through it and watch what it does | 30 to 60 minutes |
| Break and fix | Find the odd cases, patch them, test again | 1 to 2 hours |
Notice that none of those three numbers is six months. Notice that the scary total is around four hours. The reason the excuse wins is that your brain never lets the work split into these three. It keeps the lump whole so it stays too heavy to lift.
You do not schedule a lump. You schedule a first version. The lump is why nothing moves.
My own padded estimate, out loud
I will call out my own. I once put off a small intake automation because I “did not have time to figure it out.” In my head it was a week of work. When I finally sat down, the first version took about ninety minutes. Testing took half an hour. The break and fix, the part where I found the two weird inputs that jammed it, took another hour and change. Four hours, start to finish. I had carried a six month excuse for a four hour task. The estimate was not an estimate. It was avoidance with a timestamp.
How do you break the overestimate and actually start?
You break the overestimate by scheduling only the first version, giving it a hard ninety minute cap, and promising yourself that the goal is a rough thing that does the core job, not a polished system that handles every edge case you can imagine. Perfection is the excuse’s best friend. A rough first pass starves it.
Start small on purpose. The guidance from Google’s reliability engineers is blunt about this. Automation does not have to be big to earn its place, and “start small and then improve” is a real strategy, not a cop out. You can read their take on eliminating repetitive work for the full argument. The point that matters here is that a tiny automation shipped today beats a perfect one imagined forever.
- Write the task in one sentence. If you cannot, the task is actually two tasks. Split them.
- Name the three phases. First version, testing, break and fix. Put a time next to each.
- Schedule only the first version. One block. Hard cap. Core path only.
- Run it on real inputs the same day. Watch where it breaks. That is your break and fix list.
- Fix the breaks in a second short block. Stop when it handles the normal case reliably.
The thing that saves you the most is the hard cap. When you cap the first version at ninety minutes, you stop trying to solve problems you do not have yet. You build the normal case, you ship it, and the odd cases reveal themselves in testing instead of in your anxious imagination.
Why does the delay stay invisible?
The delay stays invisible because the cost of doing the task by hand is paid in small daily slices that never show up as one big number, while the cost of building is a single visible block of time you have to defend against everything else screaming for your attention. Ten minutes a day feels like nothing. Over six months it is more than twenty hours.
When time feels short, attention narrows to the urgent thing in front of you. Research on scarcity calls this “tunneling,” and a plain summary of the effect ran in this review of the research. The tunnel is why “I don’t have time to figure this out” feels so honest. You are not lying. You genuinely cannot see the build from inside the tunnel. But the build is the only thing that widens it.
The task you do by hand bills you in slices so thin you never notice the total. The build bills you once.
The planning fallacy was formally named by psychologists Daniel Kahneman and Amos Tversky back in 1979. The bias they described, people misjudging how long their own work will take, has held up across decades of studies since.
The version of this I run into most often is a client who can describe the exact task they hate, down to the click, but cannot give me a straight answer on how long building the fix would take. They say “a long time” or “I don’t even know where I’d start.” When we actually size it together, the first version almost always lands inside one afternoon. The gap between the dread and the real timeline is the whole story. The dread was never measuring the work. It was measuring the unknown.
How do I know if I’m overestimating a build?
You are probably overestimating if you can only name a vague total like “a week” and cannot split the work into first version, testing, and break and fix. A guess you cannot break into steps is a feeling, not an estimate. Sit down and name the three phases. The honest total is usually far smaller than the lump in your head.
Why do I never have time to figure out automation?
Because the task you do by hand costs you in tiny daily slices while the build asks for one visible block of time. Your attention narrows to the urgent thing and the build never gets scheduled. The fix is to schedule only the first version with a hard time cap, not the whole polished system.
How long should a small automation actually take to build?
A small automation usually takes about one to two hours for a first working version, under an hour to test, and one to two hours for break and fix. That is roughly a single afternoon. The months of delay come from the excuse, not the work itself.
What is the planning fallacy?
The planning fallacy is the documented tendency to misjudge how long your own tasks will take. For work you dread, it flips into heavy overestimation, which is why a four hour build can feel like a month and never gets started.
Should I build the whole automation at once?
No. Build only the first version that handles the normal case, then test it on real inputs. The odd cases show up in testing, where you can fix them in a short second block. Trying to solve every edge case before you start is how the build stays stuck in your head.
What is break and fix in a build timeline?
Break and fix is the phase where you run real inputs through your first version, find the cases that jam it, and patch them. It is a normal, expected part of the work, not a sign you did it wrong. Budgeting a block for it keeps the whole thing honest.
Next time you catch yourself saying “I don’t have time to figure this out,” do one thing before you move on. Write the task in a single sentence and put three numbers next to it: first version, testing, break and fix. If the honest total is under five hours, you do not have a time problem. You have a scheduling problem, and those are much easier to fix.
Save this for the next time a build estimate sounds too clean. When you are ready to size a real timeline with people who build these for a living, the community is a good place to start.
… and see more of my posts in your Google results.
