1. Never give an estimate in the same conversation in which it was requested, unless you're quite sure the answer is "less than an hour". Especially if they are going to turn around and quote your timeframe to a customer. The reason for this rule is:
2. The more you think about an estimate, the higher it will go. "Oh yeah and we'll also have to..." is 100x more common than "I found a shortcut that doesn't compromise on..."
3. Even if they know it's an estimate and not a deadline, they might not know the difference between "40 hours of dedicated effort" and "One week's worth of business hours". Making that distinction is just as important as the estimate/deadline distinction.
I'm lucky to work where we don't spend much effort on estimates and time tracking, both of which just make things take longer and cause productivity-reducing stress.
The distinction between labor time and calendar time is an important one! 40 hours of dedicated effort is great, but most people parse that as "1 week" when in reality the available people may only be able to get 10 or 20 hours in a week due to other demands, or it's 38 hours of dedicated time that gets done in 1 week but the 2 hours of security and legal reviews take a month of waiting to finally get completed.
> The more you think about an estimate, the higher it will go
This is excellent advice. At Apsis, we have a collection of "red flags" for any project that we call out specifically as likely sources of increased complexity and therefore a higher estimate. Some of these are:
* integrations external APIs
* existing tech from the client with no provided documentation
> 3. Even if they know it's an estimate and not a deadline, they might not know the difference between "40 hours of dedicated effort" and "One week's worth of business hours". Making that distinction is just as important as the estimate/deadline distinction.
This is the motivation for "story points", to avoid saying "hour" for the former.
(And secondarily, let the ratio of the two be discovered by analyzing previous work, in a stable team setting.)
When I switched from engineering to management, I spent a long time thinking about software estimates, read about many different approaches, and argued with many other managers (I’ll try to write up my own blog post for the next time the topic comes up on here).
The framing in this blog post is better than some (it at least discusses uncertainty) but I believe it’s still basically the wrong framework.
People (managers) like to assume that estimates are a random variable, and software projects are samples from project space. Estimates can be produced for a project by analogizing it to similar projects. This is not true at all. You cannot reason about software projects by analogy.
Some assertions (that I will explore in said promised blog post):
- Software development is chaotic: arbitrarily small changes in the input (project requirements, who’s implementing it, stakeholders, team, etc) may lead to arbitrarily large changes in time-to-completion (including “this project is now impossible”). In short, any project may explode at any moment prior to completion.
- The risk of a project is particularly sensitive to the engineer implementing it, and depends on that person’s specific knowledge. Have they used these APIs or this database before? Any part of a project that the engineer hasn’t used before represents potentially unbounded technical risk.
- the way to manage this risk is to include buffer in the project timeline, and, critically, to use that buffer not for development tasks that were harder than expected, but for re-planning and re-negotiating the deliverables with stakeholders, to un-explode the project. Agile builds this re-evaluation into the project lifecycle, which is the main (maybe only?) thing is does really right.
I agree that the points you raise are important to realise and affect delivery duration significantly.
I, however, disagree with that approach to managing delivery: if you tie in expected value with deliverables, you empower and enable engineering teams to smartly cut scope and deliver in shorter amount of time the biggest chunk of the value.
It's usually only described as "cutting scope", but it requires real creativity and smarts on the engineering team (they can best tell what's feasible in remaining time, when they have tackled all the unknown unknowns you bring up) to do that in a way that still brings the most of the original value. If you move this to your "renegotiation" step, it becomes too slow and hurts delivery as well.
I basically agree (I think) in that I don’t think there needs to be a separate “cutting scope” phase—one should it as soon as they realize they need to. And I certainly agree that it’s incumbent on engineering to invent alternatives and propose them when we realize that we need to cut scope (for the reasons you mentioned).
FWIW, though, engineers shouldn’t decide what to cut (i.e. choose alternatives) in a vacuum, in my experience. I’ve been in plenty of meetings with product/sales/support where they say “it’s better for the whole project to slip than to release it without this one detail” or “we would give up what seems like basic usability to get one particular piece of polish”
- the way to manage this risk is to include buffer in the project timeline, and, critically, to use that buffer not for development tasks that were harder than expected, but for re-planning and re-negotiating the deliverables with stakeholders, to un-explode the project. Agile builds this re-evaluation into the project lifecycle, which is the main (maybe only?) thing is does really right.
This is the only right answer. Unfortunately, engineering leadership is too detached from understanding how software works. They think of projects like contractor painting jobs. So easy to estimate - sq. ft * number of people * number of hours.
But software is not like that. Software is constantly changing every hour, every day. As a result, any estimation is changing every hour every day.
The best thing is for leadership to start acknowledging the realm they are dealing with. If they can't they should step down.
But realistically, engineers should always give 400% padding with estimates. The root cause of this estimation is poor leadership. It is not engineering team's problem that detached management doesn't understand software.
It's been several years since my colleague put this post together, but I think for us it's proven to be a very constructive framework for talking to clients.
It's probably worth calling out that we are, specifically, outside contractors providing estimates for clients --- usually clients at the start of their software development journey. I think a lot of our framework holds for developers working on in-house engineering teams, but there are bound to be some differences.
That said, I'll be curious to read your post whenever it goes up. Namely because I don't know what the conclusion of your comment is. Whether it's as a vendor or as an engineer on staff, estimates are a hard requirement of software development. Most stakeholders are not developers, and you can only educate the recipients of your estimates so much on the nuances of what is and isn't hard to accommodate. I don't really disagree with any of your assertions --- but isn't the re-evaluation process simply... more estimation? Aren't accounting for project risks --- like which developer is going to pick up the task, what requirements are likely or unlikely to change --- part of producing a quality estimate?
Communicating expectations is hard, and to me, one of the defining lines between junior and senior developers is the ability to clearly account for expected risks, and identify plausible but unlikely risks, and to incorporate mitigation into the plan of attack.
I agree, and in general I am very pro-estimates (they switch your team from cooperative scheduling to preemptive scheduling, and they’re an important tool for managing the chaos of development), but the statement “we expect this project to take eight weeks, but it could take 24 weeks in the worst case” is one I would be very loathe to make.
Granted, I’m coming from a B2B startup rather than a consultancy, so I was working with a mixture of internal (product, sales, support) and external (customers) stakeholders. The perspective I would try to give people, though, was this:
If we discover a bomb partway through the project (oops, groups are limited to 100 members in this auth system, so we will need to find a new system and migrate or else not support groups) then 8 weeks will no longer be enough, but maybe neither is 24. The right thing for us to do in that situation, IMO, is go back to the stakeholders and align on a new plan. Maybe groups will come in v2, or some groups will work and some won’t, or maybe we do the migration and add it to the estimate, or whatever. One shouldn’t use the 16 buffer weeks between 8 and 24 to sneak in a backend migration (which itself might be a 16-week project, or might not), but to pause and re-align on a plan everyone likes.
When I was giving estimates, I would try to frame them as “we’ll spend eight weeks trying to accomplish this list of things. If we discover an issue that prevents us from finishing the list for any reason, we’ll come back to you as early as possible with some alternative proposals and re-assess”. Sometimes people felt that this meant we just weren’t willing to commit to our estimates, and this idea of “software development is chaotic” is what I would say, to explain that the issue wasn’t a lack of motivation, but an inescapable knowledge risk that needed to be managed.
I find your framing interesting. But most importantly, even if nothing changes in the requirements or the team, the mere new information that is learned while implementing the project is often enough to change the estimate considerably.
Yes! In my last role, I aggressively pushed the concept of “technical risk” to try and get people used to this idea.
Sometimes the computers don’t work the way you thought they did at the beginning. This is a normal and ubiquitous form of risk that just needs to be managed like any other type of risk, with prototypes, multiple revisions of the implementation (each introducing additional risk), occasionally re-scoping, etc.
People outside engineering sometimes don’t like it because the risk is human in origin—it comes from engineers not knowing things, and our job is to know things—but until there’s an omniscient engineer, this risk will continue to exist.
That's too much of a carrot IMHO: I would have appreciated it more if you dove deeper into one of those points instead of promising a blog post on a dozen.
Edit: thanks for editing the comment to make it clearer what are your points. This makes my comment somewhat useless :)
> When you're communicating an estimate the most likely mistake is that the other party considers it to be a commitment.
The root cause is typically that you're communicating it to someone who doesn't want an estimate. In that case, communicating the estimate with the commitment is often a mistake unless you're willing to negotiate the commitment, because that's effectively what it invites.
An estimate is really a probability distribution, that often resembles a Gaussian distribution and thus can be captured with two numbers: the average and the variance. Combining multiple estimates together would involve some math around these two numbers. But the surprising thing is that managers in the software industry don't really understand probabilities, and to make it understandable those managers want to reduce the model to just one number, and when this model fails to capture the probabilistic nature of the underlying process, they attempt to overrule the math with authority.
The best estimates I’ve found are “This will take: days, weeks, months, years”. No numeric values allowed. Yes, you can’t do (inherently faulty) math on these estimates to arrive at aggregate metrics: this is a feature. However, it still allows you to meaningfully schedule work.
If pushed, I get my developers to give estimates in jumps of ~5x.
Their options are
2 days
2 weeks
2 months
10 months
Then I triple the estimates before sharing with the business.
We don't estimate individual tickets/bugs at all, just overarching projects.
I also ask the business to estimate the commercial/user impact of the projects too, and we track and report the reality against their estimate, to hold a bit of a mirror up to them and as a way of pushing back on doing pointless work. Those estimates we use similar orders of magnitude for - £1k, £10k, £100k, £1m, £10m.
Fermi estimations like these really help avoid protracted negotiations and the lack of precision is a feature that makes clear they are estimated.
What is an estimate for? It is really an estimate of cost where big-O is mostly developer cost and that gives a handle on the next part priority.
Both of these then add up to an illusion of control.
Software is quickly becoming the largest moving part of many many organisations - and trying to control it is likely the wrong approach
Software is a form of capital just like a robot on the Tesla assembly line. That robot and the software being estimated in the article are to do a specific job in a specific environment- an investment that will enable more production than without.
But all capital rots - or rather depreciates. Taking a nice view you can have 10% on maintenance and repairs (but realistically more than that).
Don’t try to estimate these - don’t ask your handyman for a Gantt chart for a hundred tiny fixes - just get them done.
I think you're identifying something adjacent but materially different: an attempt to estimate and wrangle ongoing maintenance, rather than an estimate for an initial development effort.
It's worth calling out that we (Apsis) are a software development agency; our estimates are for our clients, usually for greenfield work, and usually are part of the process of bidding for projects. A very different situation from an engineering team in year 5 of production deployment.
That said, even as a member of an internal engineering team, you'll need to coordinate work with the other areas of the business: you can't maneuver a large organization with no calendar for when new features, new products, etc., will become available. Estimates are an inherent part of engineering interacting with the rest of an organization, and I think this framework is still applicable.
So I think that the idea of “you cannot maneuver a large org without a calendar” is going back to tommdemarco and risk management as the soul of project mgmt
If you run a company and ask me for an estimate on when software will be ready because the rest of the company depends on it, then what you are doing is making a huge bet on the software team delivering to time and quality (and cost!). Now that’s just hoping.
There is plenty to do to fix it (reduce scope, improve team dynamics and psychological safety, dual delivery teams etc). But in the end it’s a bet, a guess.
Now perhaps there are better ways. I would suggest we look twice at using calendars and deadlines as ways of acgieveing co-ordination - software is waaay better at co-ordination than people and calendars are.
Adjust the business model, early releases for special
Clients - these can be non-software approaches to risk mitigation, but we find the tech solutions more fun.
Generally good advice, however I think the actual example phrases could still be clarified, e.g. bg explaining why clear estimates in software engineering are not as common as in other fields — note the person you are talking to might have a completely different experience in their field of work. And then you give your buest guess and a clear explaination of your level of confidence, which factors could lead to shorter or longer project durations.
A more interesting question is how you follow up on your estimates? How can you improve if you don't track and reflect on the actual result on what was estimated?
Fortunately for us, we have no choice! We (Apsis Labs) are a dev agency for hire: if our estimates are wrong, we lose our clients, and then we don't have money and then we all die of starvation.
Being good at estimating our work, and then communicating those estimates and expectations to our clients, is how we've stayed fed for 12 years.
Readit News
1. Never give an estimate in the same conversation in which it was requested, unless you're quite sure the answer is "less than an hour". Especially if they are going to turn around and quote your timeframe to a customer. The reason for this rule is:
2. The more you think about an estimate, the higher it will go. "Oh yeah and we'll also have to..." is 100x more common than "I found a shortcut that doesn't compromise on..."
3. Even if they know it's an estimate and not a deadline, they might not know the difference between "40 hours of dedicated effort" and "One week's worth of business hours". Making that distinction is just as important as the estimate/deadline distinction.
I'm lucky to work where we don't spend much effort on estimates and time tracking, both of which just make things take longer and cause productivity-reducing stress.
1FTE labor will be x hours but lead time can be couple weeks depending on where are we in development cycle.
This is excellent advice. At Apsis, we have a collection of "red flags" for any project that we call out specifically as likely sources of increased complexity and therefore a higher estimate. Some of these are:
* integrations external APIs
* existing tech from the client with no provided documentation
* any new infrastructure being spun up
This is the motivation for "story points", to avoid saying "hour" for the former.
(And secondarily, let the ratio of the two be discovered by analyzing previous work, in a stable team setting.)
The framing in this blog post is better than some (it at least discusses uncertainty) but I believe it’s still basically the wrong framework.
People (managers) like to assume that estimates are a random variable, and software projects are samples from project space. Estimates can be produced for a project by analogizing it to similar projects. This is not true at all. You cannot reason about software projects by analogy.
Some assertions (that I will explore in said promised blog post):
- Software development is chaotic: arbitrarily small changes in the input (project requirements, who’s implementing it, stakeholders, team, etc) may lead to arbitrarily large changes in time-to-completion (including “this project is now impossible”). In short, any project may explode at any moment prior to completion.
- The risk of a project is particularly sensitive to the engineer implementing it, and depends on that person’s specific knowledge. Have they used these APIs or this database before? Any part of a project that the engineer hasn’t used before represents potentially unbounded technical risk.
- the way to manage this risk is to include buffer in the project timeline, and, critically, to use that buffer not for development tasks that were harder than expected, but for re-planning and re-negotiating the deliverables with stakeholders, to un-explode the project. Agile builds this re-evaluation into the project lifecycle, which is the main (maybe only?) thing is does really right.
I, however, disagree with that approach to managing delivery: if you tie in expected value with deliverables, you empower and enable engineering teams to smartly cut scope and deliver in shorter amount of time the biggest chunk of the value.
It's usually only described as "cutting scope", but it requires real creativity and smarts on the engineering team (they can best tell what's feasible in remaining time, when they have tackled all the unknown unknowns you bring up) to do that in a way that still brings the most of the original value. If you move this to your "renegotiation" step, it becomes too slow and hurts delivery as well.
FWIW, though, engineers shouldn’t decide what to cut (i.e. choose alternatives) in a vacuum, in my experience. I’ve been in plenty of meetings with product/sales/support where they say “it’s better for the whole project to slip than to release it without this one detail” or “we would give up what seems like basic usability to get one particular piece of polish”
This is the only right answer. Unfortunately, engineering leadership is too detached from understanding how software works. They think of projects like contractor painting jobs. So easy to estimate - sq. ft * number of people * number of hours.
But software is not like that. Software is constantly changing every hour, every day. As a result, any estimation is changing every hour every day.
The best thing is for leadership to start acknowledging the realm they are dealing with. If they can't they should step down.
But realistically, engineers should always give 400% padding with estimates. The root cause of this estimation is poor leadership. It is not engineering team's problem that detached management doesn't understand software.
It's probably worth calling out that we are, specifically, outside contractors providing estimates for clients --- usually clients at the start of their software development journey. I think a lot of our framework holds for developers working on in-house engineering teams, but there are bound to be some differences.
That said, I'll be curious to read your post whenever it goes up. Namely because I don't know what the conclusion of your comment is. Whether it's as a vendor or as an engineer on staff, estimates are a hard requirement of software development. Most stakeholders are not developers, and you can only educate the recipients of your estimates so much on the nuances of what is and isn't hard to accommodate. I don't really disagree with any of your assertions --- but isn't the re-evaluation process simply... more estimation? Aren't accounting for project risks --- like which developer is going to pick up the task, what requirements are likely or unlikely to change --- part of producing a quality estimate?
Communicating expectations is hard, and to me, one of the defining lines between junior and senior developers is the ability to clearly account for expected risks, and identify plausible but unlikely risks, and to incorporate mitigation into the plan of attack.
Granted, I’m coming from a B2B startup rather than a consultancy, so I was working with a mixture of internal (product, sales, support) and external (customers) stakeholders. The perspective I would try to give people, though, was this:
If we discover a bomb partway through the project (oops, groups are limited to 100 members in this auth system, so we will need to find a new system and migrate or else not support groups) then 8 weeks will no longer be enough, but maybe neither is 24. The right thing for us to do in that situation, IMO, is go back to the stakeholders and align on a new plan. Maybe groups will come in v2, or some groups will work and some won’t, or maybe we do the migration and add it to the estimate, or whatever. One shouldn’t use the 16 buffer weeks between 8 and 24 to sneak in a backend migration (which itself might be a 16-week project, or might not), but to pause and re-align on a plan everyone likes.
When I was giving estimates, I would try to frame them as “we’ll spend eight weeks trying to accomplish this list of things. If we discover an issue that prevents us from finishing the list for any reason, we’ll come back to you as early as possible with some alternative proposals and re-assess”. Sometimes people felt that this meant we just weren’t willing to commit to our estimates, and this idea of “software development is chaotic” is what I would say, to explain that the issue wasn’t a lack of motivation, but an inescapable knowledge risk that needed to be managed.
Sometimes the computers don’t work the way you thought they did at the beginning. This is a normal and ubiquitous form of risk that just needs to be managed like any other type of risk, with prototypes, multiple revisions of the implementation (each introducing additional risk), occasionally re-scoping, etc.
People outside engineering sometimes don’t like it because the risk is human in origin—it comes from engineers not knowing things, and our job is to know things—but until there’s an omniscient engineer, this risk will continue to exist.
Edit: thanks for editing the comment to make it clearer what are your points. This makes my comment somewhat useless :)
The root cause is typically that you're communicating it to someone who doesn't want an estimate. In that case, communicating the estimate with the commitment is often a mistake unless you're willing to negotiate the commitment, because that's effectively what it invites.
It’s entirely possible to turn that to your advantage, but takes some luck/skill, not dissimilar to profiting off of stock market crashes.
The asymmetry between mathematics and authority tends to favour the math.
Their options are
2 days 2 weeks 2 months 10 months
Then I triple the estimates before sharing with the business.
We don't estimate individual tickets/bugs at all, just overarching projects.
I also ask the business to estimate the commercial/user impact of the projects too, and we track and report the reality against their estimate, to hold a bit of a mirror up to them and as a way of pushing back on doing pointless work. Those estimates we use similar orders of magnitude for - £1k, £10k, £100k, £1m, £10m.
Fermi estimations like these really help avoid protracted negotiations and the lack of precision is a feature that makes clear they are estimated.
Both of these then add up to an illusion of control.
Software is quickly becoming the largest moving part of many many organisations - and trying to control it is likely the wrong approach
Software is a form of capital just like a robot on the Tesla assembly line. That robot and the software being estimated in the article are to do a specific job in a specific environment- an investment that will enable more production than without. But all capital rots - or rather depreciates. Taking a nice view you can have 10% on maintenance and repairs (but realistically more than that).
Don’t try to estimate these - don’t ask your handyman for a Gantt chart for a hundred tiny fixes - just get them done.
It's worth calling out that we (Apsis) are a software development agency; our estimates are for our clients, usually for greenfield work, and usually are part of the process of bidding for projects. A very different situation from an engineering team in year 5 of production deployment.
That said, even as a member of an internal engineering team, you'll need to coordinate work with the other areas of the business: you can't maneuver a large organization with no calendar for when new features, new products, etc., will become available. Estimates are an inherent part of engineering interacting with the rest of an organization, and I think this framework is still applicable.
If you run a company and ask me for an estimate on when software will be ready because the rest of the company depends on it, then what you are doing is making a huge bet on the software team delivering to time and quality (and cost!). Now that’s just hoping.
There is plenty to do to fix it (reduce scope, improve team dynamics and psychological safety, dual delivery teams etc). But in the end it’s a bet, a guess.
Now perhaps there are better ways. I would suggest we look twice at using calendars and deadlines as ways of acgieveing co-ordination - software is waaay better at co-ordination than people and calendars are.
Adjust the business model, early releases for special Clients - these can be non-software approaches to risk mitigation, but we find the tech solutions more fun.
Being good at estimating our work, and then communicating those estimates and expectations to our clients, is how we've stayed fed for 12 years.