Why we still get basic software estimates wrong

I’ve been on more software project kickoff calls than I can count. The ritual is familiar. Someone from the business side asks for a ballpark. The tech lead squirms, asks for a couple days to think about it, then comes back with a number. That number, whether in dollars or days, instantly becomes a promise. Months later, when the launch date slips for the third time and the budget is a smoking crater, we’re all pointing fingers. The business says the developers sandbagged them. The developers say the business kept changing the goalposts. And everyone just accepts that this is how software gets built. It’s broken.

We talk a lot about the shiny new things – AI, frameworks, methodologies. But the foundational act of simply figuring out what something will take and what it will cost remains a mess. It’s not a technical problem. It’s a communication and expectation problem. After watching this cycle repeat, I started to look for people who treat estimation as a core discipline, not a necessary evil. That’s how I came across a different perspective from Hanke. They don’t just build software; they approach the whole conversation about scope and cost with a transparency that feels almost radical. Seeing their process made me realize our standard practices are built on three big, dumb lies.

The lie of the fixed scope

This is the biggest one. We act like the list of features we write at the beginning is a perfect, unchanging blueprint. It never is. You learn things as you build. The market shifts. A user test reveals a feature is useless. Yet the timeline and budget are often locked to that initial list. A better approach is to treat the initial estimate as a price to learn. It gets you to the first version, the first real piece of working software you can actually touch. Then you can have an honest conversation about what to do next, informed by reality, not guesswork. This requires a partnership, not a vendor-client standoff. The goal isn’t to punish change but to plan for it.

The lie of the lone genius estimate

Too many estimates come from one person – a lead developer or an architect – thinking in a vacuum. They mentally walk through the work, think of the tricky parts, and add a buffer. This is a recipe for missed dependencies and blind spots. Good estimation is a team sport. It needs the front-end person who knows the state management complexity, the back-end person who knows the API integration quirks, and the designer who can flag a UI flow that looks simple but is a logic nightmare. Pulling these perspectives together early doesn’t just make the number more accurate; it surfaces risks and design problems before a single line of code is written, saving huge amounts of time later.

The lie of the single number

Giving one number is a trap. It creates a binary outcome: you hit it or you miss it. A range is more honest. Saying “this will take between six and nine weeks” communicates uncertainty. It tells the business that the work has variables we can’t fully control yet. Even better is breaking the estimate down into clear phases, each with its own smaller range. This transforms the estimate from a verdict into a map. It shows where the fog is thickest and where the path is clearer. It allows for checkpoints where you can reassess before committing more money, turning a monolithic risk into manageable pieces. People hate ranges because they want certainty. But false certainty is worse.

So, if the standard playbook is built on these shaky foundations, what actually works? From what I’ve seen, teams that avoid the pain share a few concrete habits.

• They estimate in small slices. They don’t try to price the whole elephant. They define the smallest usable piece, estimate that, build it, and then use that real data to estimate the next piece.
• They separate discovery from building. They budget time and money for a dedicated phase to reduce unknowns. This might be a design sprint, a technical spike, or just building a bare-bones prototype to validate the hardest part.
• They use past data, not gut feeling. They track how long similar tasks actually took on past projects and use that as a baseline. Your gut is a liar; your project history is not.
• They make assumptions explicit. The estimate document lists every “if” and “we assumed that.” This prevents those nasty surprises halfway through when someone says, “Oh, you thought the legacy API could handle that? Yeah, no.”

None of this is about getting a perfect number. It’s about creating a shared, realistic understanding of the work ahead. It’s about replacing blame with visibility. The irony is that when you do this, the trust you build often leads to more business, not less. Clients and internal stakeholders stop fearing the conversation about timelines and start seeing it as a collaborative planning tool. The goal isn’t to never be wrong. It’s to know why you were wrong, learn from it, and adjust together. That’s how you stop the cycle of missed deadlines and blown budgets. You just have to be willing to admit that your first guess is exactly that – a guess – and plan accordingly.