How to estimate a software project honestly

To estimate a software project, give a range, name the risky parts that decide where in the range the work will finish, and test the riskiest part before you commit to the whole. For the cost, multiply the people by the weeks and by each person's weekly cost, add a reserve for each named risk, and add what the software costs to run after launch. Reveneau estimates this way: AI writes all of its code, every change has to pass an eval suite written from the specification, and because it uses AI instead of hiring more engineers, the same build takes a small team and that saving goes into the client's price.
Someone asks how long the project will take, and the pressure is to answer with a single number. Eight weeks. Ninety thousand dollars. It sounds decisive. For software work that is new, that single number is a guess presented as a promise, and everyone in the meeting treats it as a commitment. When it turns out to be wrong, the story becomes that the team was slow or the estimate was careless. The usual cause is different: the question had no single-number answer, and the parts that took longer than planned were the parts nobody measured.
How much does custom software development cost, and how do you estimate it?
A custom build costs the people on it, times the weeks they work, times what each person costs per week. Add a reserve for each risk you have named, and the cost of running and changing the software after launch. Give the total as a range, because the weeks are a range.
Build the estimate in five steps:
- Break the work into pieces small enough that a team can say how many people each needs and for how many weeks.
- Price the weeks. The US Bureau of Labor Statistics publishes the median wage for software developers in its Occupational Outlook Handbook (read 18 November 2026). A supplier's weekly rate is higher than the wage, because it also pays for benefits, tools, offices and its own margin.
- Add a reserve for each named risk, such as an outside system nobody has tested yet, and write the risk next to the amount.
- Add the cost after launch: hosting, monitoring, security updates and changes, paid every month the software runs.
- Choose the price form. A fixed price fits work whose scope is settled. Time and materials fits work that still has open questions.
The table is a worked example with made-up figures, to show the arithmetic.
| Part of the estimate | Low | High |
|---|---|---|
| Build: 3 people for 10 to 14 weeks at $5,000 per person per week | $150,000 | $210,000 |
| Reserve for one named risk: 1 person for 2 to 4 weeks at the same rate | $10,000 | $20,000 |
| Total to launch | $160,000 | $230,000 |
The cost after launch is a separate line. For the same arithmetic with the BLS wage applied to two team sizes, read what custom software costs when writing the code is cheap. For how the price form changes who carries the risk, read how to price an ongoing retainer vs a fixed project.
AI changes the people column: Reveneau uses AI instead of hiring more engineers, so the same build takes a small team. The weeks still depend on how much of the work is undecided when the build starts, and that is where the range is widest.
The single number is the mistake
New software has parts nobody has worked out yet. That comes with building something that did not exist before, and a good plan still has them. Because those unknowns exist, the honest answer to how long the work will take is a spread of possible outcomes. Reducing that spread to a single number hides the uncertainty without removing it, and hidden uncertainty is the most dangerous kind, because everyone plans around the number as if it were certain.
When you force a single number out of an estimator, you push them toward one of two bad choices. They add a large amount of extra time to cover everything they cannot see, which makes the work look more expensive than it may be and hides the real situation. Or they guess low, often to sound confident or to win the work, and create an overrun that appears later as delays and extra cost. Either way, the single number has taught the people relying on it the wrong thing. The same applies to price: the price of anything new depends on how much you still do not know, and a confident number leaves the unknown where it was.
Give a range, and let the width mean something
The honest alternative is a range. In place of "eight weeks," you say "likely six to ten weeks," and then you say what would push you toward each end. That extra sentence holds the real information.
The width of the range measures how much you do not yet know, and it is one of the most useful things you can tell someone. Work you understand and have done before gets a narrow range, because there is little uncertainty to show. Work full of new problems and open questions gets a wide range, because a narrow one would be false. A stakeholder who sees a wide range learns something true and important: this part is uncertain, so the plan around it should stay flexible, and the team should find ways to reduce the uncertainty. A stakeholder handed a single number learns only a date to be disappointed by.
A range also changes the conversation. The discussion moves from "is the number right" to "what would make this finish at the good end instead of the bad end," which is a question you can do something about.
Break the work down to reduce what is unknown
A range is more honest, and you also want it as narrow as it can truthfully be. The way to get there is to turn unknown work into known work, by breaking the work into small pieces.
A big, vague piece of work, "build the backend," is nearly impossible to estimate well, because all its uncertainty is hidden inside it where you cannot see it. Break it into small, concrete pieces and two good things happen. First, most of those small pieces turn out to be things you understand, and understood work is easier to estimate. Second, and more useful, the breakdown makes the risky parts visible. That one tricky integration, that one unclear requirement, that one hard problem: they were hidden inside the big piece, where they would later have ruined your estimate, and now they are named pieces you can see and reason about. Strong teams deliver in small increments for the same reason, as move fast without breaking the product sets out. Smaller pieces are easier to estimate, easier to correct, and easier to learn from.
Unscoped risk is what ruins estimates
The most common reason estimates fail is unscoped risk: work that was uncertain, complex, or unknown at the time of the estimate, and that nobody accounted for at all. The parts you never estimated are, again and again, the parts that take longer than planned, because they were the hard parts, which is why they were unclear in the first place.
The numbers on this are clear for large projects. A study by McKinsey and the University of Oxford of large IT projects found that they ran on average 45 percent over budget while delivering 56 percent less value than predicted. Those overruns come mostly from unknowns that were never measured: risky pieces that were assumed to be simple, dependencies that turned out to be complicated, requirements that were less clear than anyone admitted. And the bigger the project, the worse it gets, because a big project combines many uncertainties, and they add to each other. This is one more reason to keep the pieces small: it keeps the risk small enough to see and account for.
So when you estimate, spend most of your attention on the risky, unclear parts. The known work will finish close to its estimate. The unknown work decides whether the whole project succeeds or fails, and treating a risky unknown as if it were a simple known is the mistake that produces a confident estimate and a painful overrun.
Reduce the uncertainty before you commit
The most reliable way to give a better estimate is to reduce the uncertainty behind it before you commit. If a piece of the work is both risky and hard to measure, the right step is often a small, quick experiment that tests that unknown directly, done before you put a number on the whole project.
If you do not know whether an integration with someone else's system is simple or hard, build a small test against it in a few days and find out. If you are not sure whether a technical approach will work, try the hardest part of it first, on its own, before making the plan depend on it. An estimate made after you have tested the risky parts is worth more than one made while they are still unknown, because you have turned a guess into knowledge where the guess was most dangerous. This is also the honest answer to a stakeholder who demands one firm number and date on new work: offer to start with a small first piece that reduces the biggest unknowns, and then give a narrower estimate on the rest.
AI writing the code changes which part of the estimate is uncertain. The build phase became more predictable: producing a working first version of a well-specified thing now takes days and varies little. The work on either side of it stayed unpredictable. Deciding what you want takes as long as it did, and checking the output and making it reliable is where most of the variation now is. So the shape of an honest estimate changed. The wide range belongs on the specification and on the work to make the output reliable. The narrow range belongs on the build, which used to be the part nobody could predict.
Sources
- US Bureau of Labor Statistics, "Software Developers, Quality Assurance Analysts, and Testers", Occupational Outlook Handbook, pay section (median annual wage for software developers; read 18 November 2026): https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
- McKinsey and University of Oxford (2012), "Delivering large-scale IT projects on time, on budget, and on value": https://www.mckinsey.com/capabilities/tech-and-ai/our-insights/delivering-large-scale-it-projects-on-time-on-budget-and-on-value

