Strategy

How to estimate a software project honestly

Editorial · Reveneau · August 21, 2026 · Updated November 18, 2026

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:

  1. Break the work into pieces small enough that a team can say how many people each needs and for how many weeks.
  2. 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.
  3. Add a reserve for each named risk, such as an outside system nobody has tested yet, and write the risk next to the amount.
  4. Add the cost after launch: hosting, monitoring, security updates and changes, paid every month the software runs.
  5. 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

Common questions

How much does custom software development cost?

Count the people on the build and the weeks they work, multiply by what each person costs per week, add a reserve for each risk you have named, and add the cost of running the software after launch. Give the result as a range. A single figure for a build nobody has scoped is a guess, whoever gives it.

Why is a single-number estimate a bad idea?

Because a single number hides how uncertain the work is. New software has parts nobody has worked out yet, so the honest answer is a range of possible outcomes. A single number forces the estimator to either add a large amount of extra time or guess low, and either way it hides the uncertainty that decides the result.

What is a good way to estimate a software project?

Give a range instead of a single number, and say what would push you toward each end. Break the work into small pieces so more of it becomes known, estimate the pieces, and name the risky parts you cannot yet measure. A range with clear assumptions is more honest and more useful than a confident single number.

Why do software estimates go wrong so often?

The usual cause is unscoped risk: work that was uncertain, complex, or unknown at estimate time, and that nobody accounted for. Research on large IT projects by McKinsey and the University of Oxford found they ran 45 percent over budget on average, largely because they are big and full of unknowns. The cause is usually risk that nobody measured, and the team's speed is a smaller factor.

What does it mean to give an estimate as a range?

It means saying "this is likely six to ten weeks" in place of "this is eight weeks", and explaining what decides where in that range the work will finish. The width of the range should match how much you do not yet know. Work you understand and have done before gets a narrow range. New, uncertain work gets a wide one.

How does breaking work into smaller pieces help estimates?

Small pieces are easier to understand, so more of the work moves from unknown to known, and known work is easier to estimate. Breaking down the work also shows the risky, unclear parts that were hidden inside a big, vague piece of work, so you can name them before they surprise you later.

What is unscoped risk?

It is the work you did not account for because you did not see it or did not understand it yet: a tricky integration, an unclear requirement, a hard technical problem, a dependency on someone else. Unscoped risk is the most common reason estimates fail, because the parts you never measured are the parts that take longer than planned.

Should I add extra time to my estimate to be safe?

Adding extra time to a single number is a crude way to handle uncertainty, and it hides the real situation. Give a range and name the risky parts, so everyone can see where the uncertainty is. Then you can reduce that uncertainty on purpose, where a bigger number would only hide it.

How can I make an estimate more accurate?

Reduce the uncertainty before you commit. Break the work down, and for the riskiest unknowns, run a small, quick experiment to learn how hard they are before estimating the whole thing. An estimate made after you have tested the risky parts is more reliable than one made while they are still unknown.

Why are big projects harder to estimate than small ones?

Because a big project combines many uncertainties, and they add to each other. More parts means more assumptions, more places where a wrong guess early on breaks something later, and more risk that goes unscoped. Estimating and delivering in smaller pieces keeps the uncertainty small enough to reason about and correct.

What should I tell a stakeholder who wants one firm number and date?

Tell them the honest version: for new work, one firm number is a guess presented as a commitment, and it usually costs more in the end through overruns and rework. Offer a range with the assumptions written down, and offer to reduce the uncertainty by starting with a small first piece so the next estimate is more reliable.

How does Reveneau estimate work?

We give ranges with the risky parts named next to them. Where the uncertainty is high, we propose a small first piece to test the hardest unknowns before committing to the whole. AI writes all of our code and every change has to pass an eval suite written from the specification, and because we use AI instead of hiring more engineers, the same build takes a small team and that saving goes into the client's price.

Start a project