You asked for what seems like a simple change. Maybe updating a notification timing, changing a report filter, or adding a new field to a form.
In your head, it's a 30-minute thing. An hour if we're being generous. Then I come back with an estimate of 6-8 hours, and you're thinking, 'What the hell?'
Honestly? Sometimes, I wish it were as straightforward as it looks from the outside.
Let me explain what's happening. It's more complicated than it looks.
Why a "Small" change isn't so small
What you see on the surface is 10% of what's happening underneath.
Say you want to change when a task reminder email gets sent. "Just change it from today to tomorrow,".
Sure, that's one line of code. But
- Which system sends that email?
- Are there other places that define "due date" differently?
- What about recurring tasks vs. one-time tasks?
- Do we need to update the UI to match?
- Will this break the manager escalation emails?
- What about the mobile app notifications?
That one-line change touches six different parts of the system.
If we fail to check all of them, your operations team will be unhappy when issues come up.
What happens
Here's what happens when we get your "simple" request:
Hour 1: Figure out where the hell this logic lives. Even in WeWeb and Retool, we need to find where the logic lives. Is it in the workflow? A trigger? It might be hidden in a legacy integration from when we started working together. That's 30 minutes wasted searching, assuming we remember the system well.
Hour 2-3: Map out all the places where this change can break things. We want to avoid breaking something else while fixing your original request.
Hour 4-5: Make the change and test it. Like, actually test it, not just click around for 2 minutes. We need to make sure we haven't broken anything else. We can't simply push a change and hope for the best.
We need to test it on a staging server. Does the notification fire correctly? Does it hit the right people? If it's an internal tool for your team, a quick spot check is fine (about 20 minutes). But if it's client-facing? One wrong move and your customers get spammed.
Hour 6-8: Clean up things we accidentally found. If we're already in there, we might as well fix the three other things held together with duct tape. Then, we deploy it. Even with low-code, this isn't instant. Call it another 15-30 minutes.
Why does it feel worse than it should
Much of this complexity is unnecessary. It exists because:
- Systems get built quickly under pressure
- "Quick fixes" pile up over time
- Nobody has time to clean up the foundation
- We're always fighting fires instead of preventing them
Renovating a house while people are living is challenging. You can't just tear down walls.
What now?
We could make that one-line change and call it done in 2 hours instead of 8. But then the next similar request will also take 8 hours. And the one after that.
Changing even the simplest things becomes hard when the system is too complicated.
We need to fix things, not apply a temporary solution.
Yes, it costs more upfront. But it's the difference between:
- Spending 8 hours every time you need a small change
- Spending 1-2 hours for the same change once we've cleaned things up
It's not sexy work. There are no new features to show off. But it's the difference between a system that works for you versus one that works against you.
The bottom line
That "simple" change took 8 hours because the system has developed over time. It is complex in ways that aren't obvious on the outside.
I'm not padding the estimates. I am being honest about what it takes to do the job.
The main question is not "Why is this taking so long?" but "How can we speed this up next time?"
