In this article
Every software estimate is a guess. The difference between a useful one and a useless one isn't precision. Nobody can predict a six-month project to the day. It's honesty about what is known and what is only assumed, and most estimates blur that line badly.

Why estimates are usually wrong in one direction
Ask a developer how long a feature will take and the instinct is to answer with the time it takes if nothing goes wrong. No awkward cases, no surprises in the existing code, no back-and-forth on the requirements. That number is real, but it's the floor, not the estimate. The actual time is almost always the floor plus everything that predictably goes slightly wrong along the way - and predictable slippage is not the same as bad luck.
An estimate that only reflects the happy path isn't optimistic. It's incomplete.
Break the work down before you estimate it
A single number attached to "build the app" is close to meaningless - there's no way to sanity-check it, and no way to tell later which part went over. Break the project into pieces small enough to estimate one by one, each a few days at most. You can then check your assumptions against real progress, and you can see clearly where the uncertainty is.
- Large, vague tasks hide their own uncertainty; small tasks expose it
- A list of ten three-day tasks is easier to sanity-check than one thirty-day task
- When a small task consistently overruns, that's useful signal about where the real complexity is, not just bad luck
The three numbers worth tracking
Three numbers tell a more honest story than a single estimate: the best case if everything goes smoothly, the realistic case based on how similar work has actually gone, and the worst case if a real risk happens. Planning around the middle number, with the outer two as your honest range, survives contact with reality far better than a single confident figure that quietly assumes nothing will go wrong.
Need help scoping something before you commit budget?
What actually causes overruns
It's rarely the coding itself. The two biggest causes of delay are requirements vague enough to mean two different things to two different people, and connections to other systems that nobody fully understood until the work was underway. Think of a payment provider's awkward cases, an old database with undocumented quirks, or an outside service that doesn't quite do what its documentation says.
Both are avoidable, not by estimating harder, but by getting specific about scope up front and testing the risky connections early, before the rest of the plan depends on them.
Padding is not the same as honesty
Adding a flat 20% to every estimate "just in case" is a common habit, and it solves the wrong problem. It doesn't tell anyone where the actual risk is, and it trains a client to always discount the number they're given, since they've learned it's already padded. A better estimate names the specific risks and what would set them off. Then the number can be trusted, and a client can see exactly what would have to happen for it to change.
An honest estimate isn't the one that's least likely to be wrong. It's the one where everyone involved understands exactly what the number does and doesn't include.
Written by the 101Turn studio
A small studio in Ahmedabad, India building apps, websites and SaaS products. If this touched something you are working on, we reply within one working day.
Want an honest estimate for your project?







