How to estimate a software project reliably
Software project estimation without guesswork: why single figures fail, how to estimate in ranges, set contingency and judge any estimate you receive.


You have to commit to a budget and a date for a new application, and someone asks the question nobody likes: “How long will it take?” A single confident number is tempting, and it is usually where the trouble starts. Reliable software project estimation is less about guessing well than about saying clearly what you know, what you don’t, and how much room you need for the gap.
This guide explains why one-figure estimates fail, the techniques that give you a range instead, how to set contingency and assumptions, when to re-estimate, and how to judge an estimate a provider sends you. A worked example, with fictitious figures, shows the method end to end.
Software project estimation: why a single number fails
An estimate made at the start of a project is a forecast about work nobody has done yet. Some screens turn out simpler than expected; others hide a data problem or an awkward integration. A single figure hides that spread, so the first surprise becomes an “overrun”, even when the work was done well.
Three things make early estimates uncertain:
- The scope is still moving. Until the requirements are written and agreed, everyone estimates a different project in their head.
- Some risks are still hidden. An old database, a poorly documented Application Programming Interface (API) or a rule only one person understands can each add days.
- Estimates become promises. A “rough idea” given in a meeting is remembered as a commitment.
The answer is not to refuse to estimate. It is to estimate as a range, attach the assumptions behind it, and narrow the range as you learn. What drives the size of the bill (integrations, platforms, data) is covered in our article on what custom software costs; here we focus on the method.
Software estimation techniques that give you a range
No technique suits every project. We usually combine two, and look closely wherever they disagree.
Breakdown (bottom-up)
Split the project into pieces small enough to picture: a screen, a report, an import, a notification. Estimate each piece, then add them up. The list itself exposes forgotten work such as testing, data import, deployment and training. A breakdown is only as good as the scope behind it, which is why a clear software requirements specification is the best investment before asking for a figure.
Three-point estimating
For each piece, give three numbers: optimistic (O, everything goes smoothly), most likely (M) and pessimistic (P, the realistic bad case, not a catastrophe). A common weighting, from the Program Evaluation and Review Technique (PERT), gives an expected value of (O + 4M + P) ÷ 6. The method brings risk into the open: a piece with a wide gap between O and P is a piece you don’t yet understand.
Analogy
Compare the project with similar ones you or your provider have delivered: “the last booking module took about this long”. Analogy is quick and grounded in real outcomes, but only when the projects really are alike. Ask what was different last time.
Relative sizing
Agile teams often size work against a reference task, with points or T-shirt sizes (S, M, L, XL), rather than in days. After a few iterations, the team’s measured pace turns sizes into dates. It works well for planning the next few weeks, less well for a first budget, when there is no measured pace yet.
A worked example of three-point estimating
Illustrative example (fictitious figures). A small service business wants an online booking tool for its customers. The scope is written down and broken into six pieces, estimated in days of effort.
| Piece of work | Optimistic | Most likely | Pessimistic | Expected |
|---|---|---|---|---|
| Customer accounts and login | 3 | 5 | 9 | 5.3 |
| Booking calendar | 6 | 10 | 18 | 10.7 |
| Email reminders | 2 | 3 | 6 | 3.3 |
| Admin screens and reports | 4 | 6 | 12 | 6.7 |
| Import of the existing client list | 1 | 2 | 6 | 2.5 |
| Testing and go-live | 4 | 6 | 10 | 6.3 |
| Total | 20 | 32 | 61 | about 35 |
Three things stand out. The sum of the “most likely” values (32 days) is below the expected total (about 35), because work tends to slip more than it speeds up. The booking calendar has the widest gap, so it is the piece to clarify first, perhaps with a short prototype. And the pessimistic total (61 days) is not a realistic plan either: everything rarely goes wrong at once.
The business plans on about 35 days, holds a contingency of 7 days for the named risks, and commits to a range of 35 to 42 days, with its assumptions written next to it.
Project contingency and assumptions
A range only means something with the assumptions that produced it. Write them down, in plain words, next to the figure:
- what is in scope and, just as important, what is not;
- what the client provides, and by when: content, test data, decisions, access to existing systems;
- the technical bets: “the payment provider’s API supports refunds”, “the old data can be exported”;
- who tests, and how much time they have.
Project contingency is the reserve for risks you can name but not yet size; a simple project risk register keeps them listed, scored and assigned to an owner. Keep it visible and separate from the base estimate rather than spreading it quietly across every line: a hidden buffer gets spent, a visible one is drawn on deliberately, with a reason. There is no universal percentage. The wider your three-point ranges and the more assumptions you rely on, the larger the reserve.
Contingency covers risk inside the agreed scope. New requests are changes: they get their own estimate and their own decision.
Re-estimating as the project moves
An estimate is not a one-off event. The range should narrow as uncertainty turns into knowledge, at predictable moments:
- When the specification is agreed and the scope stops moving.
- After a prototype or first iteration, once the team has a measured pace.
- When an assumption breaks, for example when the old data is messier than expected.
- At each milestone, comparing actual effort with the estimate, piece by piece.
Re-estimating is not admitting failure. It is how a sponsor keeps control of the budget instead of discovering the problem at the end.
Delivering in releases helps a great deal. When our founder, Anass Chabbab, in his previous roles as IT director of DIGIIT Solutions, led a custom CRM/ERP (customer relationship management and enterprise resource planning) system for a Sydney law firm, the first release came in under 6 months, and the system went on to serve more than 100 users. A first release with a clear scope is far easier to estimate than a whole system. It is also how we plan custom software today: in releases, each with its own range.
How to judge a software project estimate you receive
When a provider sends you a figure, run through this checklist before you sign:
- It is a range, or it states its confidence. A single precise number for a large project is a warning sign, not a strength.
- It shows the breakdown, including testing, data import, deployment and training.
- The assumptions are written down, with what is out of scope.
- The risks are named, and the contingency is visible rather than buried.
- It matches your specification. If the provider estimated something else, you will see it here.
- Re-estimation points and change requests are planned for.
- The provider asked questions first. A figure produced in an hour from a two-line email is a guess.
If two quotes differ widely, compare their breakdowns and assumptions before their totals: the gap usually comes from scope, not efficiency. Our guide to choosing an IT provider covers the rest of the selection. The type of contract matters too: fixed price and time and materials share the risk of an overrun in different ways.
Frequently asked questions
How accurate can a software estimate be at the start?
Not very, and an honest provider says so. At the idea stage the scope is vague and the risks are untested, so the range is wide. It narrows once the requirements are agreed, and again after the first iteration, when the team has real data on its pace. Ask for the current range and for when it will be refined, rather than for a precise figure too early.
What is three-point estimating?
Three-point estimating gives each task an optimistic, a most likely and a pessimistic value instead of a single number. A common formula weights them as (optimistic + 4 × most likely + pessimistic) ÷ 6 to give an expected value. Its real benefit is the conversation it forces: tasks with a wide gap between the optimistic and pessimistic values are the ones to clarify or prototype first.
How much contingency should a software project have?
There is no universal figure. Contingency should reflect the uncertainty you actually measured: the width of your estimate ranges, the number of untested assumptions and the risks you can name. Keep it as a separate, visible reserve, drawn on with a reason, and review it at each milestone. New features requested along the way are changes to estimate separately, not a call on contingency.
In short
A reliable estimate is a range with its assumptions, not a single number. Break the work down, estimate each piece with three points or by analogy, and keep a visible contingency for the risks you can name. Re-estimate at predictable moments, and judge any estimate you receive by its breakdown and assumptions before its total.
Need a budget and a date you can defend? Book a free 30-minute discovery call on Google Meet: we look at your project together and at how to put a reliable range on it. For a project that is already defined, a 60-minute scoping workshop can follow.
Related servicesCustom softwareSaaS products
Let’s talk about it on a 30-minute discovery call, free and with no obligation.
Get our next articles in your feed: follow AnazTech on LinkedIn.Follow on LinkedIn






