How to estimate a software project as a team: who estimates what, and when

Published 3 November 2026


Give every part of the project an owner - the person who will build it - and have each owner estimate their part alone, as hour ranges, before anyone compares numbers. Have two people estimate the riskiest tasks independently. Then hold one short review of only the lines that need it: the widest ranges, the tasks where two estimates disagree, and the work no one owned. Settle disagreements by writing down the assumption behind them, never by averaging.

The order matters more than the technique. This guide covers why the first number spoken in a meeting distorts every number after it, how to run a team estimate without that happening, and a worked example with a four-person agency.

Why one person’s estimate misses

In most agencies the estimate is written by whoever writes the proposal. They know the client and the commercial picture. They do not know that the payment provider’s webhooks are unreliable in test mode, or that the designer’s wireframes include a screen nobody mentioned on the call.

A solo estimate misses in two predictable ways:

  • The numbers are guesses about other people’s work. The proposal writer’s estimate of the integration is not the integrator’s. It is usually lower, because the hard parts of a task are only visible to someone who has done it.
  • Work with no owner disappears. Project management, client demos, code review, the deploy - work that belongs to no one’s specialism is the work a single estimator forgets, because nobody’s experience reminds them of it.

Asking the team fixes both, but only if you ask in the right order.

The first number spoken sets the estimate

Jorge Aranda and Steve Easterbrook at the University of Toronto tested this in 2005. Participants, more than half with real estimating experience, estimated the same project from the same requirements. The only difference was one quote in the brief, from a client manager who admitted to having no experience with software. In one version he guessed the project would take 2 months; in another, 20; in the control, he declined to guess.

The average estimates were 6.8, 8.3 and 17.4 months. A guess labelled as uninformed, from someone with no part in the estimate, more than doubled the answer. It was a small study - 23 participants - but anchoring is one of the most replicated effects in judgement research.

In an estimating meeting, the first number does not come from a stranger who admits to knowing nothing. It comes from the senior developer, the founder, or whoever speaks first - and there is no reason to expect it to pull less.

That is why the estimating methods that have lasted share one rule. Wideband Delphi, from the 1970s, and planning poker, from agile teams, both have every estimator commit to a number before anyone hears another. And discussion afterwards helps: a study of planning poker in a software company found that estimates agreed after discussion were less optimistic, and more accurate, than the average of the same people’s individual estimates (Moløkken-Østvold, Haugen and Benestad, Journal of Systems and Software, 2008). Independent numbers first, then talk.

The method, step by step

1. Give every category an owner

Split the estimate into the categories the work moves through - discovery, design, backend, frontend, launch - and give each one an owner: the person who will do that work, or the most senior person who has done it before. One owner per category, even if three people will work on it. The owner does not have to estimate every line alone, but they answer for the section.

Then look for the work that belongs to nobody: project management, client meetings, QA, deployment, handover. Give it an owner too, or it will not be in the estimate.

2. Collect numbers before anyone talks

Each owner estimates their own section as hour ranges - “12 to 20 hours”, not “16” - without seeing anyone else’s. A low and a high on every task, and a sentence on any line where the range is wide, saying why.

For the two or three tasks most likely to sink the budget - the largest lines, the third-party integrations, anything nobody has built before - ask a second person to estimate them blind as well. Two numbers for the same task, made without seeing each other, are the cheapest way to find out whether the task is understood.

3. Review only the lines that need it

The review is not a read-through of the whole estimate. Thirty lines of “looks fine” wears everyone out before the lines that matter. Go through only:

  • Disagreements. Any task where the two blind estimates are far apart.
  • The widest ranges. A task where the high is more than double the low is a task with an open question in it. Can the question be answered now?
  • Unowned work. Read the owners’ list again and ask what is missing.

4. Settle disagreements with assumptions, not averages

When two estimates for the same task are far apart, the estimators are almost never disagreeing about how long the same work takes. They are picturing different work. Ask each what they assumed, and the gap usually turns into one of two things:

  • A hidden task. One person knew about work the other did not. Split it out into its own line with its own range.
  • An open scope question. Find the answer, or write the assumption into the estimate - “monthly plans only; proration in a later phase” - so the range is tied to something the client can read.

Averaging a 12-hour estimate and a 36-hour one produces 24 hours for a task neither person described. It looks like a compromise and is a guess.

5. One person turns the hours into a price

Once the hours are settled, one person - the account lead, usually - turns them into a price: the rate, the buffer, fixed price or time and materials. That is a commercial decision, and it should not reach back into the hours. If the total is too high, cut scope with the team, or change the price knowingly, as covered in how to price a fixed-bid project. Do not shave the developers’ numbers until the total looks sendable.

A worked example

Say a four-person agency - an account lead, a designer, a backend developer and a frontend developer - is quoting a web app MVP, starting from the Web App MVP template: 26 tasks adding up to 290-564 hours. The agency bills €75/hour. Owners first:

Category Owner Template range
Discovery & Planning Account lead 20-44 hours
Design Designer 40-72 hours
Backend Backend developer 80-156 hours
Frontend Frontend developer 78-148 hours
Billing & Accounts Backend developer 24-48 hours
Launch Both developers 48-96 hours

Each owner checks their section against this client’s scope - to keep the arithmetic simple, say the template ranges hold. Two lines get a second, blind estimate: “Core feature screens”, the largest line in the template at 40-80 hours, and “Payment provider integration” at 12-24. The review then finds three things.

The screens hid a task. The frontend developer estimated the core screens at 40-80 hours. The designer, asked to estimate the same line, said 70-120. Asked why, the designer pointed to the wireframes: one screen is a drag-and-drop scheduling board, which the frontend developer had not seen. The board becomes its own task at 24-40 hours, and the core screens stay at 40-80.

The payments line hid an assumption. The backend developer said 12-24 hours; the frontend developer said 24-40. The frontend developer had heard on the kick-off call that the client wanted monthly and annual plans with upgrades mid-cycle - proration, which the backend developer had not priced. The account lead checks with the client: monthly plans only for the first version. The line stays at 12-24 hours, with the assumption written on it.

Project management had no owner. Nobody’s section included the weekly client demo, sprint planning or the account lead’s coordination. The template has no line for it, and neither did anyone’s category. Over a twelve-week build, a weekly one-hour demo with three people attending is 36 hours before any preparation or client email. It goes in at 40-60 hours.

The total moves from 290-564 hours to 354-664. At €75/hour, the high end goes from €42,300 to €49,800 - a quote built on the template alone would have been €7,500 short at the high end, before any buffer, and the shortfall would have come out of the margin.

Note what the review did not do: it did not make every number bigger. The payments line stayed where it was, protected by an assumption the client can see. The team estimate is not more pessimistic than the solo one. It is more complete.

Mistakes that undo a team estimate

  • Estimating out loud in a meeting. The first number spoken becomes the anchor for every number after it. Collect numbers first.
  • The most senior person going first. If a meeting is unavoidable, have the senior people speak last.
  • Averaging disagreements away. The gap between two estimates is the most useful thing the second estimate produced.
  • Reviewing every line. A review that spends equal time on a 4-hour task and a 60-hour one runs out of attention before the 60-hour one.
  • Trimming the team’s hours to win the deal. Change the price or the scope, openly. Hours that were quietly cut come back during the project.

Check against last time

Your past estimates are the best reference you have. If your team quoted a Stripe integration four times in the last year, the fifth estimate should start from those four, not from a blank line.

Past estimates tell you what your team expected last time, not what it took. If you track time, compare the two after each project and move the ranges in your template accordingly - that is how a template becomes yours, as covered in what a software estimate template needs.

What Estimake does here

Estimake is built for the estimate a team writes together:

  • Everyone works in the same estimate at once. You see who else has it open, a row locks while a teammate edits it, and changes reach everyone as soon as a row is saved. No merging spreadsheets the night before the quote goes out.
  • A low and a high on every task, with a description on any line to say why the range is wide or which assumption it depends on.
  • Suggestions from your own history. Start typing a task and Estimake offers the tasks and hour ranges your workspace used on earlier estimates.
  • A rate per category, if design and backend bill differently.

There is no blind mode: a number is visible to everyone in the estimate as soon as its row is saved. For the two or three tasks that need independent estimates, collect those numbers privately first - a message to the account lead is enough - and enter them after the review. Estimake does not track time either, so comparing estimates with actual hours needs a time tracker.

The free plan has one member, so estimating as a team needs Studio, which covers up to 10 members; Agency has no limit. Every new workspace starts with 14 days of Studio, no card - the pricing page has the rest.

An estimate is only as good as what its author knew. Get the people who know the work to write it, in an order that keeps their numbers their own.

Frequently asked questions

How many people should estimate a software project?

The people who will build each part of it - for most agency projects that is three to five. Every category of work needs one owner, and the two or three riskiest tasks need a second estimator. Beyond that, extra people add opinions faster than they add knowledge, and the review stops being about the numbers.

Should we use planning poker for a client estimate?

Keep its rule, not its cards. Planning poker is built for sprint backlogs in story points; a client quote needs hours, ranges and a total. The part worth keeping is that everyone commits to a number before hearing anyone else's, and discussion happens only where the numbers differ. A private first pass followed by one review does that for a 30-task estimate.

What do you do when two developers' estimates are far apart?

Ask each of them what they assumed. A gap of two or three times almost always means they were estimating different work - one knew about a requirement the other did not. Settle it by writing the assumption down, then either splitting the hidden work into its own task or agreeing the scope with the client. Do not average the two numbers; the average is an estimate of a task nobody described.

How long should a team estimate take?

For a typical agency project of 20 to 40 tasks, an hour or two from each owner on their own section, then a review meeting of under an hour. If the review keeps running long, the scope is not clear enough to estimate yet - run a short paid discovery phase first.

Should the account lead adjust the team's hours?

No. The hours are the team's prediction of the work; the price is a commercial decision. If the total is too high to send, cut scope with the team or change the price - the buffer, the rate, the pricing model - but leave the hours as the people doing the work estimated them. Quietly trimmed hours are how a quote gets sold at a loss.

Estimate your next project in Estimake

Build the estimate with your whole team at once, keep every number a range, and send it to the client as a branded link. Free for your first estimates - no credit card.

Start estimating freeSee how Estimake works

Copyright © Estimake 2026.

Payments are processed by Paddle.com, our merchant of record.
Features